eve 0.81.1 → 0.83.0

package/dist/src/shared/framework-eve-server.js

@@ -1,2 +1,2 @@
-import{mkdir,open,readFile,rm,stat,writeFile}from"node:fs/promises";import{isLoopbackHostname}from"#shared/network-address.js";import{existsSync}from"node:fs";import{join}from"node:path";import{resolvePackageRoot}from"#internal/application/package.js";import{spawn}from"node:child_process";import{readDevelopmentRuntimeArtifactsRevision}from"#services/dev-client/runtime-artifacts.js";const DEFAULT_EVE_SERVER_TIMEOUT_MS=18e4,ANSI_ESCAPE_PATTERN=RegExp(`\x1B\\[[0-?]*[ -/]*[@-~]`,`g`),SERVER_URL_CANDIDATE_PATTERN=/https?:\/\/[^\s"'<>]+/g;function normalizeOrigin(e){return new URL(e).origin}function isNodeErrorWithCode(e,t){return e instanceof Error&&`code`in e&&e.code===t}function delay(e){return new Promise(t=>setTimeout(t,e))}function isRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function resolveEveCacheDirectory(e){return join(e,`.eve`)}function resolveEveDevServerRegistryPath(e,t){return join(resolveEveCacheDirectory(e),`${t.slug}-dev-server.json`)}function resolveEveDevServerLockPath(e,t){return join(resolveEveCacheDirectory(e),`${t.slug}-dev-server.lock`)}function resolveDevServerTimeout(e,t){if(e!==void 0){if(!Number.isFinite(e)||e<=0)throw Error(`eve ${t.label} development server timeout must be a positive number.`);return e}}function normalizeDevServerRegistry(e){if(isRecord(e)&&typeof e.appRoot==`string`&&typeof e.origin==`string`&&typeof e.updatedAt==`string`&&(e.pid===null||typeof e.pid==`number`))try{return{appRoot:e.appRoot,origin:normalizeOrigin(e.origin),pid:e.pid,updatedAt:e.updatedAt}}catch{return}}async function readUsableEveDevServerRegistry(e,t){try{let n=normalizeDevServerRegistry(JSON.parse(await readFile(resolveEveDevServerRegistryPath(e,t),`utf8`)));return n===void 0||n.appRoot!==e||await readDevelopmentRuntimeArtifactsRevision({serverUrl:n.origin,timeoutMs:1e3})===void 0?void 0:n.origin}catch(e){if(isNodeErrorWithCode(e,`ENOENT`))return;throw e}}async function writeEveDevServerRegistry(e,t,n){await mkdir(resolveEveCacheDirectory(e),{recursive:!0}),await writeFile(resolveEveDevServerRegistryPath(e,t),`${JSON.stringify({appRoot:e,origin:n.origin,pid:n.process?.pid??null,updatedAt:new Date().toISOString()},null,2)}\n`)}async function removeStaleEveDevServerLock(e){try{let t=await stat(e);Date.now()-t.mtimeMs>3e4&&await rm(e,{force:!0})}catch(e){if(!isNodeErrorWithCode(e,`ENOENT`))throw e}}async function acquireEveDevServerLock(e,t,n){let r=resolveEveCacheDirectory(e),i=resolveEveDevServerLockPath(e,t),a=Date.now()+n;for(await mkdir(r,{recursive:!0});;)try{let e=await open(i,`wx`);return await e.writeFile(`${String(process.pid)}\n`),await e.close(),async()=>{await rm(i,{force:!0})}}catch(r){if(!isNodeErrorWithCode(r,`EEXIST`))throw r;if(await readUsableEveDevServerRegistry(e,t)!==void 0)return async()=>{};if(await removeStaleEveDevServerLock(i),Date.now()>a)throw Error(`Timed out after ${n}ms waiting for another ${t.label} process to start eve.`);await delay(100)}}function createEveBinaryPath(){return join(resolvePackageRoot(),`bin`,`eve.js`)}function parseLocalServerOrigin(e){let t=URL.parse(e);if(!(t===null||t.protocol!==`http:`&&t.protocol!==`https:`||!isLoopbackHostname(t.hostname)||t.port.length===0))return t.origin}function findLocalServerOrigin(e){for(let t of e.matchAll(SERVER_URL_CANDIDATE_PATTERN)){let e=parseLocalServerOrigin(t[0]);if(e!==void 0)return e}}function formatEveDevOutputLine(e,t){let n=e.replace(/\r$/,``),r=n.replace(ANSI_ESCAPE_PATTERN,``).trim();if(r.length===0||/^☰eve\b/.test(r)||r===`CONFIGURATION_FIELD_CONFLICT`||r.startsWith(`[CONFIGURATION_FIELD_CONFLICT]`))return;let i=t===void 0?`[eve:dev]`:`[eve:dev:${t}]`,a=/server listening at\s+(https?:\/\/[^\s]+)/i.exec(n);return a===null?`${i} ${n}`:`${i} server listening at ${a[1]}`}function createEveDevOutputWriter(e){let t=``,writeLine=t=>{let n=formatEveDevOutputLine(t,e.logLabel);n!==void 0&&e.stream.write(`${n}\n`)};return{flush(){t.length!==0&&(writeLine(t),t=``)},write(e){t+=e.toString(`utf8`);let n=t.split(`
-`);t=n.pop()??``;for(let e of n)writeLine(e)}}}function startServerProcess(e){let t=e.timeoutMs??18e4;return new Promise((n,r)=>{let i=spawn(e.command,e.args,{cwd:e.cwd,env:{...process.env,...e.env},stdio:[`ignore`,`pipe`,`pipe`]}),a=createEveDevOutputWriter({logLabel:e.logLabel,stream:process.stderr}),o=createEveDevOutputWriter({logLabel:e.logLabel,stream:process.stdout}),s=setTimeout(()=>{i.kill(),r(Error(`Timed out after ${t}ms waiting for eve to print its server URL.`))},t),cleanup=()=>{clearTimeout(s),i.off(`error`,handleError),i.off(`exit`,handleEarlyExit)},flushOutput=()=>{o.flush(),a.flush()},handleError=e=>{flushOutput(),cleanup(),r(e)},handleEarlyExit=(e,t)=>{flushOutput(),cleanup(),r(Error(`eve server process exited before printing its server URL (code ${String(e)}, signal ${String(t)}).`))},handleOutput=e=>{let t=findLocalServerOrigin(e.toString(`utf8`));t!==void 0&&(cleanup(),n({origin:t,process:i}))};i.once(`error`,handleError),i.once(`exit`,handleEarlyExit),i.stdout.on(`data`,e=>{o.write(e),handleOutput(e)}),i.stderr.on(`data`,e=>{a.write(e),handleOutput(e)})})}function installProcessShutdown(e){let t=e.process;if(t===void 0)return e;let close=()=>{t.killed||t.kill()};return process.once(`beforeExit`,close),process.once(`exit`,close),e}function startEveDevServer(e){return startServerProcess({args:[createEveBinaryPath(),`dev`,`--no-ui`,`--port`,`0`,...e.workspaceAgentName===void 0?[]:[`--agent`,e.workspaceAgentName]],command:process.execPath,cwd:e.appRoot,logLabel:e.logLabel,timeoutMs:e.timeoutMs}).then(installProcessShutdown)}function startEveProductionServer(e){let t=new URL(e.origin),n=t.port,r=join(e.appRoot,`.output`,`server`,`index.mjs`);if(!existsSync(r))throw Error(`eve production output is missing at ${r}. Run eve build from ${e.appRoot} before starting ${e.host.label}.`);return startServerProcess({args:[r],command:process.execPath,cwd:e.appRoot,env:{HOST:t.hostname,NITRO_HOST:t.hostname,NITRO_PORT:n,PORT:n}}).then(installProcessShutdown)}async function resolveSharedEveDevServer(e){let t=e.timeoutMs??18e4,n=await readUsableEveDevServerRegistry(e.appRoot,e.host);if(n!==void 0)return{origin:n};let r=await acquireEveDevServerLock(e.appRoot,e.host,t);try{let n=await readUsableEveDevServerRegistry(e.appRoot,e.host);if(n!==void 0)return{origin:n};let r=await startEveDevServer({appRoot:e.appRoot,logLabel:e.logLabel,timeoutMs:t,workspaceAgentName:e.workspaceAgentName});return await writeEveDevServerRegistry(e.appRoot,e.host,r),r}finally{await r()}}export{DEFAULT_EVE_SERVER_TIMEOUT_MS,resolveDevServerTimeout,resolveSharedEveDevServer,startEveProductionServer};
+import{mkdir,open,readFile,rm,stat,writeFile}from"node:fs/promises";import{isLoopbackHostname}from"#shared/network-address.js";import{existsSync}from"node:fs";import{join}from"node:path";import{resolvePackageRoot}from"#internal/application/package.js";import{spawn}from"node:child_process";import{readDevelopmentRuntimeArtifactsRevision}from"#services/dev-client/runtime-artifacts.js";import{readBuiltServerStartFailure}from"#shared/built-server-start-failure.js";const DEFAULT_EVE_SERVER_TIMEOUT_MS=18e4,ANSI_ESCAPE_PATTERN=RegExp(`\x1B\\[[0-?]*[ -/]*[@-~]`,`g`),SERVER_URL_CANDIDATE_PATTERN=/https?:\/\/[^\s"'<>]+/g;function normalizeOrigin(e){return new URL(e).origin}function isNodeErrorWithCode(e,t){return e instanceof Error&&`code`in e&&e.code===t}function delay(e){return new Promise(t=>setTimeout(t,e))}function isRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function resolveEveCacheDirectory(e){return join(e,`.eve`)}function resolveEveDevServerRegistryPath(e,t){return join(resolveEveCacheDirectory(e),`${t.slug}-dev-server.json`)}function resolveEveDevServerLockPath(e,t){return join(resolveEveCacheDirectory(e),`${t.slug}-dev-server.lock`)}function resolveDevServerTimeout(e,t){if(e!==void 0){if(!Number.isFinite(e)||e<=0)throw Error(`eve ${t.label} development server timeout must be a positive number.`);return e}}function normalizeDevServerRegistry(e){if(isRecord(e)&&typeof e.appRoot==`string`&&typeof e.origin==`string`&&typeof e.updatedAt==`string`&&(e.pid===null||typeof e.pid==`number`))try{return{appRoot:e.appRoot,origin:normalizeOrigin(e.origin),pid:e.pid,updatedAt:e.updatedAt}}catch{return}}async function readUsableEveDevServerRegistry(e,t){try{let n=normalizeDevServerRegistry(JSON.parse(await readFile(resolveEveDevServerRegistryPath(e,t),`utf8`)));return n===void 0||n.appRoot!==e||await readDevelopmentRuntimeArtifactsRevision({serverUrl:n.origin,timeoutMs:1e3})===void 0?void 0:n.origin}catch(e){if(isNodeErrorWithCode(e,`ENOENT`))return;throw e}}async function writeEveDevServerRegistry(e,t,n){await mkdir(resolveEveCacheDirectory(e),{recursive:!0}),await writeFile(resolveEveDevServerRegistryPath(e,t),`${JSON.stringify({appRoot:e,origin:n.origin,pid:n.process?.pid??null,updatedAt:new Date().toISOString()},null,2)}\n`)}async function removeStaleEveDevServerLock(e){try{let t=await stat(e);Date.now()-t.mtimeMs>3e4&&await rm(e,{force:!0})}catch(e){if(!isNodeErrorWithCode(e,`ENOENT`))throw e}}async function acquireEveDevServerLock(e,t,n){let r=resolveEveCacheDirectory(e),i=resolveEveDevServerLockPath(e,t),a=Date.now()+n;for(await mkdir(r,{recursive:!0});;)try{let e=await open(i,`wx`);return await e.writeFile(`${String(process.pid)}\n`),await e.close(),async()=>{await rm(i,{force:!0})}}catch(r){if(!isNodeErrorWithCode(r,`EEXIST`))throw r;if(await readUsableEveDevServerRegistry(e,t)!==void 0)return async()=>{};if(await removeStaleEveDevServerLock(i),Date.now()>a)throw Error(`Timed out after ${n}ms waiting for another ${t.label} process to start eve.`);await delay(100)}}function createEveBinaryPath(){return join(resolvePackageRoot(),`bin`,`eve.js`)}function parseLocalServerOrigin(e){let t=URL.parse(e);if(!(t===null||t.protocol!==`http:`&&t.protocol!==`https:`||!isLoopbackHostname(t.hostname)||t.port.length===0))return t.origin}function findLocalServerOrigin(e){for(let t of e.matchAll(SERVER_URL_CANDIDATE_PATTERN)){let e=parseLocalServerOrigin(t[0]);if(e!==void 0)return e}}function formatEveDevOutputLine(e,t){let n=e.replace(/\r$/,``),r=n.replace(ANSI_ESCAPE_PATTERN,``).trim();if(r.length===0||/^☰eve\b/.test(r)||r===`CONFIGURATION_FIELD_CONFLICT`||r.startsWith(`[CONFIGURATION_FIELD_CONFLICT]`))return;let i=t===void 0?`[eve:dev]`:`[eve:dev:${t}]`,a=/server listening at\s+(https?:\/\/[^\s]+)/i.exec(n);return a===null?`${i} ${n}`:`${i} server listening at ${a[1]}`}function createEveDevOutputWriter(e){let t=``,writeLine=t=>{let n=formatEveDevOutputLine(t,e.logLabel);n!==void 0&&e.stream.write(`${n}\n`)};return{flush(){t.length!==0&&(writeLine(t),t=``)},write(e){t+=e.toString(`utf8`);let n=t.split(`
+`);t=n.pop()??``;for(let e of n)writeLine(e)}}}function startServerProcess(e){let t=e.timeoutMs??18e4;return new Promise((n,r)=>{let i=spawn(e.command,e.args,{cwd:e.cwd,env:{...process.env,...e.env},stdio:[`ignore`,`pipe`,`pipe`]}),a=createEveDevOutputWriter({logLabel:e.logLabel,stream:process.stderr}),o=createEveDevOutputWriter({logLabel:e.logLabel,stream:process.stdout}),s=setTimeout(()=>{i.kill(),r(Error(`Timed out after ${t}ms waiting for eve to print its server URL.`))},t),c=!1,l=``,cleanup=()=>{c=!0,l=``,clearTimeout(s),i.off(`error`,handleError),i.off(`exit`,handleEarlyExit)},flushOutput=()=>{o.flush(),a.flush()},handleError=e=>{flushOutput(),cleanup(),r(e)},handleEarlyExit=(e,t)=>{flushOutput(),cleanup(),r(Error(`eve server process exited before printing its server URL (code ${String(e)}, signal ${String(t)}).`))},handleOutput=t=>{if(c)return;let a=t.toString(`utf8`);l+=a;let o=e.listen===void 0?void 0:readBuiltServerStartFailure(l,e.listen);if(o!==void 0){flushOutput(),cleanup(),i.kill(),r(o);return}let s=findLocalServerOrigin(a);s!==void 0&&(cleanup(),n({origin:s,process:i}))};i.once(`error`,handleError),i.once(`exit`,handleEarlyExit),i.stdout.on(`data`,e=>{o.write(e),handleOutput(e)}),i.stderr.on(`data`,e=>{a.write(e),handleOutput(e)})})}function installProcessShutdown(e){let t=e.process;if(t===void 0)return e;let close=()=>{t.killed||t.kill()};return process.once(`beforeExit`,close),process.once(`exit`,close),e}function startEveDevServer(e){return startServerProcess({args:[createEveBinaryPath(),`dev`,`--no-ui`,`--port`,`0`,...e.workspaceAgentName===void 0?[]:[`--agent`,e.workspaceAgentName]],command:process.execPath,cwd:e.appRoot,logLabel:e.logLabel,timeoutMs:e.timeoutMs}).then(installProcessShutdown)}function startEveProductionServer(e){let t=new URL(e.origin),n=t.port,r=join(e.appRoot,`.output`,`server`,`index.mjs`);if(!existsSync(r))throw Error(`eve production output is missing at ${r}. Run eve build from ${e.appRoot} before starting ${e.host.label}.`);return startServerProcess({args:[r],command:process.execPath,cwd:e.appRoot,env:{HOST:t.hostname,NITRO_HOST:t.hostname,NITRO_PORT:n,PORT:n},listen:{host:t.hostname,port:n,retryHint:e.portRetryHint}}).then(installProcessShutdown)}async function resolveSharedEveDevServer(e){let t=e.timeoutMs??18e4,n=await readUsableEveDevServerRegistry(e.appRoot,e.host);if(n!==void 0)return{origin:n};let r=await acquireEveDevServerLock(e.appRoot,e.host,t);try{let n=await readUsableEveDevServerRegistry(e.appRoot,e.host);if(n!==void 0)return{origin:n};let r=await startEveDevServer({appRoot:e.appRoot,logLabel:e.logLabel,timeoutMs:t,workspaceAgentName:e.workspaceAgentName});return await writeEveDevServerRegistry(e.appRoot,e.host,r),r}finally{await r()}}export{DEFAULT_EVE_SERVER_TIMEOUT_MS,resolveDevServerTimeout,resolveSharedEveDevServer,startEveProductionServer};

package/dist/src/shared/sandbox-environment.d.ts

@@ -1,9 +1,8 @@
 import type { SessionAuth, SessionParent, SessionTurn } from "#context/keys.js";
-import type { SandboxProviderRuntime } from "#shared/sandbox-provider.js";
+import type { SandboxProviderRuntime } from "#sandbox/provider.js";
 import type { RuntimeSandboxSession, RuntimeSandboxSessionFor, SandboxSession } from "#shared/sandbox-session.js";
 declare const ENVIRONMENT: unique symbol;
 declare const PROVIDER_RUNTIME: unique symbol;
-declare const CONFIGURATION_HASH: unique symbol;
 export interface SandboxSelectorContext {
     readonly session: {
         readonly auth: SessionAuth;
@@ -15,9 +14,9 @@ export interface SandboxSelectorContext {
 export type SandboxSelector = (context: SandboxSelectorContext) => Promise<RuntimeSandboxSession> | RuntimeSandboxSession;
 export type SandboxOpenArguments<Options> = Options extends undefined ? [] : Record<never, never> extends Options ? [options?: Options] : [options: Options];
 export interface SandboxEnvironmentIdentity {
-    readonly [CONFIGURATION_HASH]: string;
     readonly [ENVIRONMENT]: true;
-    readonly [PROVIDER_RUNTIME]: SandboxProviderRuntime;
+    /** A {@link SandboxProviderRuntime}, opaque so the public type does not carry core internals. */
+    readonly [PROVIDER_RUNTIME]: unknown;
     readonly provider: string;
 }
 export interface SandboxEnvironment<Options extends object | undefined = object, Session extends SandboxSession = SandboxSession> extends SandboxEnvironmentIdentity {
@@ -25,17 +24,12 @@ export interface SandboxEnvironment<Options extends object | undefined = object,
 }
 interface ConstructorRuntime {
     open(input: {
-        readonly configurationHash: string;
         readonly environment: object;
-        readonly environmentConfigurationHash: string;
         readonly options: object | undefined;
         readonly provider: SandboxProviderRuntime;
     }): Promise<RuntimeSandboxSession>;
 }
-export declare function createSandboxEnvironment<Options extends object | undefined = object, Session extends SandboxSession = SandboxSession>(input: {
-    readonly configuration?: unknown;
-    readonly runtime: SandboxProviderRuntime;
-}): SandboxEnvironment<Options, Session>;
+export declare function createSandboxEnvironment<Options extends object | undefined = object, Session extends SandboxSession = SandboxSession>(runtime: SandboxProviderRuntime): SandboxEnvironment<Options, Session>;
 export declare function getSandboxEnvironmentRuntime(environment: SandboxEnvironmentIdentity): SandboxProviderRuntime;
 export declare function bindSandboxEnvironment(selector: SandboxSelector, environment: SandboxEnvironmentIdentity): SandboxSelector;
 export declare function getBoundSandboxEnvironment(value: unknown): SandboxEnvironmentIdentity | undefined;

package/dist/src/shared/sandbox-environment.js

@@ -1 +1 @@
-import{createHash}from"node:crypto";import{ContextContainer,contextStorage}from"#context/container.js";const ENVIRONMENT=Symbol.for(`eve.sandbox-environment`),PROVIDER_RUNTIME=Symbol.for(`eve.sandbox-provider-runtime`),CONFIGURATION_HASH=Symbol.for(`eve.sandbox-environment-configuration-hash`),SELECTOR_ENVIRONMENT=Symbol.for(`eve.sandbox-selector-environment`),RUNTIMES=Symbol.for(`eve.sandbox-constructor-runtimes`),globals=globalThis,runtimes=globals[RUNTIMES]??=new WeakMap;function createSandboxEnvironment(e){let t;return t={[CONFIGURATION_HASH]:hashConstructorOptions({environment:e.configuration,sandbox:{}}),[ENVIRONMENT]:!0,[PROVIDER_RUNTIME]:e.runtime,provider:e.runtime.providerName,async open(...n){let r=n[0],i=contextStorage.getStore(),a=i===void 0?void 0:runtimes.get(i);if(a===void 0)throw Error(`Sandbox environments can only open sandboxes inside defineSandbox().`);return await a.open({configurationHash:hashConstructorOptions({environment:e.configuration,sandbox:r}),environment:t,environmentConfigurationHash:t[CONFIGURATION_HASH],options:r,provider:e.runtime})}},t}function hashConstructorOptions(e){return createHash(`sha256`).update(stableSerialize(e)).digest(`hex`)}function stableSerialize(e,t=new WeakSet){if(e===null||typeof e==`boolean`||typeof e==`number`||typeof e==`string`)return JSON.stringify(e);if(typeof e==`function`)return`function:${e.toString()}`;if(Array.isArray(e))return`[${e.map(e=>stableSerialize(e,t)).join(`,`)}]`;if(typeof e==`object`){if(t.has(e))return`[circular]`;t.add(e);let n=e.constructor?.name??`Object`,r=`{${Object.entries(e).sort(([e],[t])=>e.localeCompare(t)).map(([e,n])=>`${JSON.stringify(e)}:${stableSerialize(n,t)}`).join(`,`)}}`;return t.delete(e),`${n}:${r}`}return typeof e}function getSandboxEnvironmentRuntime(e){return e[PROVIDER_RUNTIME]}function bindSandboxEnvironment(e,t){return Object.defineProperty(e,SELECTOR_ENVIRONMENT,{value:t}),e}function getBoundSandboxEnvironment(e){let t=typeof e==`function`?Reflect.get(e,SELECTOR_ENVIRONMENT):void 0;return isSandboxEnvironment(t)?t:void 0}function isSandboxEnvironment(e){return typeof e==`object`&&!!e&&Reflect.get(e,ENVIRONMENT)===!0&&typeof Reflect.get(e,`provider`)==`string`&&typeof Reflect.get(e,`open`)==`function`}async function runWithSandboxConstructorRuntime(e,t){let n=contextStorage.getStore(),r=n??new ContextContainer,i=runtimes.get(r);runtimes.set(r,e);try{return n===void 0?await contextStorage.run(r,t):await t()}finally{i===void 0?runtimes.delete(r):runtimes.set(r,i)}}export{bindSandboxEnvironment,createSandboxEnvironment,getBoundSandboxEnvironment,getSandboxEnvironmentRuntime,isSandboxEnvironment,runWithSandboxConstructorRuntime};
+import{ContextContainer,contextStorage}from"#context/container.js";const ENVIRONMENT=Symbol.for(`eve.sandbox-environment`),PROVIDER_RUNTIME=Symbol.for(`eve.sandbox-provider-runtime`),SELECTOR_ENVIRONMENT=Symbol.for(`eve.sandbox-selector-environment`),RUNTIMES=Symbol.for(`eve.sandbox-constructor-runtimes`),globals=globalThis,runtimes=globals[RUNTIMES]??=new WeakMap;function createSandboxEnvironment(e){let t={[ENVIRONMENT]:!0,[PROVIDER_RUNTIME]:e,provider:e.providerName,async open(...n){let r=n[0],i=contextStorage.getStore(),a=i===void 0?void 0:runtimes.get(i);if(a===void 0)throw Error("Sandbox environments can only open sandboxes inside defineSandbox(). Use `ctx.getSandbox()` to reach the session's sandbox from tools and other runtime code.");return await a.open({environment:t,options:r,provider:e})}};return t}function getSandboxEnvironmentRuntime(e){return e[PROVIDER_RUNTIME]}function bindSandboxEnvironment(e,t){return Object.defineProperty(e,SELECTOR_ENVIRONMENT,{value:t}),e}function getBoundSandboxEnvironment(e){let t=typeof e==`function`?Reflect.get(e,SELECTOR_ENVIRONMENT):void 0;return isSandboxEnvironment(t)?t:void 0}function isSandboxEnvironment(e){return typeof e==`object`&&!!e&&Reflect.get(e,ENVIRONMENT)===!0&&typeof Reflect.get(e,`provider`)==`string`&&typeof Reflect.get(e,`open`)==`function`}async function runWithSandboxConstructorRuntime(e,t){let n=contextStorage.getStore(),r=n??new ContextContainer,i=runtimes.get(r);runtimes.set(r,e);try{return n===void 0?await contextStorage.run(r,t):await t()}finally{i===void 0?runtimes.delete(r):runtimes.set(r,i)}}export{bindSandboxEnvironment,createSandboxEnvironment,getBoundSandboxEnvironment,getSandboxEnvironmentRuntime,isSandboxEnvironment,runWithSandboxConstructorRuntime};

package/dist/src/shared/sandbox-network-policy.d.ts

@@ -1,11 +1,9 @@
-import type * as Vercel from "#compiled/@vercel/sandbox/index.js";
 /**
  * Firewall network policy applied to a live sandbox session.
  *
- * eve-owned alias of the provider network-policy shape. Use it to restrict
- * egress (`"deny-all"`, an allow-list) or to broker credentials onto
- * outgoing requests. A per-domain `transform` injects headers at the
- * firewall so secrets never enter the sandbox process:
+ * Use it to restrict egress (`"deny-all"`, an allow-list) or to broker
+ * credentials onto outgoing requests. A per-domain `transform` injects
+ * headers at the firewall so secrets never enter the sandbox process:
  *
  * ```ts
  * import { environment } from "../sandbox";
@@ -19,11 +17,49 @@ import type * as Vercel from "#compiled/@vercel/sandbox/index.js";
  * });
  * ```
  *
- * The Docker provider honors only the coarse `"allow-all"` and
- * `"deny-all"` policies. just-bash environments do not expose
- * `setNetworkPolicy` because their network policy is fixed at sandbox creation.
+ * A provider rejects any part of a policy it cannot enforce instead of
+ * weakening it. The Docker provider honors only `"allow-all"` and
+ * `"deny-all"`.
  */
-export type SandboxNetworkPolicy = Vercel.NetworkPolicy;
+export type SandboxNetworkPolicy = "allow-all" | "deny-all" | {
+    /** Allowed domains, or a map from domain to the rules applied to its requests. */
+    readonly allow?: readonly string[] | Readonly<Record<string, readonly SandboxNetworkRule[]>>;
+    readonly subnets?: {
+        readonly allow?: readonly string[];
+        readonly deny?: readonly string[];
+    };
+};
+/** Exactly one of `transform` (inject headers) or `forwardURL` (proxy the request). */
+export type SandboxNetworkRule = {
+    readonly match?: SandboxNetworkMatch;
+} & ({
+    readonly transform: readonly {
+        readonly headers?: Readonly<Record<string, string>>;
+    }[];
+} | {
+    readonly forwardURL: string;
+});
+/** Which requests a {@link SandboxNetworkRule} applies to. */
+export interface SandboxNetworkMatch {
+    readonly headers?: readonly {
+        readonly key?: SandboxNetworkMatcher;
+        readonly value?: SandboxNetworkMatcher;
+    }[];
+    readonly method?: readonly string[];
+    readonly path?: SandboxNetworkMatcher;
+    readonly queryString?: readonly {
+        readonly key?: SandboxNetworkMatcher;
+        readonly value?: SandboxNetworkMatcher;
+    }[];
+}
+/** Sets exactly one of `exact`, `startsWith`, or `regex`. */
+export type SandboxNetworkMatcher = {
+    readonly exact: string;
+} | {
+    readonly startsWith: string;
+} | {
+    readonly regex: string;
+};
 /** Initial network configuration shared by network-capable sandbox providers. */
 export interface SandboxNetworkOptions {
     readonly networkPolicy?: SandboxNetworkPolicy;

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

@@ -1,5 +1,3 @@
-import { type SandboxEnvironment, type SandboxSelectorContext } from "#shared/sandbox-environment.js";
-import type { SandboxSession } from "#shared/sandbox-session.js";
 export interface SandboxDeleteOptions {
     readonly abortSignal?: AbortSignal;
 }
@@ -7,113 +5,12 @@ export interface SandboxProviderResourceFile {
     readonly content: string | Uint8Array;
     readonly relativePath: string;
 }
-export interface SandboxProviderResourceTree {
-    readonly files: readonly SandboxProviderResourceFile[];
-    readonly key: string;
-    readonly mountPath: string;
-    readonly targetPath: string;
-}
-export type SandboxProviderResourceSource = {
-    readonly kind: "none";
-} | {
-    readonly key: string;
-    readonly kind: "inline";
-} | {
-    readonly key: string;
-    readonly kind: "materialized";
-    readonly path: string;
-};
-export interface SandboxProviderResources {
-    readonly skills?: SandboxProviderResourceTree;
-    readonly source: SandboxProviderResourceSource;
-    readonly workspace?: SandboxProviderResourceTree;
-}
-export declare function sandboxProviderResourceIdentity(resources: SandboxProviderResources): object;
-export interface SandboxProviderTargetFile {
-    readonly content: string | Uint8Array;
-    readonly path: string;
-}
-export declare function providerResourceTargetFiles(resources: SandboxProviderResources): SandboxProviderTargetFile[];
 export type SandboxPreparedArtifact = null | boolean | number | string | readonly SandboxPreparedArtifact[] | {
     readonly [key: string]: SandboxPreparedArtifact;
 };
 export declare function isSandboxPreparedArtifact(value: unknown): value is SandboxPreparedArtifact;
-export declare function isSandboxPreparedArtifactRecord(artifact: unknown): artifact is {
-    readonly [key: string]: SandboxPreparedArtifact;
-};
 export interface SandboxProviderFiles {
     list(): Promise<readonly string[]>;
     read(path: string): Promise<Uint8Array>;
     readText(path: string): Promise<string>;
 }
-export interface SandboxProviderHost {
-    loadOptionalPackage<T>(input: {
-        readonly autoInstall: boolean;
-        readonly importModule: () => Promise<T>;
-        readonly installPackageName?: string;
-        readonly ignoredOptionalDependencies?: readonly string[];
-        readonly missingMessage: string;
-        readonly packageName: string;
-    }): Promise<T>;
-    resolveProjectPath(path: string): string;
-}
-export interface SandboxProviderPrepareContext {
-    readonly files: SandboxProviderFiles;
-    readonly host: SandboxProviderHost;
-    readonly log?: (message: string) => void;
-    readonly resources: SandboxProviderResources;
-    readonly sourceRevision: string;
-    readonly storagePath: string;
-}
-export interface SandboxProviderSessionContext {
-    readonly host: SandboxProviderHost;
-    readonly session: SandboxSelectorContext["session"];
-    readonly storagePath: string;
-}
-export interface SandboxProviderHandle<Session extends SandboxSession = SandboxSession> {
-    readonly sandbox: Session;
-    onRuntimeShutdown(): Promise<void>;
-    onSandboxDelete(options?: SandboxDeleteOptions): Promise<void>;
-    onSandboxStop(): Promise<void>;
-}
-export interface SandboxProviderImplementation<OpenOptions extends object | undefined, PreparedArtifact extends SandboxPreparedArtifact, SessionState, Session extends SandboxSession = SandboxSession> {
-    /**
-     * Permanently releases resources owned by a durable session after its terminal outcome.
-     * Implementations must be idempotent because the cleanup step may retry.
-     */
-    onSessionEnd?(context: SandboxProviderSessionContext, artifact: Readonly<PreparedArtifact>, state: Readonly<SessionState>, options: {
-        readonly reason: "completed" | "expired" | "failed";
-    }): Promise<void>;
-    prepare(context: SandboxProviderPrepareContext): Promise<PreparedArtifact>;
-    resume(context: SandboxProviderSessionContext, artifact: Readonly<PreparedArtifact>, state: Readonly<SessionState>): Promise<SandboxProviderHandle<Session>>;
-    start(context: SandboxProviderSessionContext, options: Readonly<OpenOptions> | undefined, artifact: Readonly<PreparedArtifact>): Promise<{
-        readonly handle: SandboxProviderHandle<Session>;
-        readonly state: SessionState;
-    }>;
-}
-type SandboxOptionArguments<Options extends object | undefined> = Options extends undefined ? [options?: undefined] : Record<never, never> extends Options ? [options?: Readonly<Options>] : [options: Readonly<Options>];
-export type SandboxProviderDefinition<EnvironmentOptions extends object | undefined, OpenOptions extends object | undefined, PreparedArtifact extends SandboxPreparedArtifact, SessionState, Session extends SandboxSession> = {
-    readonly name: string;
-    readonly stateProtocolVersion?: number;
-    environment(...args: SandboxOptionArguments<EnvironmentOptions>): SandboxProviderImplementation<OpenOptions, PreparedArtifact, SessionState, Session>;
-};
-export interface SandboxProvider<EnvironmentOptions extends object | undefined, OpenOptions extends object | undefined, Session extends SandboxSession> {
-    readonly name: string;
-    environment(...args: SandboxOptionArguments<EnvironmentOptions>): SandboxEnvironment<OpenOptions, Session>;
-}
-type ErasedSandboxProviderImplementation = SandboxProviderImplementation<object | undefined, SandboxPreparedArtifact, SandboxPreparedArtifact, SandboxSession>;
-export interface SandboxProviderRuntime {
-    readonly implementation: ErasedSandboxProviderImplementation;
-    readonly providerName: string;
-    readonly stateProtocolVersion: number;
-}
-export declare function defineSandboxProvider<EnvironmentOptions extends object | undefined = undefined, OpenOptions extends object | undefined = undefined, PreparedArtifact extends SandboxPreparedArtifact = SandboxPreparedArtifact, SessionState = SandboxPreparedArtifact, Session extends SandboxSession = SandboxSession>(definition: SandboxProviderDefinition<EnvironmentOptions, OpenOptions, PreparedArtifact, SessionState, Session>): SandboxProvider<EnvironmentOptions, OpenOptions, Session>;
-export declare function createSandboxProviderResources(input: {
-    readonly resourcesKey?: string;
-    readonly resourcesPath?: string;
-    readonly seedFiles?: readonly {
-        readonly content: string | Uint8Array;
-        readonly path: string;
-    }[];
-}): SandboxProviderResources;
-export {};

package/dist/src/shared/sandbox-provider.js

@@ -1 +1 @@
-import{createSandboxEnvironment}from"#shared/sandbox-environment.js";function sandboxProviderResourceIdentity(e){return{skills:e.skills?.key,workspace:e.workspace?.key}}function providerResourceTargetFiles(e){return[e.workspace,e.skills].flatMap(e=>e===void 0?[]:e.files.map(t=>({content:t.content,path:`${e.targetPath}/${t.relativePath}`})))}function isSandboxPreparedArtifact(e){return e===null||typeof e==`boolean`||typeof e==`number`||typeof e==`string`?!0:Array.isArray(e)?e.every(isSandboxPreparedArtifact):typeof e==`object`&&!!e&&Object.values(e).every(isSandboxPreparedArtifact)}function isSandboxPreparedArtifactRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function defineSandboxProvider(e){let t=e.stateProtocolVersion??1;return{name:e.name,environment(...n){return createSandboxEnvironment({configuration:n[0],runtime:{implementation:eraseSandboxProviderImplementation(e.environment(...n)),providerName:e.name,stateProtocolVersion:t}})}}}function eraseSandboxProviderImplementation(e){return e}function createSandboxProviderResources(e){if(e.resourcesKey===void 0)return{source:{kind:`none`}};let t=e.seedFiles??[],n=e.resourcesPath===void 0?{key:e.resourcesKey,kind:`inline`}:{key:e.resourcesKey,kind:`materialized`,path:e.resourcesPath};return{skills:createResourceTree({files:t.filter(e=>e.path.startsWith(`$HOME/.agents/skills/`)),key:`${e.resourcesKey}:skills`,mountPath:`/eve/resources/skills`,prefix:`$HOME/.agents/skills/`,targetPath:`$HOME/.agents/skills`}),source:n,workspace:createResourceTree({files:t.filter(e=>!e.path.startsWith(`$HOME/.agents/skills/`)),key:`${e.resourcesKey}:workspace`,mountPath:`/eve/resources/workspace`,prefix:`/workspace/`,targetPath:`/workspace`})}}function createResourceTree(e){return{files:e.files.map(t=>({content:t.content,relativePath:t.path.startsWith(e.prefix)?t.path.slice(e.prefix.length):t.path})),key:e.key,mountPath:e.mountPath,targetPath:e.targetPath}}export{createSandboxProviderResources,defineSandboxProvider,isSandboxPreparedArtifact,isSandboxPreparedArtifactRecord,providerResourceTargetFiles,sandboxProviderResourceIdentity};
+function isSandboxPreparedArtifact(e){return e===null||typeof e==`boolean`||typeof e==`number`||typeof e==`string`?!0:Array.isArray(e)?e.every(isSandboxPreparedArtifact):typeof e==`object`&&!!e&&Object.values(e).every(isSandboxPreparedArtifact)}export{isSandboxPreparedArtifact};

package/dist/src/shared/sandbox-recorded-data-error.d.ts

@@ -0,0 +1,4 @@
+/** A provider's recorded session state does not match the shape this eve version writes. */
+export declare function invalidSandboxSessionStateError(label: string): Error;
+/** A provider's prepared artifact from `eve build` does not match the shape this eve version writes. */
+export declare function invalidPreparedSandboxArtifactError(label: string): Error;

package/dist/src/shared/sandbox-recorded-data-error.js

@@ -0,0 +1 @@
+function invalidSandboxSessionStateError(e){return Error(`Invalid ${e} session state. This session's recorded sandbox state does not match the format this eve version expects, usually because the session started under a different eve version. Start a new session to get a fresh sandbox.`)}function invalidPreparedSandboxArtifactError(e){return Error(`Invalid prepared ${e} artifact. The artifact recorded by \`eve build\` does not match the format this eve version expects, usually because the build used a different eve version. Run \`eve build\` with the eve version this runtime uses, then redeploy.`)}export{invalidPreparedSandboxArtifactError,invalidSandboxSessionStateError};

package/dist/src/shared/sandbox-session-gone-error.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Thrown by a provider's `resume()` when the session's native sandbox no
+ * longer exists. eve then clears the session's sandbox state and reruns the
+ * sandbox selector, which starts a fresh sandbox, as it would after
+ * `sandbox.delete()`. Throw it only for a sandbox that is gone; other
+ * failures must surface unchanged.
+ */
+export declare class SandboxSessionGoneError extends Error {
+    constructor(message: string);
+    /** Also matches an error from another copy of this class, such as one a provider bundles. */
+    static is(error: unknown): error is SandboxSessionGoneError;
+}

package/dist/src/shared/sandbox-session-gone-error.js

@@ -0,0 +1 @@
+var SandboxSessionGoneError=class SandboxSessionGoneError extends Error{constructor(e){super(e),this.name=`SandboxSessionGoneError`}static is(e){return e instanceof SandboxSessionGoneError||e instanceof Error&&e.name===`SandboxSessionGoneError`}};export{SandboxSessionGoneError};

package/dist/src/shared/sandbox-session.d.ts

@@ -1,59 +1,88 @@
-import type { Experimental_SandboxSession as AiSdkSandbox } from "ai";
 import type { SandboxDeleteOptions } from "#shared/sandbox-provider.js";
 /**
- * Options for running one command in a sandbox. Shape mirrors the AI
- * SDK {@link AiSdkSandbox} `run` argument so authored code that targets
- * either surface uses the same call shape.
+ * Options for running one command, or spawning one process, in a sandbox.
+ * `env` holds per-call variables, merged over the sandbox's environment.
+ * Aborting kills the process.
  */
-export type SandboxRunOptions = Parameters<AiSdkSandbox["run"]>[0];
-/**
- * Serializable result returned after running one sandbox command.
- */
-export type SandboxCommandResult = Awaited<ReturnType<AiSdkSandbox["run"]>>;
-/**
- * Options for spawning one long-running process in a sandbox. Shape
- * mirrors the AI SDK {@link AiSdkSandbox} `spawn` argument.
- */
-export type SandboxSpawnOptions = Parameters<AiSdkSandbox["spawn"]>[0];
-/**
- * Handle to a long-running process spawned via {@link SandboxSession.spawn}.
- * Mirrors the AI SDK `Experimental_SandboxProcess` type.
- */
-export type SandboxProcess = Awaited<ReturnType<AiSdkSandbox["spawn"]>>;
-/**
- * Options for reading one file as a stream of bytes.
- */
-export type SandboxReadFileOptions = Parameters<AiSdkSandbox["readFile"]>[0];
-/**
- * Options for reading one file as raw bytes.
- */
-export type SandboxReadBinaryFileOptions = Parameters<AiSdkSandbox["readBinaryFile"]>[0];
+export interface SandboxRunOptions {
+    readonly abortSignal?: AbortSignal;
+    readonly command: string;
+    readonly env?: Readonly<Record<string, string>>;
+    /** Relative directories resolve from the workspace root, which is also the default. */
+    readonly workingDirectory?: string;
+}
+/** Options for spawning one long-running process in a sandbox. */
+export type SandboxSpawnOptions = SandboxRunOptions;
+/** Result of one finished sandbox command. A nonzero `exitCode` does not throw. */
+export interface SandboxCommandResult {
+    readonly exitCode: number;
+    readonly stderr: string;
+    readonly stdout: string;
+}
+/** Handle to a long-running process spawned via {@link SandboxSession.spawn}. */
+export interface SandboxProcess {
+    readonly pid?: number;
+    readonly stderr: ReadableStream<Uint8Array>;
+    readonly stdout: ReadableStream<Uint8Array>;
+    /** Terminates the process. Idempotent. */
+    kill(): Promise<void>;
+    wait(): Promise<{
+        readonly exitCode: number;
+    }>;
+}
+/** Options for reading one file as a stream of bytes. */
+export interface SandboxReadFileOptions {
+    readonly abortSignal?: AbortSignal;
+    readonly path: string;
+}
+/** Options for reading one file as raw bytes. */
+export type SandboxReadBinaryFileOptions = SandboxReadFileOptions;
 /**
  * Options for reading one text file from a sandbox.
  *
- * `encoding`, `startLine`, and `endLine` are passed through to the
- * public-surface decoder. `"utf-8"` decodes with `TextDecoder` in fatal
- * mode; other encodings fall back to Node's `Buffer.toString(encoding)`.
- * Line ranges are 1-based and inclusive; `endLine` past the file's line
- * count returns through EOF without error.
+ * `"utf-8"` decodes with `TextDecoder` in fatal mode; other encodings fall
+ * back to Node's `Buffer.toString(encoding)`. Line ranges are 1-based and
+ * inclusive; `endLine` past the file's line count returns through EOF
+ * without error.
  */
-export type SandboxReadTextFileOptions = Parameters<AiSdkSandbox["readTextFile"]>[0];
-/**
- * Options for writing one file from a stream of bytes.
- */
-export type SandboxWriteFileOptions = Parameters<AiSdkSandbox["writeFile"]>[0];
-/**
- * Options for writing one file from raw bytes.
- */
-export type SandboxWriteBinaryFileOptions = Parameters<AiSdkSandbox["writeBinaryFile"]>[0];
+export interface SandboxReadTextFileOptions extends SandboxReadFileOptions {
+    readonly encoding?: string;
+    readonly endLine?: number;
+    readonly startLine?: number;
+}
+/** Options for writing one file from a stream of bytes. */
+export interface SandboxWriteFileOptions {
+    readonly abortSignal?: AbortSignal;
+    readonly content: ReadableStream<Uint8Array>;
+    readonly path: string;
+}
+/** Options for writing one file from raw bytes. */
+export interface SandboxWriteBinaryFileOptions {
+    readonly abortSignal?: AbortSignal;
+    readonly content: Uint8Array;
+    readonly path: string;
+}
+/** Options for writing one text file to a sandbox. Encodes as UTF-8 unless `encoding` is set. */
+export interface SandboxWriteTextFileOptions {
+    readonly abortSignal?: AbortSignal;
+    readonly content: string;
+    readonly encoding?: string;
+    readonly path: string;
+}
 /**
- * Options for writing one text file to a sandbox.
+ * Options for writing several files from raw bytes in one batch.
  */
-export type SandboxWriteTextFileOptions = Parameters<AiSdkSandbox["writeTextFile"]>[0];
+export interface SandboxWriteFilesOptions {
+    readonly abortSignal?: AbortSignal;
+    readonly files: readonly {
+        readonly content: Uint8Array;
+        readonly path: string;
+    }[];
+}
 /**
  * Options for removing a path from a sandbox.
  *
- * Relative paths resolve from `/workspace`; absolute paths pass through.
+ * Relative paths resolve from the workspace root; absolute paths pass through.
  * `force` ignores missing paths. `recursive` permits removing non-empty
  * directories.
  */
@@ -64,32 +93,37 @@ export interface SandboxRemovePathOptions {
     readonly recursive?: boolean;
 }
 /**
- * Public eve-owned sandbox session exposed to authored lifecycle hooks.
+ * The sandbox session that authored tools, hooks, and `prepare` receive.
  *
- * The eight I/O methods (`run`, `spawn`, `readFile`, `readBinaryFile`,
- * `readTextFile`, `writeFile`, `writeBinaryFile`, `writeTextFile`) are
- * pulled directly from the AI SDK {@link AiSdkSandbox} type, so authored
- * code that targets either surface uses identical signatures. `resolvePath`
- * is an eve-specific extension for `/workspace` path anchoring.
- *
- * Relative paths resolve from `/workspace`, the live working directory
- * for every provider. Absolute paths pass through unchanged.
+ * Relative paths resolve from the workspace root, where commands start by
+ * default: `/workspace` on every built-in provider. Absolute paths pass
+ * through unchanged. Writes create missing parent directories and overwrite
+ * existing files. Reads resolve to `null` only when the path does not exist.
  *
+ * The method set stays assignable to the AI SDK's
+ * `Experimental_SandboxSession`, apart from its `description`.
  */
-export interface SandboxSession extends Pick<AiSdkSandbox, "run" | "spawn" | "readFile" | "readBinaryFile" | "readTextFile" | "writeFile" | "writeBinaryFile" | "writeTextFile"> {
+export interface SandboxSession {
+    run(options: SandboxRunOptions): Promise<SandboxCommandResult>;
+    spawn(options: SandboxSpawnOptions): Promise<SandboxProcess>;
+    readFile(options: SandboxReadFileOptions): Promise<ReadableStream<Uint8Array> | null>;
+    readBinaryFile(options: SandboxReadBinaryFileOptions): Promise<Uint8Array | null>;
+    readTextFile(options: SandboxReadTextFileOptions): Promise<string | null>;
+    writeFile(options: SandboxWriteFileOptions): Promise<void>;
+    writeBinaryFile(options: SandboxWriteBinaryFileOptions): Promise<void>;
+    writeTextFile(options: SandboxWriteTextFileOptions): Promise<void>;
     /**
-     * Anchors a sandbox-relative path to `/workspace` and returns the
-     * resulting absolute path.
-     *
-     * Relative paths resolve from `/workspace`; absolute paths pass through.
-     * The read and write methods already apply this internally.
+     * Writes several files in as few provider calls as the provider allows. A
+     * batch is not atomic: a rejected batch may leave earlier files written.
      */
-    resolvePath(path: string): string;
+    writeFiles(options: SandboxWriteFilesOptions): Promise<void>;
     /**
-     * Removes one file or directory from the sandbox filesystem.
-     *
-     * Relative paths resolve from `/workspace`; absolute paths pass through.
+     * Anchors a sandbox-relative path to the workspace root and returns the
+     * resulting absolute path, so `resolvePath(".")` is the root itself. The
+     * read and write methods already apply it.
      */
+    resolvePath(path: string): string;
+    /** Removes one file or directory from the sandbox filesystem. */
     removePath(options: SandboxRemovePathOptions): Promise<void>;
 }
 export interface RuntimeSandboxSession extends SandboxSession {
@@ -103,23 +137,3 @@ export interface RuntimeSandboxSession extends SandboxSession {
     stop(): Promise<void>;
 }
 export type RuntimeSandboxSessionFor<Session extends SandboxSession> = Session & Pick<RuntimeSandboxSession, "delete" | "stop">;
-/**
- * Internal sandbox session, used to construct the public {@link SandboxSession}.
- *
- * Provider implementations only need to provide byte-oriented file I/O and
- * a `spawn` primitive; the public surface (binary and text variants,
- * line-range slicing, encoding handling, the `run` wrapper) is built on
- * top of these primitives by `buildSandboxSession`.
- *
- * Each method's signature mirrors its public counterpart (and the AI
- * SDK {@link AiSdkSandbox} surface) so providers look symmetric with
- * what authored code sees. The `path` field on `readFile`/`writeFile`
- * here is the **already-resolved** path: the public-surface builder
- * calls `resolvePath` before delegating.
- */
-export interface InternalSandboxSession extends Pick<AiSdkSandbox, "spawn" | "readFile" | "writeFile"> {
-    /** Removes an already-resolved path from the provider filesystem. */
-    removePath(options: SandboxRemovePathOptions): Promise<void>;
-    /** Translates a user-facing path to the provider's native path. */
-    resolvePath(path: string): string;
-}

package/dist/src/shared/sandbox-template-error.d.ts

@@ -1,9 +1,24 @@
+type SandboxTemplateNotProvisionedInput = 
+/** The build recorded no prepared artifact for this agent node. */
+{
+    readonly nodeId: string;
+    readonly providerName: string;
+}
+/**
+ * The provider cannot use the recorded template. Callers that know why pass
+ * `reason`; the default message names no cause, because callers raise this for
+ * several different ones.
+ */
+ | {
+    readonly providerName: string;
+    readonly reason?: string;
+    readonly templateKey: string;
+};
 export declare class SandboxTemplateNotProvisionedError extends Error {
     readonly providerName: string;
+    /** The provider's template identifier, or the agent node id when the build recorded no artifact. */
     readonly templateKey: string;
-    constructor(input: {
-        readonly providerName: string;
-        readonly templateKey: string;
-    });
+    constructor(input: SandboxTemplateNotProvisionedInput);
     static is(error: unknown): error is SandboxTemplateNotProvisionedError;
 }
+export {};

package/dist/src/shared/sandbox-template-error.js

@@ -1 +1 @@
-var SandboxTemplateNotProvisionedError=class SandboxTemplateNotProvisionedError extends Error{providerName;templateKey;constructor(e){super(`Sandbox template "${e.templateKey}" is not provisioned for provider "${e.providerName}". Run \`eve build\` before serving traffic.`),this.name=`SandboxTemplateNotProvisionedError`,this.providerName=e.providerName,this.templateKey=e.templateKey}static is(e){return e instanceof SandboxTemplateNotProvisionedError||typeof e==`object`&&!!e&&Reflect.get(e,`name`)===`SandboxTemplateNotProvisionedError`&&typeof Reflect.get(e,`providerName`)==`string`&&typeof Reflect.get(e,`templateKey`)==`string`}};export{SandboxTemplateNotProvisionedError};
+var SandboxTemplateNotProvisionedError=class SandboxTemplateNotProvisionedError extends Error{providerName;templateKey;constructor(e){super(`nodeId`in e?`No prepared "${e.providerName}" sandbox environment is recorded for agent node "${e.nodeId}". eve prepares sandbox environments during \`eve build\` and never prepares them in production. Run \`eve build\` without \`--skip-sandbox-prewarm\` and deploy that output with this runtime.`:`Sandbox template "${e.templateKey}" for provider "${e.providerName}" is not available to this runtime. `+(e.reason===void 0?``:`${e.reason} `)+"The runtime only uses templates that `eve build` prepared and never recreates them. Run `eve build` again and deploy its output."),this.name=`SandboxTemplateNotProvisionedError`,this.providerName=e.providerName,this.templateKey=`nodeId`in e?e.nodeId:e.templateKey}static is(e){return e instanceof SandboxTemplateNotProvisionedError||typeof e==`object`&&!!e&&Reflect.get(e,`name`)===`SandboxTemplateNotProvisionedError`&&typeof Reflect.get(e,`providerName`)==`string`&&typeof Reflect.get(e,`templateKey`)==`string`}};export{SandboxTemplateNotProvisionedError};

package/dist/src/shared/sandbox-tool-session-error.d.ts

@@ -0,0 +1,4 @@
+/** Raised when a keyed tool session opens a sandbox on a provider that cannot keep it. */
+export declare class ToolSessionSandboxUnsupportedError extends Error {
+    constructor(providerName: string);
+}

package/dist/src/shared/sandbox-tool-session-error.js

@@ -0,0 +1 @@
+var ToolSessionSandboxUnsupportedError=class extends Error{constructor(e){super(`Sandbox provider "${e}" cannot keep a sandbox between invokeTool calls, so a call with a key cannot open one. Call without a key for a sandbox that lasts one call, or use Vercel Sandbox, just-bash, or a custom provider that sets \`toolSessions: true\`.`),this.name=`ToolSessionSandboxUnsupportedError`}};export{ToolSessionSandboxUnsupportedError};

package/dist/src/shared/session-history.d.ts

@@ -0,0 +1,22 @@
+/**
+ * One prior message passed as `history` to `send()` or `create()`.
+ *
+ * Entries become real user and assistant turns in the session's model history
+ * and are published in the `history.imported` stream event.
+ */
+export interface SessionHistoryMessage {
+    /** Optional app-owned id, echoed in `history.imported` so clients can join annotations. */
+    readonly id?: string;
+    readonly role: "user" | "assistant";
+    /** Plain text. Channels render speaker attribution into this text when needed. */
+    readonly text: string;
+}
+/** Thrown when `history` passed to a send does not satisfy the seeding contract. */
+export declare class InvalidSessionHistoryError extends Error {
+    readonly name = "InvalidSessionHistoryError";
+}
+/**
+ * Validates `history` at the send boundary and returns a normalized copy that
+ * carries only contract fields. Returns `undefined` when `history` is omitted.
+ */
+export declare function validateSessionHistory(history: unknown): readonly SessionHistoryMessage[] | undefined;

package/dist/src/shared/session-history.js

@@ -0,0 +1 @@
+import{isObject}from"#shared/guards.js";var InvalidSessionHistoryError=class extends Error{name=`InvalidSessionHistoryError`};function validateSessionHistory(e){if(e===void 0)return;if(!Array.isArray(e))throw new InvalidSessionHistoryError(`history must be an array of messages.`);let t=new Set;return e.map((e,n)=>{let r=`history[${n}]`;if(!isObject(e))throw new InvalidSessionHistoryError(`${r} must be an object.`);let{id:i,role:a,text:o}=e;if(a!==`user`&&a!==`assistant`)throw new InvalidSessionHistoryError(`${r}.role must be "user" or "assistant".`);if(typeof o!=`string`||o.trim().length===0)throw new InvalidSessionHistoryError(`${r}.text must be a non-empty string.`);let s={role:a,text:o};if(i===void 0)return s;if(typeof i!=`string`||i.length===0)throw new InvalidSessionHistoryError(`${r}.id must be a non-empty string.`);if(t.has(i))throw new InvalidSessionHistoryError(`${r}.id "${i}" is not unique.`);return t.add(i),{...s,id:i}})}export{InvalidSessionHistoryError,validateSessionHistory};

package/dist/src/shared/skill-package.js

@@ -1 +1 @@
-import{createHash}from"node:crypto";import{mkdir,writeFile}from"node:fs/promises";import{dirname,join}from"node:path";import{resolveSandboxSkillRoot,resolveSandboxSkillWritePath}from"#shared/skill-paths.js";import{mapWithConcurrency}from"#shared/map-with-concurrency.js";import{Buffer}from"node:buffer";function stripSkillFrontmatter(e){return e.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/,``)}function skillPackageRevision(e){let t=createHash(`sha256`);for(let n of e.files)t.update(`${n.relativePath}\0${n.content.byteLength}\0`).update(n.content);return t.digest(`hex`)}function normalizeSkillPackage(e){assertSafeSkillPackageName(e.name);let t=[{content:Buffer.from(e.markdown,`utf8`),relativePath:`SKILL.md`}];for(let[n,r]of Object.entries(e.files??{}))assertSafeSkillPackageFilePath(n),t.push({content:contentToBuffer(r),relativePath:n});return t.sort((e,t)=>comparePaths(e.relativePath,t.relativePath)),{deferred:e.deferred,description:e.description,files:t,license:e.license,markdown:e.markdown,metadata:e.metadata===void 0?void 0:{...e.metadata},name:e.name}}async function writeSkillPackageDirectory(e){for(let t of e.skill.files){let n=join(e.rootPath,`skills`,e.skill.name,t.relativePath);await mkdir(dirname(n),{recursive:!0}),await writeFile(n,t.content)}}async function writeSkillPackageToSandbox(e){await mapWithConcurrency(e.skill.files,16,async t=>{await e.sandbox.writeBinaryFile({content:t.content,path:await resolveSandboxSkillWritePath({name:e.skill.name,relativePath:t.relativePath,sandbox:e.sandbox})})})}async function removeSkillPackageFromSandbox(e){assertSafeSkillPackageName(e.name);let t=await resolveSandboxSkillRoot({sandbox:e.sandbox});await e.sandbox.removePath({force:!0,path:`${t}/${e.name}`,recursive:!0})}function assertSafeSkillPackageName(e){if(e.length===0||e.startsWith(`.`)||e.includes(`/`)||e.includes(`\\`)||e.includes(`..`)||!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(e)||/^[A-Za-z]:/.test(e))throw Error(`Expected skill name to be a non-empty shell-safe path segment starting with an alphanumeric character and containing only alphanumerics, ".", "_", or "-".`)}function assertSafeSkillPackageFilePath(e){if(e===`SKILL.md`)throw Error(`Skill package files must not include "SKILL.md"; eve generates it.`);if(e.length===0||e.startsWith(`/`)||e.includes(`\\`)||/^[A-Za-z]:/.test(e)||e.split(`/`).some(e=>e.length===0||e===`.`||e===`..`))throw Error(`Expected skill package file paths to be relative POSIX paths.`)}function contentToBuffer(e){return typeof e==`string`?Buffer.from(e,`utf8`):Buffer.from(e)}function comparePaths(e,t){return e<t?-1:+(e>t)}export{normalizeSkillPackage,removeSkillPackageFromSandbox,skillPackageRevision,stripSkillFrontmatter,writeSkillPackageDirectory,writeSkillPackageToSandbox};
+import{createHash}from"node:crypto";import{mkdir,writeFile}from"node:fs/promises";import{dirname,join}from"node:path";import{resolveSandboxSkillRoot,resolveSandboxSkillWritePath}from"#shared/skill-paths.js";import{Buffer}from"node:buffer";function stripSkillFrontmatter(e){return e.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/,``)}function skillPackageRevision(e){let t=createHash(`sha256`);for(let n of e.files)t.update(`${n.relativePath}\0${n.content.byteLength}\0`).update(n.content);return t.digest(`hex`)}function normalizeSkillPackage(e){assertSafeSkillPackageName(e.name);let t=[{content:Buffer.from(e.markdown,`utf8`),relativePath:`SKILL.md`}];for(let[n,r]of Object.entries(e.files??{}))assertSafeSkillPackageFilePath(n),t.push({content:contentToBuffer(r),relativePath:n});return t.sort((e,t)=>comparePaths(e.relativePath,t.relativePath)),{deferred:e.deferred,description:e.description,files:t,license:e.license,markdown:e.markdown,metadata:e.metadata===void 0?void 0:{...e.metadata},name:e.name}}async function writeSkillPackageDirectory(e){for(let t of e.skill.files){let n=join(e.rootPath,`skills`,e.skill.name,t.relativePath);await mkdir(dirname(n),{recursive:!0}),await writeFile(n,t.content)}}async function writeSkillPackageToSandbox(e){let t=await Promise.all(e.skill.files.map(async t=>({content:t.content,path:await resolveSandboxSkillWritePath({name:e.skill.name,relativePath:t.relativePath,sandbox:e.sandbox})})));await e.sandbox.writeFiles({files:t})}async function removeSkillPackageFromSandbox(e){assertSafeSkillPackageName(e.name);let t=await resolveSandboxSkillRoot({sandbox:e.sandbox});await e.sandbox.removePath({force:!0,path:`${t}/${e.name}`,recursive:!0})}function assertSafeSkillPackageName(e){if(e.length===0||e.startsWith(`.`)||e.includes(`/`)||e.includes(`\\`)||e.includes(`..`)||!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(e)||/^[A-Za-z]:/.test(e))throw Error(`Expected skill name to be a non-empty shell-safe path segment starting with an alphanumeric character and containing only alphanumerics, ".", "_", or "-".`)}function assertSafeSkillPackageFilePath(e){if(e===`SKILL.md`)throw Error(`Skill package files must not include "SKILL.md"; eve generates it.`);if(e.length===0||e.startsWith(`/`)||e.includes(`\\`)||/^[A-Za-z]:/.test(e)||e.split(`/`).some(e=>e.length===0||e===`.`||e===`..`))throw Error(`Expected skill package file paths to be relative POSIX paths.`)}function contentToBuffer(e){return typeof e==`string`?Buffer.from(e,`utf8`):Buffer.from(e)}function comparePaths(e,t){return e<t?-1:+(e>t)}export{normalizeSkillPackage,removeSkillPackageFromSandbox,skillPackageRevision,stripSkillFrontmatter,writeSkillPackageDirectory,writeSkillPackageToSandbox};