sandbox

type AccessKind string

type ApprovalRequiredError struct {
	Reason string
}

type ApprovalScope string

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

type Context struct {
	WorkingDirectory string
	WorkspaceRoot    string
	AdditionalRoots  []string
	Environment      EnvironmentKind
	SandboxEnabled   bool
}

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

type DaggerExecutorConfig struct {
	// BaseImage is the OCI image used for new environments.
	// Default: "ubuntu:24.04"
	BaseImage string

	// SetupCommands are shell commands run once when building the base image.
	// Example: ["apt-get update -y", "apt-get install -y python3 nodejs"]
	SetupCommands []string

	// WorkDir is the working directory inside the container.
	// Default: "/workdir"
	WorkDir string

	// Env is a set of KEY=VALUE pairs always injected into the container.
	Env map[string]string

	// StorageDir is the host directory where environment state is persisted.
	// Default: ~/.config/seshat/sandbox/
	StorageDir string

	// NetworkAccess controls whether the container can reach the internet.
	// Default: true (containers have internet access by default).
	// Set to false for fully air-gapped sandboxes.
	NetworkAccess bool
}

type DaggerRunOptions struct {
	// ExposePorts lists container ports to tunnel back to the host.
	// The RunResult.Endpoints map is populated with host:port mappings.
	ExposePorts []int

	// EnvironmentID selects a named, persistent environment.
	// Empty means the default session environment.
	EnvironmentID string
}

type Decision string

type DecisionResult struct {
	Decision Decision
	Reason   string
}

type EnvironmentKind string

type Executor interface {
	// Run executes a command inside the sandbox and streams its output.
	// Implementations must respect ctx cancellation and RunRequest.Timeout.
	Run(ctx context.Context, req RunRequest) (RunResult, error)

	// Kind identifies which backend this is.
	Kind() EnvironmentKind

	// Healthy returns nil when the executor is ready to accept work.
	// A non-nil error means the backend is unavailable (Dagger engine down,
	// Docker socket missing, etc). The engine calls this once at startup.
	Healthy(ctx context.Context) error
}

type ExecutorConfig struct {
	// Kind selects the backend. Defaults to EnvironmentLocal (noop).
	Kind EnvironmentKind

	// Dagger holds Dagger-specific configuration.
	// Only used when Kind == EnvironmentDocker.
	Dagger DaggerExecutorConfig
}

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

type NoopExecutor struct{}

type PathDecision struct {
	DecisionResult
	ResolvedPath string
}

type PermissionDecision struct {
	Decision      Decision
	Reason        string
	Scope         ApprovalScope
	ApprovedPaths []string
	Metadata      map[string]any
}

type PermissionDeniedError struct {
	Reason string
}

type PermissionRequest struct {
	ToolName       string
	Description    string
	Environment    EnvironmentKind
	Access         AccessKind
	Command        string
	Paths          []string
	NetworkTargets []string
	Justification  string
	Scope          ApprovalScope
	Metadata       map[string]any
}

type RunRequest struct {
	// Command is the shell command string to execute.
	// Passed as-is to the interpreter defined by Shell.
	Command string

	// Shell specifies the interpreter (default: /bin/sh -c).
	// Ignored by DaggerExecutor which always uses sh inside the container.
	Shell []string

	// Env is a set of KEY=VALUE pairs injected into the command environment
	// on top of the executor's base environment.
	Env map[string]string

	// WorkDir is the working directory for the command.
	// For DaggerExecutor, this is relative to the container's /workdir.
	WorkDir string

	// Stdin is connected to the command's standard input (may be nil).
	Stdin io.Reader

	// Timeout is the maximum duration for the command.
	// Zero means no timeout beyond the parent context deadline.
	Timeout time.Duration

	// Background requests a fire-and-forget execution (no output captured).
	// Used for long-running processes (servers, watchers).
	Background bool

	// Dagger-specific extensions — ignored by NoopExecutor.
	Dagger *DaggerRunOptions
}

type RunResult struct {
	// Stdout and Stderr capture the command output.
	// Empty when Background=true.
	Stdout string
	Stderr string

	// ExitCode is the process exit code. Non-zero indicates failure.
	ExitCode int

	// Duration is the wall-clock time the command took.
	Duration time.Duration

	// Endpoints maps exposed port numbers to "host:port" strings.
	// Populated by DaggerExecutor when DaggerRunOptions.ExposePorts is set.
	Endpoints map[int]string
}

type ToolAccessPreview struct {
	ToolName       string   `json:"tool_name"`
	Environment    string   `json:"environment,omitempty"`
	Access         string   `json:"access,omitempty"`
	Command        string   `json:"command,omitempty"`
	Paths          []string `json:"paths,omitempty"`
	NetworkTargets []string `json:"network_targets,omitempty"`
	Justification  string   `json:"justification,omitempty"`
}

type ToolPermissionOptions struct {
	ToolInput              map[string]any
	ToolUseID              string
	SessionID              types.SessionID
	TurnID                 types.TurnID
	PermissionMode         types.PermissionMode
	WorkingDirectory       string
	IsToolRunningInSandbox bool
	Stage                  types.ToolPermissionStage
	Intent                 types.ToolPermissionIntent
	Metadata               map[string]any
}