scriptexec

type Config struct {
	// DB backs the run, script, and version stores. A nil DB with no stores
	// supplied disables the feature: New returns nil and every method on the
	// nil handle is a no-op.
	DB *sql.DB

	// Runs, Scripts, Versions and Schedules, when non-nil, are used directly
	// instead of building PostgreSQL stores from DB. Production passes DB and
	// leaves them nil; they exist so the execution side can be assembled over
	// in-memory stores, which is the only way to exercise the worker, the
	// engine, and the middleware chain together without a database. The same
	// shape as scriptlayer.Config.Store.
	Runs      script.RunStore
	Scripts   ScriptReader
	Versions  VersionReader
	Schedules script.ScheduleStore

	// DSN is the raw database DSN for the LISTEN connection that wakes the
	// worker the moment a run is enqueued. Empty degrades to poll-only.
	DSN string

	// Server is the assembled MCP server a run drives over an in-memory
	// session. A nil server leaves the worker running but every run fails with
	// "script execution is unavailable", which is the honest report.
	Server *mcp.Server

	// Export carries the portal dependencies platform.export writes through. An
	// incomplete set leaves scripts able to query and unable to persist, which
	// each affected run reports.
	Export ExportDeps

	// PortalURL is the deployment's public portal address, from which a run's
	// own page is built: the link a platform.notify post carries when the
	// script names none (#1723). Empty omits the link.
	PortalURL string
	// Destinations is the deployment's configured bucket destinations, which a
	// run resolves platform.export names against at run time.
	Destinations []script.Destination

	// Metrics records what the run queue is doing: runs by script, trigger and
	// status, their duration, how many are executing on this replica, and the
	// fires the misfire policy stepped over (#1307). Optional — every method on
	// it is nil-safe — but without it the automations are invisible to an
	// operator watching the platform rather than reading the run table.
	Metrics *observability.Metrics

	// Audit records the script_run lifecycle event. Optional.
	Audit middleware.AuditLogger

	// Subjects tells a run the subject its author's own session authenticates
	// as, so the run files managed resources in the library that session files
	// in rather than one keyed by the author's address (#1677). Nil leaves a
	// run keyed by address.
	Subjects SubjectResolver

	// Notifier queues the alert a failed SCHEDULED run raises. When nil and DB
	// is set, one is built over the notification queue unless
	// NotificationsDisabled says the deployment turned notifications off.
	Notifier Notifier

	// NotificationsDisabled mirrors notifications.enabled: false in YAML.
	NotificationsDisabled bool

	// DigestHourUTC is the hour daily digests are scheduled for, for a
	// recipient whose delivery mode is daily.
	DigestHourUTC int

	// RunRetention overrides DefaultRunRetention.
	RunRetention time.Duration

	// WorkerDisabled leaves this replica serving without ever claiming from the
	// run queue. run_script still enqueues and still waits on the result, which
	// a separate deployment of the same binary with the worker on produces, so
	// script execution scales apart from serving and a pathological script
	// reaches no pod an agent is talking to. The zero value runs the worker,
	// which is the single-binary default.
	WorkerDisabled bool
}

type Draft struct {
	// Script is the record the draft runs as. A draft of a script that is not
	// saved yet carries a record with a name and no id.
	Script *script.Script
	// RunID is the draft's own id, the session every call it makes records.
	RunID string
	// Email and Subject are the person running the draft, and Roles the roles
	// their session holds. A library output lands in that person's library,
	// which is where a platform run of the same script, acting for them as its
	// author, would land it.
	Email   string
	Subject string
	Roles   []string
	// Caller is the draft's own session, which a bucket delivery is made over.
	Caller scriptrun.Caller
}

type ExportDeps struct {
	Assets   portal.AssetStore
	Versions portal.VersionStore
	S3       portal.S3Client
	Bucket   string
	Prefix   string
	// FollowTables, when set, is called after every version an output writes,
	// so the tables registered over the output's file follow it (#1536). It
	// returns what happened to each table, which the run records on the
	// output and prints into its log. Nil on a deployment that cannot
	// register tables.
	FollowTables func(ctx context.Context, assetID string, version int) []string
	// Lander writes an output into the managed resource at a path, creating the
	// file the first time and recording a new version of it after (#1663). It is
	// what the built-in "resources" destination writes through. Nil leaves that
	// destination reporting that this deployment has no library, which is what a
	// deployment without one should say.
	Lander ResourceLander
}

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

type Notifier interface {
	Notify(ctx context.Context, recipient, category string, p notification.Payload) (bool, error)
}

type ResourceLander interface {
	Land(
		ctx context.Context, dest toolkit.ResourceDestination,
		content io.Reader, contentType string, claims resource.Claims,
	) (*toolkit.ResourceLanding, error)
}

type ScriptReader interface {
	GetByID(ctx context.Context, id string) (*script.Script, error)
}

type SubjectResolver interface {
	// ForRun returns the subject the address most recently authenticated as,
	// with what that address filed folded into the subject's library, or ""
	// when the platform has not seen the person authenticate.
	ForRun(ctx context.Context, address string) string
}

type VersionReader interface {
	GetVersionByID(ctx context.Context, id string) (*script.Version, error)
	GetVersion(ctx context.Context, scriptID string, version int) (*script.Version, error)
}