worker

type Backend interface {
	// ExecuteTask runs the agent for the given task parameters. Execution
	// failures are surfaced as ExecuteOutcomeError with an error that is (or
	// wraps) *TaskFailure.
	ExecuteTask(ctx context.Context, params *TaskParams) ExecuteResult
	// CancelTask requests cancellation after ExecuteTask returns. A nil error
	// means the request was accepted, not that asynchronous resources stopped.
	// Failed requests may be retried and must be execution-scoped and idempotent.
	CancelTask(ctx context.Context, params *CancelParams) error
	// PreservesTasksOnShutdown reports whether active task execution units can
	// safely outlive the worker process during shutdown.
	PreservesTasksOnShutdown() bool
	// Shutdown cleans up backend resources.
	Shutdown(ctx context.Context)
}

type CancelParams struct {
	TaskID      string
	ExecutionID string
}

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

type CommandBackendConfig struct {
	// DispatchCommand is the shell command invoked (via /bin/sh -c) to dispatch
	// a task. It receives the DispatchPayload as JSON on stdin. Required.
	DispatchCommand string
	// CancelCommand, when set, is invoked (via /bin/sh -c) to best-effort cancel
	// a previously dispatched task.
	CancelCommand string
	// DispatchTimeout bounds the dispatch command's runtime. Zero uses defaultDispatchTimeout.
	DispatchTimeout time.Duration
	// Env contains extra environment variables exposed to the dispatch and
	// cancel commands. Task env/secrets are NOT placed here; they travel only in
	// the JSON payload on stdin.
	Env map[string]string
	// ServerRootURL and WorkerID are copied into the dispatch payload.
	ServerRootURL string
	WorkerID      string
}

type Config struct {
	APIKey        string
	WorkerID      string
	WebSocketURL  string
	ServerRootURL string
	LogLevel      string
	BackendType   string // "docker", "direct", or "kubernetes"
	// MaxConcurrentTasks caps how many tasks may execute locally at once
	// (0 means unlimited). A task's slot is released when the backend's
	// ExecuteTask returns, so for backends that spawn tasks fire-and-forget
	// (e.g. command), a slot is held only for the brief dispatch and the limit
	// effectively does not bound the number of remote tasks running at once.
	MaxConcurrentTasks int
	// OneShot makes the worker accept one task and exit after it reaches a
	// terminal outcome. Backend support is validated before initialization.
	OneShot bool
	// IdleOnComplete is passed to the oz CLI's --idle-on-complete flag for every task.
	// Empty string means use the oz CLI default (45m). Use "0s" to disable idle.
	IdleOnComplete string
	// SessionSharingServerURL, when non-empty, is forwarded to the oz CLI via --session-sharing-server-url.
	SessionSharingServerURL string
	CollectTaskLogs         bool

	// Backend-specific configs. Only the one matching BackendType should be set.
	Docker     *DockerBackendConfig
	Direct     *DirectBackendConfig
	Kubernetes *KubernetesBackendConfig
	Command    *CommandBackendConfig
}

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

type DirectBackendConfig struct {
	WorkspaceRoot   string
	TargetDir       string // If set, run all tasks in this directory instead of creating per-task workspaces.
	OzPath          string // Path to the oz CLI binary. If empty, looks up "oz" in PATH.
	SetupCommand    string
	TeardownCommand string
	NoCleanup       bool
	Env             map[string]string
}

type DispatchPayload struct {
	Version       int                  `json:"version"`
	RunID         string               `json:"run_id"`
	ExecutionID   string               `json:"execution_id"`
	ServerRootURL string               `json:"server_root_url"`
	WorkerID      string               `json:"worker_id"`
	DockerImage   string               `json:"docker_image"`
	BaseArgs      []string             `json:"base_args"`
	Env           map[string]string    `json:"env"`
	Sidecars      []types.SidecarMount `json:"sidecars"`
	Task          *types.Task          `json:"task"`
}

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

type DockerBackendConfig struct {
	NoCleanup bool
	Volumes   []string
	Env       map[string]string
	// ImagePullPolicy controls how the main task image and every Warp/additional sidecar image
	// are resolved before use: PullPolicyAlways, PullPolicyIfNotPresent, or PullPolicyNever. An
	// empty value defaults to PullPolicyAlways, preserving the backend's original
	// unconditional-pull behavior for installations that don't set it.
	ImagePullPolicy string
	SidecarImage    string
}

type ExecuteOutcome int

type ExecuteResult struct {
	Outcome ExecuteOutcome
	Error   error
}

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

type KubernetesBackendConfig struct {
	WorkerID              string
	Namespace             string
	Kubeconfig            string
	DefaultImage          string
	ImagePullPolicy       string
	UseImageVolumes       bool
	PreflightImage        string
	SidecarImage          string
	SetupCommand          string
	TeardownCommand       string
	NoCleanup             bool
	ExtraLabels           map[string]string
	ExtraAnnotations      map[string]string
	ActiveDeadlineSeconds *int64
	TTLSecondsAfterFinish *int32
	WorkspaceSizeLimit    *resource.Quantity
	UnschedulableTimeout  *time.Duration
	// CodingCLISidecars maps harness config name (e.g. "claude", "codex") to a custom
	// Docker image for the coding CLI sidecar. When non-empty for a task's harness,
	// the worker overrides or injects the sidecar at /mnt/{harness}-cli-sidecar.
	CodingCLISidecars map[string]string
	// TaskEnv contains runtime-only env overrides from CLI -e/--env. Declarative
	// task container env in file or Helm config should be set in PodTemplate.
	TaskEnv map[string]string
	// PodTemplate, when non-nil, is the declarative PodSpec template for task
	// Jobs. Worker-required fields are overlaid at execution time.
	PodTemplate *corev1.PodSpec
	// PreflightResources, when non-nil, overrides the default cpu/memory
	// requests and limits applied to startup preflight Job containers.
	// Defaults: requests 10m CPU / 16Mi memory; limits 100m CPU / 64Mi memory.
	PreflightResources *corev1.ResourceRequirements
}

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

type TaskParams struct {
	TaskID      string
	ExecutionID string
	Task        *types.Task

	// EnvVars contains pre-resolved common environment variables (TASK_ID, Git config,
	// assignment env vars). Backends append their own config-specific env vars.
	EnvVars []string

	// BaseArgs contains the base CLI arguments for the agent command
	// (agent run --share ... --task-id ... --server-root-url ... + augmented args).
	// Backends prepend their invocation prefix and append backend-specific flags.
	BaseArgs []string

	// DockerImage is the resolved Docker image name (with default fallback applied).
	// Backends that don't use Docker can ignore this.
	DockerImage string

	// Sidecars is the unified list of sidecar mounts for this task. The Warp agent
	// sidecar (mounted at /agent) is included as the first entry when present, followed
	// by any additional sidecars from the assignment. Backends that don't use sidecars
	// can ignore this.
	Sidecars []types.SidecarMount

	// InstanceShape, when non-nil, is the resolved compute size for this task.
	// Containerized backends apply it as CPU/memory limits (Docker) or resource
	// requests/limits (Kubernetes). Backends that cannot enforce a shape (direct) ignore it.
	InstanceShape *types.InstanceShape

	// SetupEvents reports worker-observed setup phase durations to warp-server.
	// It may be nil, and all of its methods are safe to call on a nil reporter.
	SetupEvents *setupEventReporter
	Logs        *tasklogs.Reporter
}

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