core

type CommandSender interface {
	SendCommand(runnerID string, cmd *pb.ServerCommand) error
}

type ConnectionManagerInterface interface {
	IsConnected(runnerID string) bool
	UpdateLastSeen(runnerID string) error
}

type ContextSnapshot struct {
	// WorkingDirectory is the agent's current working directory.
	WorkingDirectory string `json:"working_directory,omitempty"`

	// Environment contains environment variables to restore.
	Environment map[string]string `json:"environment,omitempty"`

	// ConversationID is the agent's conversation ID (for agents that support it).
	// This allows the agent to continue the conversation after resume.
	ConversationID string `json:"conversation_id,omitempty"`

	// AgentState contains agent-specific state as raw JSON.
	// This is opaque to the server and passed directly to the agent on resume.
	AgentState json.RawMessage `json:"agent_state,omitempty"`

	// LastActivity is when the session was last active.
	LastActivity time.Time `json:"last_activity"`

	// Version is the snapshot format version for compatibility checking.
	Version int `json:"version"`

	// AgentVersion is the agent version that created this snapshot.
	// Used to check compatibility on resume.
	AgentVersion string `json:"agent_version,omitempty"`

	// PendingPermissions contains IDs of pending permission requests.
	// These need to be delivered to the agent on resume.
	PendingPermissions []string `json:"pending_permissions,omitempty"`

	// TaskContext contains information about the current/last task.
	TaskContext *TaskContextSnapshot `json:"task_context,omitempty"`
}

type CreatePermissionRequestInput struct {
	OriginalRequestID   string // Original request ID from agent (e.g., tool_use_id)
	SessionID           string
	TaskID              string
	RunID               string
	Tool                string
	Action              string
	Context             string
	RiskLevel           string
	SuspendAfterSeconds int
	TenantID            *string
}

type CreateScheduledTaskOptions struct {
	SessionID              string            // Required
	Name                   string            // Required
	Description            string            // Optional
	CronExpression         string            // Required: e.g., "0 9 * * 1-5"
	Timezone               string            // Default: "UTC"
	PromptTemplate         string            // Required: may contain {{.Date}}, {{.RunNumber}}
	TimeoutSeconds         int               // Default: 3600
	MaxRetries             int               // Default: 0
	OnFailure              string            // Default: "continue"
	MaxConsecutiveFailures *int              // Default: 3
	TenantID               *string           // For multi-tenant deployments
	Labels                 map[string]string // Optional metadata labels
	Annotations            map[string]string // Optional metadata annotations
}

type CreateSessionOptions struct {
	Name          *string           // Optional session name
	WorkspaceID   string            // Required
	Agent         string            // Required (e.g., "claude")
	IsBYOK        bool              // Whether using BYOK mode
	AgentConfigID *string           // Optional, for managed credentials
	ProfileID     *string           // Optional, for runner configuration
	LifecycleMode string            // on_demand, always_on, scheduled
	IdleTimeout   *int              // Seconds (for on_demand mode)
	NetworkPolicy string            // none, allow_list, proxy, air_gapped
	AllowedHosts  []string          // For allow_list network policy
	ScheduleCron  *string           // Required for scheduled mode
	ScheduleTZ    *string           // Timezone for scheduled mode
	TenantID      *string           // For multi-tenant deployments
	Labels        map[string]string // Optional metadata labels
	Annotations   map[string]string // Optional metadata annotations
}

type CreateTaskOptions struct {
	SessionID      string            // Required
	Prompt         string            // Required
	MaxRetries     int               // Default: 0
	TimeoutSeconds int               // Default: 3600
	TenantID       *string           // For multi-tenant deployments
	Labels         map[string]string // Optional metadata labels
	Annotations    map[string]string // Optional metadata annotations
}

type CreateWebhookInput struct {
	Name              string
	URL               string
	Events            []string
	MaxRetries        *int
	RetryDelaySeconds *int
	TimeoutSeconds    *int
	Headers           map[string]string
	TenantID          *string
	Labels            map[string]string
	Annotations       map[string]string
}

type CreateWorkspaceOptions struct {
	Name        string            // Optional workspace name
	Persist     *bool             // Whether to persist workspace (default: true)
	StorageType string            // Storage type (default: "volume")
	Mobility    string            // Mobility mode (default: "local")
	DiskQuotaMB *int              // Disk quota in MB (nil for default)
	TenantID    *string           // For multi-tenant deployments
	Labels      map[string]string // Optional metadata labels
	Annotations map[string]string // Optional annotations
}

type ListPermissionRequestsOptions = store.ListPermissionRequestsOptions

type ListScheduledTasksOptions = store.ListScheduledTasksOptions

type ListSessionsOptions = store.ListSessionsOptions

type ListTaskRunsOptions = store.ListTaskRunsOptions

type ListTasksOptions = store.ListTasksOptions

type ListWorkspacesOptions struct {
	Limit    int
	Cursor   string
	TenantID *string
}

type LogSubscriberManager struct {
	// contains filtered or unexported fields
}

type LogSubscriberManagerInterface interface {
	// Broadcast sends a log entry to all subscribers for the session.
	Broadcast(log *store.Log)
	// Subscribe registers a channel to receive logs for a session.
	Subscribe(sessionID string, ch chan *store.Log)
	// Unsubscribe removes a channel from session subscriptions.
	Unsubscribe(sessionID string, ch chan *store.Log)
}

type PermissionManager struct {
	// contains filtered or unexported fields
}

type PermissionManagerInterface interface {
	// Create stores a new permission request from runner.
	Create(ctx context.Context, req *CreatePermissionRequestInput) (*store.PermissionRequest, error)
	// Respond approves or denies a permission request.
	Respond(ctx context.Context, permID string, approved bool, reason, respondedBy string) error
	// Get retrieves a permission request by ID.
	Get(ctx context.Context, permID string) (*store.PermissionRequest, error)
	// List retrieves permission requests with filters.
	List(ctx context.Context, opts ListPermissionRequestsOptions) (*store.ListResult[store.PermissionRequest], error)
	// Cancel cancels a pending permission request.
	Cancel(ctx context.Context, permID string) error
}

type PermissionTimeoutEnforcer struct {
	// contains filtered or unexported fields
}

type PermissionTimeoutEnforcerOption func(*PermissionTimeoutEnforcer)

type ProfileNetwork struct {
	Level        string   `json:"level"`         // "none", "allow_list", "proxy", "air_gapped"
	AllowedHosts []string `json:"allowed_hosts"` // For allow_list mode
}

type ProfileResources struct {
	CPU    int    `json:"cpu"`
	Memory string `json:"memory"` // e.g., "8GB"
	Disk   string `json:"disk"`   // e.g., "50GB"
}

type ProfileSelector struct {
	OS           string   `json:"os,omitempty"`           // e.g., "darwin", "linux"
	Arch         string   `json:"arch,omitempty"`         // e.g., "arm64", "amd64"
	Capabilities []string `json:"capabilities,omitempty"` // e.g., ["gpu", "xcode"]
}

type PromptTemplateData struct {
	Date         string // Current date in YYYY-MM-DD format
	DateTime     string // Current date and time in RFC3339 format
	RunNumber    int    // Total number of runs including this one
	TaskName     string // Name of the scheduled task
	SessionID    string // Session ID
	ScheduledFor string // Scheduled run time in RFC3339 format
}

type ProviderRegistryInterface interface {
	// GetDefault returns the default provider.
	GetDefault(ctx context.Context) (provider.Provider, error)
	// Get returns a provider by name.
	Get(ctx context.Context, name string) (provider.Provider, error)
}

type RegisterRequest struct {
	Token        string            // Runner token (required)
	Name         string            // Runner name
	Hostname     string            // Runner hostname
	SandboxMode  string            // Sandbox mode
	SandboxTypes []string          // Available sandbox types
	Capabilities []string          // Runner capabilities
	Labels       map[string]string // Key-value labels
}

type RegisterResult struct {
	RunnerID string // The runner ID (new or existing)
	IsNew    bool   // True if a new runner was created
	PoolName string // Pool name from token
}

type ResumeResult struct {
	// Session is the resumed session.
	Session *store.Session

	// ContextSnapshot is the saved context to restore.
	ContextSnapshot *ContextSnapshot

	// SuspendStrategy is the strategy used when suspended.
	SuspendStrategy string

	// SnapshotID is the snapshot ID if one was created during suspend.
	SnapshotID string

	// WorkspaceSynced indicates if workspace was synced during suspend.
	WorkspaceSynced bool
}

type RunnerManager struct {
	// contains filtered or unexported fields
}

type RunnerManagerInterface interface {
	OnConnect(ctx context.Context, runnerID string) error
	OnDisconnect(ctx context.Context, runnerID string) error
	OnHeartbeat(ctx context.Context, runnerID string, hb *pb.Heartbeat) error
	SetStatus(ctx context.Context, runnerID, status string) error
}

type RunnerManagerOption func(*RunnerManager)

type RunnerRegistry struct {
	// contains filtered or unexported fields
}

type ScheduledSessionActivator struct {
	// contains filtered or unexported fields
}

type ScheduledSessionActivatorConfig struct {
	Store         store.Store
	SessionMgr    SessionManagerInterface
	CheckInterval time.Duration
	BatchSize     int
	Logger        *zap.Logger
}

type ScheduledTaskExecutor struct {
	// contains filtered or unexported fields
}

type ScheduledTaskExecutorOption func(*ScheduledTaskExecutor)

type ScheduledTaskService struct {
	// contains filtered or unexported fields
}

type ScheduledTaskServiceInterface interface {
	Create(ctx context.Context, opts CreateScheduledTaskOptions) (*store.ScheduledTask, error)
	Get(ctx context.Context, taskID string) (*store.ScheduledTask, error)
	List(ctx context.Context, opts ListScheduledTasksOptions) (*store.ListResult[store.ScheduledTask], error)
	Update(ctx context.Context, taskID string, opts UpdateScheduledTaskOptions) (*store.ScheduledTask, error)
	Delete(ctx context.Context, taskID string) error
	Pause(ctx context.Context, taskID string) error
	Resume(ctx context.Context, taskID string) error
	Trigger(ctx context.Context, taskID string) (*store.Task, error)
	GetDue(ctx context.Context, limit int) ([]*store.ScheduledTask, error)
	ExecuteScheduledTask(ctx context.Context, scheduledTask *store.ScheduledTask) (*store.Task, error)
	MarkTaskCompleted(ctx context.Context, scheduledTaskID string, success bool) error
	CalculateNextRunAt(cronExpr, timezone string, after time.Time) (*time.Time, error)
}

type SessionManager struct {
	// contains filtered or unexported fields
}

type SessionManagerConfig struct {
	Store            store.Store
	ConnManager      ConnectionManagerInterface
	CmdSender        CommandSender
	WorkspaceManager WorkspaceManagerInterface
	AuditLog         audit.Logger
	ProviderRegistry ProviderRegistryInterface
	Logger           *zap.Logger
}

type SessionManagerInterface interface {
	Create(ctx context.Context, opts CreateSessionOptions) (*store.Session, error)
	Get(ctx context.Context, sessionID string) (*store.Session, error)
	List(ctx context.Context, opts ListSessionsOptions) (*store.ListResult[store.Session], error)
	Activate(ctx context.Context, sessionID, runnerID string) error
	Suspend(ctx context.Context, sessionID, strategy string) error
	Resume(ctx context.Context, sessionID string) error
	Terminate(ctx context.Context, sessionID string) error
	AttachRunner(ctx context.Context, sessionID, runnerID string) error
	DetachRunner(ctx context.Context, sessionID string) error
	UpdateContextSnapshot(ctx context.Context, sessionID string, snapshot *ContextSnapshot) error
}

type StaleDetector struct {
	// contains filtered or unexported fields
}

type StaleDetectorOption func(*StaleDetector)

type StreamManager struct {
	// contains filtered or unexported fields
}

type StreamManagerConfig struct {
	// Manager configuration
	Manager manager.Config

	// WebSocket configuration
	WebSocketReadBufferSize  int
	WebSocketWriteBufferSize int
	AllowedOrigins           []string
}

type SuspendOptions struct {
	// Strategy specifies how to handle the suspend (pause, snapshot, etc.).
	Strategy string

	// ContextSnapshot is the context to save with the session.
	// If nil, a basic snapshot is created automatically.
	ContextSnapshot *ContextSnapshot

	// WorkspaceSynced indicates if workspace was synced to object storage.
	WorkspaceSynced bool

	// SnapshotID is the ID of any snapshot created during suspend.
	SnapshotID string
}

type TaskCompletedResult struct {
	RunID        string
	Success      bool
	Error        string
	ExitCode     *int
	TokensInput  int
	TokensOutput int
}

type TaskContextSnapshot struct {
	// TaskID is the current task ID.
	TaskID string `json:"task_id,omitempty"`

	// RunID is the current task run ID.
	RunID string `json:"run_id,omitempty"`

	// Status is the task status when suspended.
	Status string `json:"status,omitempty"`

	// Progress is the estimated task progress (0-100).
	Progress int `json:"progress,omitempty"`
}

type TaskManager struct {
	// contains filtered or unexported fields
}

type TaskManagerInterface interface {
	Create(ctx context.Context, opts CreateTaskOptions) (*store.Task, error)
	Get(ctx context.Context, taskID string) (*store.Task, error)
	List(ctx context.Context, opts ListTasksOptions) (*store.ListResult[store.Task], error)
	Cancel(ctx context.Context, taskID string) error
	Execute(ctx context.Context, taskID string) error
	ReExecute(ctx context.Context, taskID string) error
	CreateRun(ctx context.Context, taskID string) (*store.TaskRun, error)
	OnTaskAccepted(ctx context.Context, runID string) error
	OnTaskStarted(ctx context.Context, runID string) error
	OnTaskProgress(ctx context.Context, runID string, progress int) error
	OnTaskCompleted(ctx context.Context, result *TaskCompletedResult) error
	FailRun(ctx context.Context, runID, reason string) error
	ShouldRetry(ctx context.Context, taskID string) (bool, error)
	Retry(ctx context.Context, taskID string) (*store.TaskRun, error)
}

type TaskTimeoutEnforcer struct {
	// contains filtered or unexported fields
}

type TaskTimeoutEnforcerOption func(*TaskTimeoutEnforcer)

type UpdateScheduledTaskOptions struct {
	Name                   *string
	Description            *string
	CronExpression         *string
	Timezone               *string
	PromptTemplate         *string
	TimeoutSeconds         *int
	MaxRetries             *int
	OnFailure              *string
	MaxConsecutiveFailures *int
	Labels                 map[string]string
	Annotations            map[string]string
}

type UpdateWebhookInput struct {
	Name              *string
	URL               *string
	Events            []string
	IsActive          *bool
	MaxRetries        *int
	RetryDelaySeconds *int
	TimeoutSeconds    *int
	Headers           map[string]string
	Labels            map[string]string
	Annotations       map[string]string
}

type WebhookDispatcher interface {
	Dispatch(ctx context.Context, eventType string, resource webhook.ResourceInfo, data any, tenantID *string) error
}

type WebhookIntegration struct {
	// contains filtered or unexported fields
}

type WebhookManager struct {
	// contains filtered or unexported fields
}

type WebhookManagerInterface interface {
	// Webhook CRUD
	Create(ctx context.Context, input *CreateWebhookInput) (*store.Webhook, string, error)
	Get(ctx context.Context, webhookID string) (*store.Webhook, error)
	GetByName(ctx context.Context, name string, tenantID *string) (*store.Webhook, error)
	List(ctx context.Context, opts store.ListWebhooksOptions) (*store.ListResult[store.Webhook], error)
	Update(ctx context.Context, webhookID string, input *UpdateWebhookInput) error
	Delete(ctx context.Context, webhookID string) error
	RotateSecret(ctx context.Context, webhookID string) (string, error)

	// Event dispatch
	Dispatch(ctx context.Context, eventType string, resource webhook.ResourceInfo, data any, tenantID *string) error

	// Webhook events
	GetEvent(ctx context.Context, eventID string) (*store.WebhookEvent, error)
	ListEvents(ctx context.Context, opts store.ListWebhookEventsOptions) (*store.ListResult[store.WebhookEvent], error)
	RetryEvent(ctx context.Context, eventID string) error
}

type WorkspaceManager struct {
	// contains filtered or unexported fields
}

type WorkspaceManagerInterface interface {
	Create(ctx context.Context, opts CreateWorkspaceOptions) (*store.Workspace, error)
	Get(ctx context.Context, workspaceID string) (*store.Workspace, error)
	List(ctx context.Context, opts ListWorkspacesOptions) (*store.ListResult[store.Workspace], error)
	Update(ctx context.Context, workspaceID string, updates store.WorkspaceUpdates) (*store.Workspace, error)
	Delete(ctx context.Context, workspaceID string) error
	GetHostPath(ctx context.Context, workspaceID string) (string, error)
	EnsureHostDirectory(ctx context.Context, workspaceID string) (string, error)
	CleanupHostDirectory(ctx context.Context, workspaceID string) error
	IsInUse(ctx context.Context, workspaceID string) (bool, error)
}

type WorkspaceStore interface {
	CreateWorkspace(ctx context.Context, ws *store.Workspace) error
	GetWorkspace(ctx context.Context, id string) (*store.Workspace, error)
	ListWorkspaces(ctx context.Context, opts store.ListWorkspacesOptions) (*store.ListResult[store.Workspace], error)
	UpdateWorkspace(ctx context.Context, id string, updates store.WorkspaceUpdates) error
	DeleteWorkspace(ctx context.Context, id string) error
	ListSessions(ctx context.Context, opts store.ListSessionsOptions) (*store.ListResult[store.Session], error)
}