eve 0.82.0 → 0.83.1

package/dist/src/sandbox/provider.d.ts

@@ -0,0 +1,185 @@
+import { type SandboxEnvironment, type SandboxSelectorContext } from "#shared/sandbox-environment.js";
+import type { SandboxPreparedArtifact, SandboxProviderFiles } from "#shared/sandbox-provider.js";
+import type { SandboxProcess, SandboxRemovePathOptions, SandboxSession, SandboxWriteFilesOptions } from "#shared/sandbox-session.js";
+/** A JSON-compatible value: what a provider may return as an artifact or session state. */
+export type SandboxJson = SandboxPreparedArtifact;
+/** Members eve owns on every live sandbox, which a connection's extensions cannot replace. */
+type ReservedSessionMember = keyof SandboxSession | "delete" | "stop";
+/**
+ * The byte-level connection to one sandbox that a provider implements. eve
+ * derives the full {@link SandboxSession} from it.
+ *
+ * Every path a connection receives is absolute, and `workingDirectory` is
+ * always set: eve resolves relative paths from {@link workspaceRoot}.
+ */
+export interface SandboxConnection<Extensions extends object = {}> {
+    /**
+     * The absolute sandbox directory that relative paths resolve from and
+     * commands start in by default. Defaults to `/workspace`. The directory
+     * must exist when eve first runs a command.
+     */
+    readonly workspaceRoot?: string;
+    /**
+     * Runs `command` as a Bash login-shell script (`bash -lc`) in
+     * `workingDirectory`, with the sandbox's environment plus `env`. `env`
+     * holds only the per-call variables. Aborting kills the process tree.
+     */
+    spawn(options: {
+        readonly abortSignal?: AbortSignal;
+        readonly command: string;
+        readonly env: Readonly<Record<string, string>>;
+        readonly workingDirectory: string;
+    }): Promise<SandboxProcess>;
+    /**
+     * Resolves to `null` only when the path does not exist. A directory or an
+     * unreadable path rejects. Return bytes or a stream, whichever the backend has.
+     */
+    readFile(options: {
+        readonly abortSignal?: AbortSignal;
+        readonly path: string;
+    }): Promise<Uint8Array | ReadableStream<Uint8Array> | null>;
+    /** Creates missing parent directories and overwrites existing files. The only write primitive. */
+    writeFiles(options: SandboxWriteFilesOptions): Promise<void>;
+    /** `force` ignores a missing path; `recursive` removes a non-empty directory. */
+    removePath(options: SandboxRemovePathOptions): Promise<void>;
+    /** Releases compute and keeps the sandbox's files. */
+    stop(): Promise<void>;
+    /** Releases what this process holds, such as a local interpreter, without touching the sandbox. */
+    close?(): Promise<void>;
+    /**
+     * Provider capabilities merged onto the session, such as `setNetworkPolicy`.
+     * A plain object: eve merges its own enumerable properties, so use closures
+     * rather than class methods. A member named like a session method is a type
+     * error, and eve rejects it.
+     */
+    readonly extensions?: Extensions & {
+        readonly [Key in ReservedSessionMember]?: never;
+    };
+}
+/** What eve passes to `start()`, `resume()`, and `onSessionEnd()`. */
+export interface SandboxSessionContext {
+    /**
+     * The session that owns the sandbox. Derive native names from `session.id`:
+     * for a subagent that shares its parent's sandbox it is the parent's id, and
+     * for a keyed `invokeTool` call it is the derived tool-session id.
+     */
+    readonly session: SandboxSelectorContext["session"];
+    /** `"tool-session"` for a keyed `invokeTool` call's sandbox, `"session"` otherwise. */
+    readonly kind: "session" | "tool-session";
+    /** A host directory the provider may use for local state. */
+    readonly storagePath: string;
+    /** Resolves a path relative to the app's project root on the host. */
+    resolveProjectPath(path: string): string;
+}
+/**
+ * Values hashed into a template key: JSON values, `undefined` (omitted),
+ * plain objects and arrays, and functions (hashed by their source). Other
+ * values and circular structures reject.
+ */
+export type SandboxIdentity = {
+    readonly [key: string]: unknown;
+};
+/**
+ * What eve passes to `prepare()` while it builds a template. Not generic over
+ * the provider's extensions, so TypeScript infers them from `start()`.
+ */
+export interface SandboxPrepareContext {
+    /** Authored files under the agent's `sandbox/` directory. */
+    readonly files: SandboxProviderFiles;
+    /** `true` when there are no workspace or skill files and no authored `prepare`. */
+    readonly isEmpty: boolean;
+    readonly storagePath: string;
+    /** Reports build progress, such as `eve build` output. */
+    log(message: string): void;
+    /**
+     * Seeds the connection's workspace root and `$HOME/.agents/skills`, then
+     * runs the authored `prepare` with a session over `connection`. With
+     * `mountedAt`, the provider has mounted {@link resourcesDirectory}
+     * read-only at that sandbox path, and eve copies from it instead of
+     * writing every file.
+     */
+    populate(connection: SandboxConnection<object>, options?: {
+        readonly mountedAt?: string;
+    }): Promise<void>;
+    resolveProjectPath(path: string): string;
+    /** A stable read-only host directory holding `workspace/` and `skills/`, when one exists. */
+    resourcesDirectory(): Promise<string | undefined>;
+    /**
+     * Hashes `identity` together with the workspace files, skill files, and
+     * sandbox source revision into a stable SHA-256 hex key. `resources` and
+     * `sourceRevision` are reserved.
+     */
+    templateKey(identity: SandboxIdentity): string;
+}
+export interface SandboxSessionEndOptions {
+    readonly abortSignal?: AbortSignal;
+    readonly reason: "completed" | "expired" | "failed" | "deleted";
+}
+/** The lifecycle one sandbox environment implements. */
+export interface SandboxProviderImplementation<OpenOptions extends object | undefined, Artifact extends SandboxJson, State extends SandboxJson, Extensions extends object> {
+    /**
+     * Builds a template during `eve build`, or on first access in `eve dev`, and
+     * returns the JSON artifact that ships with the deployment. Call
+     * `ctx.populate()` on the build instance before capturing it.
+     */
+    prepare(ctx: SandboxPrepareContext): Promise<Artifact>;
+    /**
+     * Returns the sandbox for `ctx.session.id`, creating it when none exists.
+     * An idempotent upsert: repeated, concurrent, cross-process, and
+     * cross-deployment calls return the same sandbox while it exists. Derive
+     * native identity from `ctx.session.id` and a provider-level namespace
+     * only; `options` and `artifact` apply only when this call creates it.
+     */
+    start(ctx: SandboxSessionContext, options: Readonly<OpenOptions> | undefined, artifact: Readonly<Artifact>): Promise<{
+        readonly connection: SandboxConnection<Extensions>;
+        readonly state: State;
+    }>;
+    /**
+     * Reconnects to the sandbox `state` names, never recreating it. Throw
+     * `SandboxSessionGoneError` when it no longer exists.
+     */
+    resume(ctx: SandboxSessionContext, artifact: Readonly<Artifact>, state: Readonly<State>): Promise<SandboxConnection<Extensions>>;
+    /**
+     * Deletes whatever exists for `ctx.session.id`. `state` is `null` when the
+     * session never recorded it. Must succeed when nothing exists and be
+     * idempotent. `sandbox.delete()` also lands here, with `reason: "deleted"`.
+     */
+    onSessionEnd(ctx: SandboxSessionContext, state: Readonly<State> | null, options: SandboxSessionEndOptions): Promise<void>;
+    /**
+     * Lets a keyed `invokeTool` call keep its sandbox between calls. eve never
+     * ends a keyed sandbox, so the provider must bound its retention.
+     */
+    readonly toolSessions?: true;
+}
+export interface SandboxPrepareOption<Session> {
+    /** Runs once per template, after eve seeds workspace and skill files. */
+    readonly prepare?: (sandbox: Session) => void | Promise<void>;
+}
+/** Environment options plus the standard `prepare` option. */
+export type WithPrepareOption<Options extends object, Session> = Options & SandboxPrepareOption<Session>;
+export interface SandboxProviderDefinition<EnvironmentOptions extends object, OpenOptions extends object | undefined, Artifact extends SandboxJson, State extends SandboxJson, Extensions extends object> {
+    readonly name: string;
+    /** Bump when `State` changes incompatibly; recorded state from another version starts fresh. */
+    readonly stateProtocolVersion?: number;
+    /**
+     * Receives the environment options without `prepare`, which eve runs in
+     * `ctx.populate()`. Always an object: `{}` when the caller passes none.
+     */
+    environment(options: EnvironmentOptions): SandboxProviderImplementation<OpenOptions, Artifact, State, Extensions>;
+}
+type SandboxOptionArguments<Options extends object | undefined> = Options extends undefined ? [options?: undefined] : Record<never, never> extends Options ? [options?: Readonly<Options>] : [options: Readonly<Options>];
+export interface SandboxProvider<EnvironmentOptions extends object | undefined, OpenOptions extends object | undefined, Session extends SandboxSession> {
+    readonly name: string;
+    environment(...args: SandboxOptionArguments<EnvironmentOptions>): SandboxEnvironment<OpenOptions, Session>;
+}
+/** What core runs for one environment: the provider's lifecycle with its types erased. */
+export interface SandboxProviderRuntime {
+    readonly implementation: SandboxProviderImplementation<object | undefined, SandboxJson, SandboxJson, object>;
+    /** The authored `prepare` option, which eve runs in `ctx.populate()`. */
+    readonly prepare: ((sandbox: SandboxSession) => void | Promise<void>) | undefined;
+    readonly providerName: string;
+    readonly stateProtocolVersion: number;
+}
+/** Defines a sandbox provider from a connection and a lifecycle. */
+export declare function defineSandboxProvider<EnvironmentOptions extends object = {}, OpenOptions extends object | undefined = undefined, Artifact extends SandboxJson = SandboxJson, State extends SandboxJson = SandboxJson, Extensions extends object = {}>(definition: SandboxProviderDefinition<EnvironmentOptions, OpenOptions, Artifact, State, Extensions>): SandboxProvider<WithPrepareOption<EnvironmentOptions, SandboxSession & Extensions>, OpenOptions, SandboxSession & Extensions>;
+export {};

package/dist/src/sandbox/provider.js

@@ -0,0 +1 @@
+import{createSandboxEnvironment}from"#shared/sandbox-environment.js";function defineSandboxProvider(e){return{name:e.name,environment(t){let{prepare:n,...r}=t??{};return createSandboxEnvironment({implementation:e.environment(r),prepare:n,providerName:e.name,stateProtocolVersion:e.stateProtocolVersion??1})}}}export{defineSandboxProvider};

package/dist/src/sandbox/providers/default.d.ts

@@ -1,27 +1,28 @@
 import type { DockerSandboxEnvironmentOptions } from "#public/sandbox/docker-sandbox.js";
-import type { JustBashSandboxCreateOptions } from "#public/sandbox/just-bash-sandbox.js";
-import type { MicrosandboxSandboxCreateOptions } from "#public/sandbox/microsandbox-sandbox.js";
+import type { SandboxSession } from "#public/sandbox/index.js";
+import { type SandboxProvider } from "#public/sandbox/provider.js";
 import type { VercelSandboxCreateOptions } from "#public/sandbox/vercel-sandbox.js";
-import type { SandboxEnvironment } from "#shared/sandbox-environment.js";
-import type { SandboxSession } from "#shared/sandbox-session.js";
+import { type JustBashEnvironmentOptions } from "#sandbox/providers/just-bash.js";
+import type { SandboxNetworkOptions, SandboxNetworkPolicy } from "#shared/sandbox-network-policy.js";
 export interface DefaultSandboxEnvironmentOptions {
     readonly docker?: DockerSandboxEnvironmentOptions;
-    readonly justBash?: JustBashSandboxCreateOptions;
-    readonly microsandbox?: MicrosandboxSandboxCreateOptions;
+    readonly justBash?: JustBashEnvironmentOptions;
     readonly prepare?: (sandbox: SandboxSession) => Promise<void> | void;
     readonly vercel?: VercelSandboxCreateOptions;
 }
-export interface DefaultSandboxProbes {
-    readonly isDeployedOnVercel: () => boolean;
-    readonly isDockerAvailable: () => boolean;
-    readonly isMicrosandboxSupported: () => boolean;
+/** Options applied when eve creates one live sandbox from a `DefaultSandbox` environment. */
+export type DefaultSandboxRuntimeOptions = SandboxNetworkOptions;
+/** Live sandbox capabilities exposed by a `DefaultSandbox` environment. */
+export interface DefaultSandboxSession extends SandboxSession {
+    /**
+     * Applies a network policy to the live sandbox. Docker accepts only
+     * `"allow-all"` and `"deny-all"`; just-bash accepts only `"allow-all"`.
+     */
+    setNetworkPolicy(policy: SandboxNetworkPolicy): Promise<void>;
 }
-export declare const SANDBOX_PROVIDER_PROBES: DefaultSandboxProbes;
-export declare const DefaultSandbox: {
-    name: string;
-    environment(options?: DefaultSandboxEnvironmentOptions): SandboxEnvironment<undefined>;
-};
-export declare function defineDefaultSandboxProvider(probes: DefaultSandboxProbes): {
-    name: string;
-    environment(options?: DefaultSandboxEnvironmentOptions): SandboxEnvironment<undefined>;
-};
+/**
+ * Selects Vercel Sandbox on Vercel, Docker when a daemon is reachable, and
+ * just-bash in development. Preparation records the choice, so the runtime
+ * uses the provider the build selected and never probes the host.
+ */
+export declare const DefaultSandbox: SandboxProvider<DefaultSandboxEnvironmentOptions, DefaultSandboxRuntimeOptions, DefaultSandboxSession>;

package/dist/src/sandbox/providers/default.js

@@ -1 +1 @@
-import{isLinuxDockerDaemonAvailableSync,isMicrosandboxPlatformSupported}from"#execution/sandbox/bindings/local.js";import{DockerSandbox}from"#sandbox/providers/docker.js";import{JustBashSandbox}from"#sandbox/providers/just-bash.js";import{MicrosandboxSandbox}from"#sandbox/providers/microsandbox.js";import{createDefaultVercelEnvironment}from"#sandbox/providers/vercel.js";const SANDBOX_PROVIDER_PROBES={isDeployedOnVercel:()=>!!process.env.VERCEL,isDockerAvailable:()=>isLinuxDockerDaemonAvailableSync(),isMicrosandboxSupported:()=>isMicrosandboxPlatformSupported()},DefaultSandbox=defineDefaultSandboxProvider(SANDBOX_PROVIDER_PROBES);function defineDefaultSandboxProvider(e){return{name:`default`,environment(t={}){return e.isDeployedOnVercel()?withoutOpenOptions(createDefaultVercelEnvironment(withPreparation(t.vercel,t.prepare))):e.isDockerAvailable()?withoutOpenOptions(DockerSandbox.environment(withPreparation(t.docker,t.prepare))):e.isMicrosandboxSupported()?withoutOpenOptions(MicrosandboxSandbox.environment(withPreparation(t.microsandbox,t.prepare))):JustBashSandbox.environment(withPreparation(t.justBash,t.prepare))}}}function withPreparation(e,t){return Object.assign({},e,t===void 0?{}:{prepare:t})}function withoutOpenOptions(e){return e}export{DefaultSandbox,SANDBOX_PROVIDER_PROBES,defineDefaultSandboxProvider};
+import{isObject}from"#shared/guards.js";import{isLinuxDockerDaemonAvailableSync}from"#execution/sandbox/bindings/local.js";import{getSandboxEnvironmentRuntime}from"#shared/sandbox-environment.js";import{isEveDevEnvironment}from"#internal/application/dev-environment.js";import{ToolSessionSandboxUnsupportedError}from"#shared/sandbox-tool-session-error.js";import{SandboxSessionGoneError,defineSandboxProvider}from"#public/sandbox/provider.js";import{withAdoptedSandboxSessionStates,withSessionEndArtifact}from"#sandbox/state.js";import{DockerSandbox}from"#sandbox/providers/docker.js";import{JustBashSandbox}from"#sandbox/providers/just-bash.js";import{VercelSandbox}from"#sandbox/providers/vercel.js";const SELECTED_PROVIDERS=[`docker`,`just-bash`,`vercel`],NO_PROVIDER_MESSAGE=`DefaultSandbox has no sandbox provider for this build: it did not run on Vercel, no Docker daemon was reachable, and production builds do not fall back to just-bash. Start Docker and rebuild, deploy to Vercel, or select a provider explicitly in your sandbox module, such as agent/sandbox/sandbox.ts.`,JUST_BASH_NETWORK_POLICY_MESSAGE=`DefaultSandbox selected just-bash, which always allows network access and accepts only the "allow-all" network policy. Start Docker so DefaultSandbox selects it, or select VercelSandbox or DockerSandbox explicitly.`,DefaultSandbox=defineSandboxProvider({name:`default`,environment(e){let t=new Map,provider=n=>{let r=t.get(n);return r===void 0&&(r=getSandboxEnvironmentRuntime(createEnvironment(n,e)),t.set(n,r)),r};function requireProvider(e,t){let n=provider(e);if(t===`tool-session`&&n.implementation.toolSessions!==!0)throw new ToolSessionSandboxUnsupportedError(e);return n}async function endSession(e,t,n,r){let i=t?.provider??n?.provider??null;if(i===null)return;let a=provider(i),o=t?.stateProtocolVersion===a.stateProtocolVersion?t.state:null;await a.implementation.onSessionEnd(e,o,r)}let n={onSessionEnd:(e,t,n)=>endSession(e,t,void 0,n),async prepare(e){let t=selectProvider();return t===null?(e.log(NO_PROVIDER_MESSAGE),{provider:null}):{artifact:await provider(t).implementation.prepare(e),provider:t}},async start(e,t,n){if(n.provider===null)throw Error(NO_PROVIDER_MESSAGE);let r=requireProvider(n.provider,e.kind),i=await r.implementation.start(e,innerOpenOptions(n.provider,t),n.artifact);return{connection:withNetworkPolicy(i.connection),state:{provider:n.provider,state:i.state,stateProtocolVersion:r.stateProtocolVersion}}},async resume(e,t,n){if(t.provider===null||t.provider!==n.provider)throw new SandboxSessionGoneError(`The session's ${n.provider} sandbox cannot resume because this build selected ${t.provider??`no provider`}.`);let r=requireProvider(n.provider,e.kind);if(n.stateProtocolVersion!==r.stateProtocolVersion)throw new SandboxSessionGoneError(`The session's ${n.provider} sandbox state uses protocol ${n.stateProtocolVersion}, not ${r.stateProtocolVersion}.`);return withNetworkPolicy(await r.implementation.resume(e,t.artifact,n.state))},toolSessions:!0};return withSessionEndArtifact(n,async(e,t,{artifact:n,reason:r})=>{await endSession(e,isDefaultSandboxSessionState(t)?t:null,isDefaultSandboxPreparedArtifact(n)?n:void 0,{reason:r})}),withAdoptedSandboxSessionStates(n,e=>{let t=e.providerName;if(isSelectedProvider(t))return{provider:t,state:e.state,stateProtocolVersion:e.stateProtocolVersion}})}});function selectProvider(){return process.env.VERCEL?.trim()?`vercel`:isLinuxDockerDaemonAvailableSync()?`docker`:isEveDevEnvironment()?`just-bash`:null}function createEnvironment(e,t){switch(e){case`docker`:return DockerSandbox.environment(t.docker??{});case`just-bash`:return JustBashSandbox.environment(t.justBash??{});case`vercel`:return VercelSandbox.environment(t.vercel??{})}}function innerOpenOptions(e,t){if(e!==`just-bash`)return t;if(t?.networkPolicy!==void 0&&t.networkPolicy!==`allow-all`)throw Error(JUST_BASH_NETWORK_POLICY_MESSAGE)}function withNetworkPolicy(e){let t=e.extensions??{};return typeof Reflect.get(t,`setNetworkPolicy`)==`function`?e:{...e,extensions:{...t,setNetworkPolicy:rejectJustBashNetworkPolicy}}}async function rejectJustBashNetworkPolicy(e){if(e!==`allow-all`)throw Error(JUST_BASH_NETWORK_POLICY_MESSAGE)}function isSelectedProvider(e){return SELECTED_PROVIDERS.some(t=>t===e)}function isDefaultSandboxSessionState(e){return isObject(e)&&isSelectedProvider(e.provider)&&typeof e.stateProtocolVersion==`number`&&`state`in e}function isDefaultSandboxPreparedArtifact(e){return isObject(e)&&(e.provider===null||isSelectedProvider(e.provider)&&`artifact`in e)}export{DefaultSandbox};

package/dist/src/sandbox/providers/docker.d.ts

@@ -1,8 +1,11 @@
-import type { DockerSandboxSession } from "#public/sandbox/docker.js";
-import type { DockerSandboxEnvironmentOptions, DockerSandboxRuntimeOptions } from "#public/sandbox/docker-sandbox.js";
+import type { DockerCli } from "#execution/sandbox/bindings/docker-cli.js";
+import type { DockerSandboxEnvironmentOptions, DockerSandboxRuntimeOptions, DockerSandboxSession } from "#public/sandbox/docker-sandbox.js";
+import { type SandboxProvider } from "#public/sandbox/provider.js";
 import type { SandboxEnvironment } from "#shared/sandbox-environment.js";
 export type { DockerSandboxEnvironmentOptions, DockerSandboxRuntimeOptions, } from "#public/sandbox/docker-sandbox.js";
 type DockerfileEnvironmentInput = Omit<DockerSandboxEnvironmentOptions, "image">;
+/** Defines the Docker provider over `dockerCli`, the real `docker` CLI unless tests inject one. */
+export declare function defineDockerSandboxProvider(dockerCli?: DockerCli): SandboxProvider<DockerSandboxEnvironmentOptions, DockerSandboxRuntimeOptions, DockerSandboxSession>;
 export declare const DockerSandbox: {
     name: string;
     environment(options?: Readonly<DockerSandboxEnvironmentOptions> | undefined): SandboxEnvironment<DockerSandboxRuntimeOptions, DockerSandboxSession>;

package/dist/src/sandbox/providers/docker.js

@@ -1 +1 @@
-import{createDockerSandboxProvider}from"#execution/sandbox/bindings/local.js";import{defineSandboxProvider}from"#shared/sandbox-provider.js";const provider=defineSandboxProvider({name:`docker`,environment(e){return createDockerSandboxProvider(e)}}),DockerSandbox={...provider,dockerfile(e={}){return provider.environment(e)},image(e,t={}){return provider.environment({...t,image:e})}};export{DockerSandbox};
+import{DOCKER_PROVIDER_NAME,createDockerSandboxProvider}from"#execution/sandbox/bindings/local.js";import{defineSandboxProvider}from"#public/sandbox/provider.js";function defineDockerSandboxProvider(e){return defineSandboxProvider({name:DOCKER_PROVIDER_NAME,environment:t=>createDockerSandboxProvider(t,e)})}const provider=defineDockerSandboxProvider(),DockerSandbox={...provider,dockerfile(e={}){return provider.environment(e)},image(e,t={}){return provider.environment({...t,image:e})}};export{DockerSandbox,defineDockerSandboxProvider};

package/dist/src/sandbox/providers/just-bash.d.ts

@@ -1,4 +1,5 @@
 import type { JustBashSandboxCreateOptions } from "#public/sandbox/just-bash-sandbox.js";
-import type { SandboxSession } from "#shared/sandbox-session.js";
-export type JustBashEnvironmentOptions = JustBashSandboxCreateOptions;
-export declare const JustBashSandbox: import("#shared/sandbox-provider.js").SandboxProvider<JustBashSandboxCreateOptions, undefined, SandboxSession>;
+import { type WithPrepareOption } from "#public/sandbox/provider.js";
+import type { SandboxSession } from "#public/sandbox/index.js";
+export type JustBashEnvironmentOptions = WithPrepareOption<JustBashSandboxCreateOptions, SandboxSession>;
+export declare const JustBashSandbox: import("#public/sandbox/provider.js").SandboxProvider<WithPrepareOption<JustBashSandboxCreateOptions, SandboxSession>, undefined, SandboxSession>;

package/dist/src/sandbox/providers/just-bash.js

@@ -1 +1 @@
-import{createJustBashSandboxProvider}from"#execution/sandbox/bindings/local.js";import{defineSandboxProvider}from"#shared/sandbox-provider.js";const JustBashSandbox=defineSandboxProvider({name:`just-bash`,environment:e=>createJustBashSandboxProvider(e)});export{JustBashSandbox};
+import{createJustBashSandboxProvider}from"#execution/sandbox/bindings/local.js";import{defineSandboxProvider}from"#public/sandbox/provider.js";const JustBashSandbox=defineSandboxProvider({name:`just-bash`,environment:e=>createJustBashSandboxProvider(e)});export{JustBashSandbox};

package/dist/src/sandbox/providers/vercel.d.ts

@@ -1,13 +1,7 @@
 import type { VercelSandboxSession } from "#public/sandbox/vercel.js";
+import { type SandboxProvider, type WithPrepareOption } from "#public/sandbox/provider.js";
 import type { VercelSandboxCreateOptions, VercelSandboxRuntimeOptions } from "#public/sandbox/vercel-sandbox.js";
-import type { SandboxEnvironment } from "#shared/sandbox-environment.js";
-import type { SandboxSession } from "#shared/sandbox-session.js";
-export type VercelSandboxEnvironmentOptions = VercelSandboxCreateOptions & {
-    readonly prepare?: (sandbox: SandboxSession) => Promise<void> | void;
-};
+/** Vercel create options plus `prepare`, which receives a {@link VercelSandboxSession}. */
+export type VercelSandboxEnvironmentOptions = WithPrepareOption<VercelSandboxCreateOptions, VercelSandboxSession>;
 export type { VercelSandboxRuntimeOptions } from "#public/sandbox/vercel-sandbox.js";
-export declare function createDefaultVercelEnvironment(options?: VercelSandboxEnvironmentOptions): SandboxEnvironment<VercelSandboxRuntimeOptions, VercelSandboxSession>;
-export declare const VercelSandbox: {
-    name: string;
-    environment(options?: VercelSandboxEnvironmentOptions): SandboxEnvironment<VercelSandboxRuntimeOptions, VercelSandboxSession>;
-};
+export declare const VercelSandbox: SandboxProvider<VercelSandboxEnvironmentOptions | undefined, VercelSandboxRuntimeOptions, VercelSandboxSession>;

package/dist/src/sandbox/providers/vercel.js

@@ -1 +1 @@
-import{defineSandboxProvider}from"#shared/sandbox-provider.js";import{createVercelSandbox,createVercelSandboxProvider}from"#execution/sandbox/bindings/vercel.js";const defaultProvider=defineSandboxProvider({name:`vercel`,environment:e=>{let{prepare:t,...n}=e??{};return createVercelSandbox({createOptions:n,prepare:t,skipEmptyPreparation:!0})}}),provider=defineSandboxProvider({name:`vercel`,environment:e=>createVercelSandboxProvider(e)});function createDefaultVercelEnvironment(e){return defaultProvider.environment(e)}const VercelSandbox={name:`vercel`,environment(e){return provider.environment(e)}};export{VercelSandbox,createDefaultVercelEnvironment};
+import{defineSandboxProvider}from"#public/sandbox/provider.js";import{createVercelSandbox}from"#execution/sandbox/bindings/vercel.js";const VercelSandbox=defineSandboxProvider({name:`vercel`,environment:e=>createVercelSandbox({createOptions:e})});export{VercelSandbox};

package/dist/src/sandbox/providers.d.ts

@@ -1,5 +1,4 @@
 export { DefaultSandbox } from "#sandbox/providers/default.js";
 export { DockerSandbox } from "#sandbox/providers/docker.js";
 export { JustBashSandbox } from "#sandbox/providers/just-bash.js";
-export { MicrosandboxSandbox } from "#sandbox/providers/microsandbox.js";
 export { VercelSandbox } from "#sandbox/providers/vercel.js";

package/dist/src/sandbox/providers.js

@@ -1 +1 @@
-import{DockerSandbox}from"#sandbox/providers/docker.js";import{DefaultSandbox}from"#sandbox/providers/default.js";import{JustBashSandbox}from"#sandbox/providers/just-bash.js";import{MicrosandboxSandbox}from"#sandbox/providers/microsandbox.js";import{VercelSandbox}from"#sandbox/providers/vercel.js";export{DefaultSandbox,DockerSandbox,JustBashSandbox,MicrosandboxSandbox,VercelSandbox};
+import{DockerSandbox}from"#sandbox/providers/docker.js";import{DefaultSandbox}from"#sandbox/providers/default.js";import{JustBashSandbox}from"#sandbox/providers/just-bash.js";import{VercelSandbox}from"#sandbox/providers/vercel.js";export{DefaultSandbox,DockerSandbox,JustBashSandbox,VercelSandbox};

package/dist/src/sandbox/state.d.ts

@@ -1,8 +1,18 @@
 import type { SandboxSession } from "#public/definitions/sandbox.js";
+import type { SandboxProviderRuntime, SandboxSessionContext } from "#sandbox/provider.js";
 import type { SandboxEnvironmentIdentity } from "#shared/sandbox-environment.js";
 import type { SandboxDeleteOptions, SandboxPreparedArtifact } from "#shared/sandbox-provider.js";
 export type SandboxSessionEndReason = "completed" | "expired" | "failed";
 export interface SandboxSessionState {
+    /**
+     * Set anew each time this session's access calls `start()`, which is an upsert,
+     * and kept on resume. Providers name a session's sandbox deterministically, so
+     * without it a sandbox recreated after it was gone would look like the old one
+     * to dynamic skills, which then write their files into it at the next turn. A
+     * sandbox that a sharing subagent or a borrowed workflow step starts keeps this
+     * session's generation. Absent in state saved by earlier releases.
+     */
+    readonly generation?: string;
     readonly providerName: string;
     readonly state: SandboxPreparedArtifact;
     readonly stateProtocolVersion: number;
@@ -10,10 +20,61 @@ export interface SandboxSessionState {
 export interface SandboxState {
     readonly session: SandboxSessionState | null;
 }
+/**
+ * Whether no provider can resume this persisted record, so callers treat it as
+ * no sandbox: records saved before the provider redesign (eve 0.64) have no
+ * `providerName`, and `microsandbox` was removed as a provider.
+ */
+export declare function isRetiredSandboxSessionState(state: SandboxSessionState): boolean;
+/** Converts a record another provider wrote into this provider's state, or `undefined`. */
+type SandboxSessionStateAdopter = (state: SandboxSessionState) => SandboxPreparedArtifact | undefined;
+/**
+ * Lets an eve-owned provider resume records that another provider name wrote,
+ * such as `DefaultSandbox` for sessions saved when it recorded the provider it
+ * picked. Internal, so the public provider API is unchanged.
+ */
+export declare function withAdoptedSandboxSessionStates<Implementation extends object>(implementation: Implementation, adopt: SandboxSessionStateAdopter): Implementation;
+/**
+ * The persisted record the current provider should resume, or `null` for no
+ * sandbox. A record the provider cannot adopt is returned as-is; resuming it
+ * starts a fresh sandbox, and handoff rejects it. An adopted record keeps its
+ * `generation`, because it still names the same live sandbox.
+ */
+export declare function resolvePersistedSandboxSessionState(state: SandboxSessionState | null | undefined, provider: SandboxProviderRuntime | undefined): SandboxSessionState | null;
+/** Session-end cleanup that also needs the current build's prepared artifact. */
+type SandboxSessionEndWithArtifact = (context: SandboxSessionContext, state: SandboxPreparedArtifact | null, options: {
+    readonly artifact: SandboxPreparedArtifact | undefined;
+    readonly reason: SandboxSessionEndReason;
+}) => Promise<void>;
+/**
+ * Lets an eve-owned provider receive the prepared artifact at session end,
+ * such as `DefaultSandbox`, which finds the provider it selected there when
+ * no state was recorded. Internal, so the public provider API is unchanged.
+ */
+export declare function withSessionEndArtifact<Implementation extends object>(implementation: Implementation, onSessionEnd: SandboxSessionEndWithArtifact): Implementation;
+export declare function getSessionEndWithArtifact(implementation: object): SandboxSessionEndWithArtifact | undefined;
+/**
+ * Background work that may need the sandbox. It calls `open` only when it
+ * does, so work that turns out to have nothing to do never opens it. Calling
+ * the access's `get()` from the work waits on the work itself.
+ */
+export type SandboxPreparation = (open: () => Promise<SandboxSession>) => Promise<void>;
 export interface SandboxAccess {
     readonly environment?: SandboxEnvironmentIdentity;
     captureState(): Promise<SandboxState>;
     delete?(options?: SandboxDeleteOptions): Promise<void>;
+    /** Resolves once the sandbox is open and every queued preparation has run. */
     get(): Promise<SandboxSession | null>;
+    /**
+     * Opens the sandbox without waiting for queued preparation, for framework
+     * work that needs only the connection, such as staging attachments.
+     */
+    open(): Promise<SandboxSession | null>;
+    /**
+     * Queues `work` to run in the background, in order; without `work`, opens
+     * the sandbox in the background. Returns at once and never throws.
+     */
+    prepare(work?: SandboxPreparation): void;
     stop(): Promise<void>;
 }
+export {};

package/dist/src/sandbox/state.js

@@ -1 +1 @@
-export{};
+function isRetiredSandboxSessionState(e){return e.providerName===void 0||e.providerName===`microsandbox`}const adopters=new WeakMap;function withAdoptedSandboxSessionStates(e,t){return adopters.set(e,t),e}function resolvePersistedSandboxSessionState(e,t){if(e==null||isRetiredSandboxSessionState(e))return null;if(t===void 0||e.providerName===t.providerName)return e;let n=adopters.get(t.implementation)?.(e);return n===void 0?e:{...e,providerName:t.providerName,state:n,stateProtocolVersion:t.stateProtocolVersion}}const sessionEndsWithArtifact=new WeakMap;function withSessionEndArtifact(e,t){return sessionEndsWithArtifact.set(e,t),e}function getSessionEndWithArtifact(e){return sessionEndsWithArtifact.get(e)}export{getSessionEndWithArtifact,isRetiredSandboxSessionState,resolvePersistedSandboxSessionState,withAdoptedSandboxSessionStates,withSessionEndArtifact};

package/dist/src/self-modification/deployed-sandbox.d.ts

@@ -1,14 +1,9 @@
-import { MicrosandboxSandbox } from "#sandbox/providers/microsandbox.js";
-import { type DefaultSandboxProbes } from "#sandbox/providers/default.js";
-import { VercelSandbox } from "#sandbox/providers/vercel.js";
 import { type SandboxSelector } from "#shared/sandbox-environment.js";
 import { type DeployedSelfModificationConfig } from "./remote/config.js";
-type Probes = Pick<DefaultSandboxProbes, "isDeployedOnVercel" | "isMicrosandboxSupported">;
-type DeployedSelfModificationEnvironment = ReturnType<typeof MicrosandboxSandbox.environment> | ReturnType<typeof VercelSandbox.environment>;
 /**
  * Defines the deployed child's sandbox. During `eve dev` the deployed child is never
- * offered, so its sandbox binds an inert environment instead of probing providers.
+ * offered, so its sandbox binds an inert environment. Other builds bind a Vercel
+ * environment, whose empty preparation is a no-op, so they compile on any host;
+ * the Vercel requirement is enforced when a deployed child opens its sandbox.
  */
-export declare function defineDeployedSelfModificationSandbox(config: DeployedSelfModificationConfig, probes?: Probes): SandboxSelector;
-export declare function selectDeployedSelfModificationEnvironment(probes: Probes): DeployedSelfModificationEnvironment;
-export {};
+export declare function defineDeployedSelfModificationSandbox(config: DeployedSelfModificationConfig, isDeployedOnVercel?: () => boolean): SandboxSelector;

package/dist/src/self-modification/deployed-sandbox.js

@@ -1 +1 @@
-import{createGitHubCredentialProvider}from"./credentials.js";import{SELF_MODIFICATION_BASELINE_NETWORK_POLICY}from"./network-policy.js";import{REPOSITORY_PATH,prepareSelfModificationWorkspace}from"./git-workspace.js";import{isDeployedRuntime}from"./mode.js";import{resolveDeployedSelfModificationConfig}from"./remote/config.js";import{bindSandboxEnvironment}from"#shared/sandbox-environment.js";import{shellQuote}from"#shared/shell-quote.js";import{defineSandbox}from"#public/definitions/sandbox.js";import{SANDBOX_PROVIDER_PROBES}from"#sandbox/providers/default.js";import{JustBashSandbox}from"#sandbox/providers/just-bash.js";import{MicrosandboxSandbox}from"#sandbox/providers/microsandbox.js";import{VercelSandbox}from"#sandbox/providers/vercel.js";function defineDeployedSelfModificationSandbox(e,t=SANDBOX_PROVIDER_PROBES){if(!isDeployedRuntime()){let e=JustBashSandbox.environment();return bindSandboxEnvironment(defineSandbox(()=>e.open()),e)}let n=resolveDeployedSelfModificationConfig(e),r=selectDeployedSelfModificationEnvironment(t);return bindSandboxEnvironment(defineSandbox(async({session:e})=>{let t=await r.open({networkPolicy:SELF_MODIFICATION_BASELINE_NETWORK_POLICY});if(e.parent===void 0)throw Error(`Production self-modification requires a child session.`);if(t.setNetworkPolicy===void 0)throw Error(`Production self-modification requires mutable sandbox network policy.`);let i={...t,setNetworkPolicy:t.setNetworkPolicy},a=await createGitHubCredentialProvider(n.credentials).resolve({capability:`checkout`,repository:n.repository});await prepareSelfModificationWorkspace({directory:n.directory,repository:n.repository,sandbox:i,targetBranch:n.targetBranch,token:a});let o=n.directory===`.`?REPOSITORY_PATH:`${REPOSITORY_PATH}/${n.directory}`;if((await t.run({command:`rm -rf /source && ln -s ${shellQuote(`${o}/agent`)} /source`})).exitCode!==0)throw Error(`Self-modification could not mount the agent source.`);return t}),r)}function selectDeployedSelfModificationEnvironment(e){if(e.isDeployedOnVercel())return VercelSandbox.environment();if(e.isMicrosandboxSupported())return MicrosandboxSandbox.environment();throw Error(`Deployed self-modification requires runtime credential transforms. No supported provider is available. Use Vercel Sandbox or microsandbox on a supported self-hosted system.`)}export{defineDeployedSelfModificationSandbox,selectDeployedSelfModificationEnvironment};
+import{createGitHubCredentialProvider}from"./credentials.js";import{SELF_MODIFICATION_BASELINE_NETWORK_POLICY}from"./network-policy.js";import{REPOSITORY_PATH,prepareSelfModificationWorkspace}from"./git-workspace.js";import{isDeployedRuntime}from"./mode.js";import{resolveDeployedSelfModificationConfig}from"./remote/config.js";import{bindSandboxEnvironment}from"#shared/sandbox-environment.js";import{shellQuote}from"#shared/shell-quote.js";import{defineSandbox}from"#public/definitions/sandbox.js";import{JustBashSandbox}from"#sandbox/providers/just-bash.js";import{VercelSandbox}from"#sandbox/providers/vercel.js";function defineDeployedSelfModificationSandbox(e,t=()=>!!process.env.VERCEL){if(!isDeployedRuntime()){let e=JustBashSandbox.environment();return bindSandboxEnvironment(defineSandbox(()=>e.open()),e)}let n=resolveDeployedSelfModificationConfig(e),r=VercelSandbox.environment();return bindSandboxEnvironment(defineSandbox(async({session:e})=>{if(!t())throw Error(`Deployed self-modification requires deploying on Vercel, where Vercel Sandbox provides the runtime credential transforms that keep the GitHub token out of the sandbox. Deploy this agent to Vercel, or remove the eve/self-modification/remote extension mount from self-hosted deployments.`);let i=await r.open({networkPolicy:SELF_MODIFICATION_BASELINE_NETWORK_POLICY});if(e.parent===void 0)throw Error(`Production self-modification requires a child session.`);if(i.setNetworkPolicy===void 0)throw Error(`Production self-modification requires mutable sandbox network policy.`);let a={...i,setNetworkPolicy:i.setNetworkPolicy},o=await createGitHubCredentialProvider(n.credentials).resolve({capability:`checkout`,repository:n.repository});await prepareSelfModificationWorkspace({directory:n.directory,repository:n.repository,sandbox:a,targetBranch:n.targetBranch,token:o});let s=n.directory===`.`?REPOSITORY_PATH:`${REPOSITORY_PATH}/${n.directory}`;if((await i.run({command:`rm -rf /source && ln -s ${shellQuote(`${s}/agent`)} /source`})).exitCode!==0)throw Error(`Self-modification could not mount the agent source.`);return i}),r)}export{defineDeployedSelfModificationSandbox};

package/dist/src/self-modification/filesystem.d.ts

@@ -1,7 +1,7 @@
-import type { IFileSystem } from "just-bash";
+import type { JustBashFilesystem } from "#public/sandbox/just-bash-sandbox.js";
 export declare function createSelfModificationFilesystem(input: {
     readonly appRoot?: string;
-    readonly defaultFilesystem: IFileSystem;
+    readonly defaultFilesystem: JustBashFilesystem;
     resolveProjectPath?(path: string): string;
     readonly justBash: typeof import("just-bash");
-}): Promise<IFileSystem>;
+}): Promise<JustBashFilesystem>;

package/dist/src/self-modification/remote/config.d.ts

@@ -41,8 +41,8 @@ export interface DeployedSelfModificationConfig {
     readonly authorize: SelfModificationAuthorization;
     readonly credentials?: GitHubCredentialProvider | {
         /**
-         * Self-hosted exception. Reads `EVE_SELF_MODIFICATION_GITHUB_TOKEN` from
-         * the trusted deployment environment; never injects it into the sandbox.
+         * Reads `EVE_SELF_MODIFICATION_GITHUB_TOKEN` from the trusted deployment
+         * environment; never injects it into the sandbox.
          */
         readonly pat: true;
     };

package/dist/src/self-modification/remote/config.js

@@ -1 +1 @@
-import{assertGitRef,assertRepositoryPart}from"../identifiers.js";function resolveDeployedSelfModificationConfig(e){if(!isRecord(e))throw Error(`Deployed self-modification configuration must be an object.`);let{source:t,target:n,authorize:r,credentials:i}=e;if(t===void 0||n===void 0||r===void 0)throw Error(`Deployed self-modification requires source, target, and authorization configuration.`);if(!isRecord(t))throw Error(`Deployed self-modification source must be an object.`);if(!isRecord(t.git))throw Error(`Deployed self-modification source.git must be an object.`);if(!isRecord(n))throw Error(`Deployed self-modification target must be an object.`);if(typeof r!=`function`)throw Error(`Deployed self-modification authorize must be a function.`);let{git:a}=t;if(typeof a.repository!=`string`||typeof a.directory!=`string`)throw Error(`Deployed self-modification source.git.repository and source.git.directory must be strings.`);if(typeof n.branch!=`string`)throw Error(`Deployed self-modification target.branch must be a string.`);return{authorize:r,credentials:parseCredentials(i),directory:parseDirectory(a.directory),repository:parseGitHubRepository(a.repository),targetBranch:parseBranch(n.branch)}}function parseCredentials(e){if(!isRecord(e))throw Error(`Deployed self-modification credentials must explicitly configure a credential provider or the self-hosted PAT exception.`);let t=e.resolve!==void 0,n=e.pat!==void 0;if(t&&n)throw Error(`Deployed self-modification credentials must configure either a credential provider or pat, not both.`);if(n){if(e.pat!==!0)throw Error(`Deployed self-modification credentials.pat must be true.`);return{kind:`pat`}}if(!isGitHubCredentialProvider(e))throw Error(`Deployed self-modification credentials must be an object with a resolve function.`);return{kind:`provider`,provider:e}}function isGitHubCredentialProvider(e){return isRecord(e)&&typeof e.resolve==`function`}function parseGitHubRepository(e){let t=/^github\.com\/([^/]+)\/([^/]+)$/u.exec(e);if(t?.[1]===void 0||t[2]===void 0)throw Error(`Deployed self-modification source.git.repository must use github.com/owner/repo form.`);return assertRepositoryPart(t[1],`repository owner`),assertRepositoryPart(t[2],`repository name`),{owner:t[1],repo:t[2]}}function parseDirectory(e){if(e!==`.`&&(e.length===0||e.startsWith(`/`)||e.includes(`\\`)||e.split(`/`).some(e=>e===``||e===`.`||e===`..`)))throw Error(`Deployed self-modification source.git.directory must be a safe repository-relative path.`);return e}function parseBranch(e){if(assertGitRef(e,`target branch`),e.startsWith(`refs/`))throw Error(`Deployed self-modification target.branch must be a branch name, not a full Git ref.`);return e}function isRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}export{resolveDeployedSelfModificationConfig};
+import{assertGitRef,assertRepositoryPart}from"../identifiers.js";function resolveDeployedSelfModificationConfig(e){if(!isRecord(e))throw Error(`Deployed self-modification configuration must be an object.`);let{source:t,target:n,authorize:r,credentials:i}=e;if(t===void 0||n===void 0||r===void 0)throw Error(`Deployed self-modification requires source, target, and authorization configuration.`);if(!isRecord(t))throw Error(`Deployed self-modification source must be an object.`);if(!isRecord(t.git))throw Error(`Deployed self-modification source.git must be an object.`);if(!isRecord(n))throw Error(`Deployed self-modification target must be an object.`);if(typeof r!=`function`)throw Error(`Deployed self-modification authorize must be a function.`);let{git:a}=t;if(typeof a.repository!=`string`||typeof a.directory!=`string`)throw Error(`Deployed self-modification source.git.repository and source.git.directory must be strings.`);if(typeof n.branch!=`string`)throw Error(`Deployed self-modification target.branch must be a string.`);return{authorize:r,credentials:parseCredentials(i),directory:parseDirectory(a.directory),repository:parseGitHubRepository(a.repository),targetBranch:parseBranch(n.branch)}}function parseCredentials(e){if(!isRecord(e))throw Error("Deployed self-modification credentials must explicitly configure a credential provider or `{ pat: true }`.");let t=e.resolve!==void 0,n=e.pat!==void 0;if(t&&n)throw Error(`Deployed self-modification credentials must configure either a credential provider or pat, not both.`);if(n){if(e.pat!==!0)throw Error(`Deployed self-modification credentials.pat must be true.`);return{kind:`pat`}}if(!isGitHubCredentialProvider(e))throw Error(`Deployed self-modification credentials must be an object with a resolve function.`);return{kind:`provider`,provider:e}}function isGitHubCredentialProvider(e){return isRecord(e)&&typeof e.resolve==`function`}function parseGitHubRepository(e){let t=/^github\.com\/([^/]+)\/([^/]+)$/u.exec(e);if(t?.[1]===void 0||t[2]===void 0)throw Error(`Deployed self-modification source.git.repository must use github.com/owner/repo form.`);return assertRepositoryPart(t[1],`repository owner`),assertRepositoryPart(t[2],`repository name`),{owner:t[1],repo:t[2]}}function parseDirectory(e){if(e!==`.`&&(e.length===0||e.startsWith(`/`)||e.includes(`\\`)||e.split(`/`).some(e=>e===``||e===`.`||e===`..`)))throw Error(`Deployed self-modification source.git.directory must be a safe repository-relative path.`);return e}function parseBranch(e){if(assertGitRef(e,`target branch`),e.startsWith(`refs/`))throw Error(`Deployed self-modification target.branch must be a branch name, not a full Git ref.`);return e}function isRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}export{resolveDeployedSelfModificationConfig};

package/dist/src/self-modification/setup.d.ts

@@ -9,7 +9,6 @@ export interface SelfModificationSetupValues {
     readonly connector: string;
     readonly directory: string;
     readonly repository: string;
-    readonly vercelBackend: boolean;
 }
 export interface DetectedGitRepository {
     readonly branch?: string;

package/dist/src/self-modification/setup.js

@@ -1,7 +1,4 @@
-import{renderLocalSelfModificationExtension}from"./scaffold.js";import{createHash}from"node:crypto";import{mkdir,readFile,writeFile}from"node:fs/promises";import{join,relative}from"node:path";import{execFile}from"node:child_process";import{promisify}from"node:util";import{stripLogicalPathExtension}from"#discover/filesystem.js";import{captureVercel,runVercelCaptureStdout}from"#setup/primitives/run-vercel.js";import{discoverAgent}from"#discover/discover-agent.js";const SELF_MODIFICATION_CONFIG_PATH=`agent/extensions/self-modification/extension.ts`,DEPLOYED_SELF_MODIFICATION_CONFIG_PATH=`agent/extensions/self-modification-remote/extension.ts`,runFile=promisify(execFile),DEFAULT_EXTENSION=renderLocalSelfModificationExtension(),LEGACY_DEFAULT_EXTENSION=DEFAULT_EXTENSION.replace(`"eve/self-modification/local"`,`"eve/self-modification"`),defaultDependencies={captureVercel,runVercelCaptureStdout};function connectorName(e,t){return`selfmod-${e}-${t}`.toLowerCase().replaceAll(/[^a-z0-9-]/gu,`-`)}function renderSelfModificationConfig(e){if(e===void 0)return DEFAULT_EXTENSION;let t=[...new Set(e.channelNames)].filter(e=>e!==`eve`).sort(),n=(e.vercelBackend?t:[]).map(e=>`      case ${JSON.stringify(`channel:${e}`)}:
-        // Authorize trusted principals for this channel before returning true.
-        return false;`).join(`
-`),r=`${e.vercelBackend?`      case "http": {
+import{renderLocalSelfModificationExtension}from"./scaffold.js";import{createHash}from"node:crypto";import{mkdir,readFile,writeFile}from"node:fs/promises";import{join,relative}from"node:path";import{execFile}from"node:child_process";import{promisify}from"node:util";import{stripLogicalPathExtension}from"#discover/filesystem.js";import{captureVercel,runVercelCaptureStdout}from"#setup/primitives/run-vercel.js";import{discoverAgent}from"#discover/discover-agent.js";const SELF_MODIFICATION_CONFIG_PATH=`agent/extensions/self-modification/extension.ts`,DEPLOYED_SELF_MODIFICATION_CONFIG_PATH=`agent/extensions/self-modification-remote/extension.ts`,runFile=promisify(execFile),DEFAULT_EXTENSION=renderLocalSelfModificationExtension(),LEGACY_DEFAULT_EXTENSION=DEFAULT_EXTENSION.replace(`"eve/self-modification/local"`,`"eve/self-modification"`),defaultDependencies={captureVercel,runVercelCaptureStdout};function connectorName(e,t){return`selfmod-${e}-${t}`.toLowerCase().replaceAll(/[^a-z0-9-]/gu,`-`)}function renderSelfModificationConfig(e){if(e===void 0)return DEFAULT_EXTENSION;let t=`      case "http": {
         const projectId = process.env.VERCEL_PROJECT_ID;
         return (
           projectId !== undefined &&
@@ -12,7 +9,10 @@ import{renderLocalSelfModificationExtension}from"./scaffold.js";import{createHas
           principal.attributes.project_id === projectId
         );
       }
-`:``}${n}`,i=`Self-modification could not obtain a GitHub credential from Vercel Connect for ${e.connector}. Install and attach the configured GitHub connector to this Vercel project, install the managed GitHub App for the configured repository, then retry.`,a=`import { getToken } from "@vercel/connect";
+${[...new Set(e.channelNames)].filter(e=>e!==`eve`).sort().map(e=>`      case ${JSON.stringify(`channel:${e}`)}:
+        // Authorize trusted principals for this channel before returning true.
+        return false;`).join(`
+`)}`,n=`Self-modification could not obtain a GitHub credential from Vercel Connect for ${e.connector}. Install and attach the configured GitHub connector to this Vercel project, install the managed GitHub App for the configured repository, then retry.`,r=`import { getToken } from "@vercel/connect";
 import selfModification from "eve/self-modification/remote";
 
 export default selfModification({
@@ -40,19 +40,19 @@ export default selfModification({
           subject: { type: "app" },
         });
       } catch (error) {
-        throw new Error(${JSON.stringify(i)}, { cause: error });
+        throw new Error(${JSON.stringify(n)}, { cause: error });
       }
     },
   },
   authorize: ({ channel, principal }) => {
     switch (channel.kind) {
-${r}      default:
+${t}      default:
         // Add another branch when you add a trusted channel.
         return false;
     }
   },
 });
-`;return`// eve-self-modification: generated-v1 digest:${createHash(`sha256`).update(a).digest(`hex`)}\n${a}`}function classifySelfModificationConfig(e){if(e===void 0)return`missing`;if(e===DEFAULT_EXTENSION||e===LEGACY_DEFAULT_EXTENSION||e===`import { defineSelfModificationConfig } from "eve/self-modification/config";
+`;return`// eve-self-modification: generated-v1 digest:${createHash(`sha256`).update(r).digest(`hex`)}\n${r}`}function classifySelfModificationConfig(e){if(e===void 0)return`missing`;if(e===DEFAULT_EXTENSION||e===LEGACY_DEFAULT_EXTENSION||e===`import { defineSelfModificationConfig } from "eve/self-modification/config";
 
 export default defineSelfModificationConfig({});
 `)return`local`;let[t,...n]=e.split(`

package/dist/src/setup/integrations/discord/api.d.ts

@@ -13,4 +13,11 @@ export declare function registerDiscordCommand(applicationId: string, botToken:
 }, fetchImpl?: typeof fetch): Promise<void>;
 /** Points Discord HTTP Interactions at a persisted Connect connector. */
 export declare function configureDiscordInteractionsEndpoint(botToken: string, connectorId: string, fetchImpl?: typeof fetch): Promise<void>;
+/**
+ * Turns on the Message Content intent, so messages that don't mention the bot,
+ * such as thread follow-ups, arrive with their text. Returns `false` when
+ * Discord refuses, as it does for a verified app in 100 or more servers, which
+ * needs Discord's approval instead.
+ */
+export declare function enableDiscordMessageContentIntent(botToken: string, fetchImpl?: typeof fetch): Promise<boolean>;
 export {};

package/dist/src/setup/integrations/discord/api.js

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.js";const DiscordApplicationSchema=z.object({id:z.string(),name:z.string(),verify_key:z.string()});async function discordRequest(e,t,n,r){return r(`https://discord.com/api/v10${t}`,{...n,headers:{authorization:`Bot ${e}`,"content-type":`application/json`,...n.headers}})}async function resolveDiscordApplication(e,t=fetch){let n=await discordRequest(e,`/oauth2/applications/@me`,{method:`GET`},t);if(!n.ok)throw Error(`Discord rejected the bot token (HTTP ${n.status}).`);let r=DiscordApplicationSchema.safeParse(await n.json());if(!r.success)throw Error(`Discord returned incomplete application details.`);return{id:r.data.id,name:r.data.name,publicKey:r.data.verify_key}}async function registerDiscordCommand(e,t,n,r=fetch){let i=await discordRequest(t,`/applications/${encodeURIComponent(e)}/commands`,{method:`POST`,body:JSON.stringify({name:n.name,description:n.description,type:1,options:[{name:`message`,description:`What should the agent do?`,type:3,required:!0},{name:`file`,description:`A file for the agent to read`,type:11,required:!1}]})},r);if(!i.ok)throw Error(`Discord command registration failed (HTTP ${i.status}).`)}async function configureDiscordInteractionsEndpoint(e,t,n=fetch){let r=await discordRequest(e,`/applications/@me`,{method:`PATCH`,body:JSON.stringify({interactions_endpoint_url:`https://connect.vercel.com/trigger/${encodeURIComponent(t)}`})},n);if(!r.ok)throw Error(`Discord rejected the interactions endpoint (HTTP ${r.status}).`)}export{configureDiscordInteractionsEndpoint,registerDiscordCommand,resolveDiscordApplication};
+import{z}from"#compiled/zod/index.js";const DiscordApplicationSchema=z.object({id:z.string(),name:z.string(),verify_key:z.string()});async function discordRequest(e,t,n,r){return r(`https://discord.com/api/v10${t}`,{...n,headers:{authorization:`Bot ${e}`,"content-type":`application/json`,...n.headers}})}async function resolveDiscordApplication(e,t=fetch){let n=await discordRequest(e,`/oauth2/applications/@me`,{method:`GET`},t);if(!n.ok)throw Error(`Discord rejected the bot token (HTTP ${n.status}).`);let r=DiscordApplicationSchema.safeParse(await n.json());if(!r.success)throw Error(`Discord returned incomplete application details.`);return{id:r.data.id,name:r.data.name,publicKey:r.data.verify_key}}async function registerDiscordCommand(e,t,n,r=fetch){let i=await discordRequest(t,`/applications/${encodeURIComponent(e)}/commands`,{method:`POST`,body:JSON.stringify({name:n.name,description:n.description,type:1,options:[{name:`message`,description:`What should the agent do?`,type:3,required:!0},{name:`file`,description:`A file for the agent to read`,type:11,required:!1}]})},r);if(!i.ok)throw Error(`Discord command registration failed (HTTP ${i.status}).`)}async function configureDiscordInteractionsEndpoint(e,t,n=fetch){let r=await discordRequest(e,`/applications/@me`,{method:`PATCH`,body:JSON.stringify({interactions_endpoint_url:`https://connect.vercel.com/trigger/${encodeURIComponent(t)}`})},n);if(!r.ok)throw Error(`Discord rejected the interactions endpoint (HTTP ${r.status}).`)}const DiscordApplicationFlagsSchema=z.object({flags:z.number().optional()});async function enableDiscordMessageContentIntent(e,t=fetch){let n=await discordRequest(e,`/applications/@me`,{method:`GET`},t);if(!n.ok)return!1;let r=DiscordApplicationFlagsSchema.safeParse(await n.json()).data?.flags??0;return r&786432?!0:(await discordRequest(e,`/applications/@me`,{method:`PATCH`,body:JSON.stringify({flags:r&565248|524288})},t)).ok}export{configureDiscordInteractionsEndpoint,enableDiscordMessageContentIntent,registerDiscordCommand,resolveDiscordApplication};

package/dist/src/setup/integrations/discord/daemon.d.ts

@@ -0,0 +1,18 @@
+/** Name of the Vercel Daemon that holds the Discord Gateway connection. */
+export declare const DISCORD_DAEMON_NAME = "discord-gateway";
+/** Directory of the relay, relative to the project root. */
+export declare const DISCORD_DAEMON_ROOT = "daemon";
+/** The relay's files, by path relative to {@link DISCORD_DAEMON_ROOT}. */
+export declare function discordDaemonFiles(connectorUid: string, options?: {
+    readonly messageContent: boolean;
+}): Readonly<Record<string, string>>;
+/** The `daemons` entry to add by hand to a project configured through `vercel.ts`. */
+export declare function discordDaemonEntry(): string;
+/**
+ * `vercel.json` with the relay's daemon added, given its current contents or
+ * `undefined` when there is none. Returns `undefined` when a daemon of the same
+ * name already exists, so the file is left as it is.
+ */
+export declare function withDiscordDaemon(vercelJson: string | undefined): string | undefined;
+/** Reads a text file, or `undefined` when there is none. */
+export declare function readTextFile(path: string): Promise<string | undefined>;