experimental-ash 0.26.0 → 0.28.0

package/dist/src/execution/sandbox/bindings/vercel.js

@@ -1,363 +1 @@
-import { SandboxTemplateNotProvisionedError } from "#public/definitions/sandbox-backend.js";
-import { WORKSPACE_ROOT } from "#runtime/workspace/types.js";
-import { buildSandboxSession } from "#execution/sandbox/session.js";
-import { streamToBuffer } from "#execution/sandbox/stream-utils.js";
-/**
- * Creates the Vercel-backed sandbox backend.
- *
- * Any author-supplied `createOptions` are forwarded to the Vercel SDK
- * `Sandbox.create(...)` for every fresh sandbox the framework creates
- * (template at prewarm time, session at first-time session-create). On
- * resume (`Sandbox.get`) no create happens, so they are not re-applied.
- */
-export function createVercelSandboxBackend(input = {}) {
-    const loadSandboxModule = input.loadSandboxModule ?? (async () => await import("#compiled/@vercel/sandbox/index.js"));
-    const createOptions = {
-        timeout: DEFAULT_SANDBOX_TIMEOUT_MS,
-        ...input.createOptions,
-    };
-    const prewarmedTemplates = new Map();
-    return {
-        name: "vercel",
-        async create(createInput) {
-            // Resolve tags up-front so tag-count validation fails fast before
-            // we go to the network for the template snapshot.
-            const tags = resolveVercelSandboxTags(createOptions.tags, createInput.tags);
-            let template;
-            try {
-                template = await readTemplate({
-                    loadSandboxModule,
-                    prewarmedTemplates,
-                    templateKey: createInput.templateKey,
-                });
-            }
-            catch (error) {
-                if (SandboxTemplateNotProvisionedError.is(error)) {
-                    throw error;
-                }
-                throw new Error(`Failed to read sandbox template "${createInput.templateKey}": ${errorMessage(error)}`, { cause: error });
-            }
-            let sandbox;
-            try {
-                sandbox = await ensureSession({
-                    createOptions,
-                    existingMetadata: createInput.existingMetadata,
-                    sandboxModule: await loadSandboxModule(),
-                    sessionKey: createInput.sessionKey,
-                    snapshotId: template.snapshotId,
-                    tags,
-                });
-            }
-            catch (error) {
-                throw new Error(`Failed to create sandbox session "${createInput.sessionKey}": ${errorMessage(error)}`, { cause: error });
-            }
-            // No bootstrap on session create — the prewarmed snapshot already
-            // includes /workspace and the framework's ripgrep install.
-            return createHandle(sandbox, createInput.sessionKey);
-        },
-        async prewarm(prewarmInput) {
-            let template;
-            try {
-                template = await ensureTemplate({
-                    bootstrap: prewarmInput.bootstrap,
-                    createOptions,
-                    loadSandboxModule,
-                    seedFiles: prewarmInput.seedFiles,
-                    templateKey: prewarmInput.templateKey,
-                });
-            }
-            catch (error) {
-                throw new Error(`Failed to prewarm Vercel sandbox template "${prewarmInput.templateKey}": ${errorMessage(error)}. Run \`vercel login\` and \`vercel link\` so the SDK can authenticate, or set VERCEL_TOKEN.`, { cause: error });
-            }
-            prewarmedTemplates.set(prewarmInput.templateKey, template);
-        },
-    };
-}
-async function readTemplate(input) {
-    const prewarmed = input.prewarmedTemplates.get(input.templateKey);
-    if (prewarmed !== undefined) {
-        return prewarmed;
-    }
-    const sandboxModule = await input.loadSandboxModule();
-    const sandbox = await getNamedSandbox(sandboxModule, input.templateKey);
-    if (sandbox === null || typeof sandbox.currentSnapshotId !== "string") {
-        throw new SandboxTemplateNotProvisionedError({
-            backendName: "vercel",
-            templateKey: input.templateKey,
-        });
-    }
-    return {
-        sandboxName: sandbox.name,
-        snapshotId: sandbox.currentSnapshotId,
-        templateKey: input.templateKey,
-    };
-}
-/**
- * Creates or refreshes one named Vercel sandbox template and returns the
- * resulting snapshot metadata. Internal — exposed only to the prewarm
- * pipeline through the backend's `prewarm` method.
- */
-async function ensureTemplate(input) {
-    const sandboxModule = await input.loadSandboxModule();
-    let sandbox = await getNamedSandbox(sandboxModule, input.templateKey);
-    const tags = resolveVercelSandboxTags(input.createOptions.tags, input.tags);
-    if (sandbox === null) {
-        const createParams = {
-            ...input.createOptions,
-            name: input.templateKey,
-            persistent: false,
-        };
-        if (tags !== undefined) {
-            createParams.tags = tags;
-        }
-        sandbox = await sandboxModule.Sandbox.create(createParams);
-    }
-    else {
-        await ensureVercelSandboxTags(sandbox, tags);
-    }
-    /*
-     * A non-empty `currentSnapshotId` normally means "this template was
-     * prewarmed in a previous run — reuse it." But with an author-supplied
-     * `source: snapshot`, the SDK pre-populates `currentSnapshotId` with
-     * the *author's* snapshotId both on a fresh create and on every
-     * subsequent `getNamedSandbox` reuse until we run our own snapshot.
-     * So we ignore that exact value: it's the author's base layer, not a
-     * framework snapshot, and we still owe `ensureSandboxWorkingDirectory`,
-     * bootstrap, seed file writes, and `sandbox.snapshot()` on top.
-     */
-    const authorSnapshotId = extractAuthorSnapshotId(input.createOptions);
-    const hasFrameworkSnapshot = typeof sandbox.currentSnapshotId === "string" &&
-        sandbox.currentSnapshotId.length > 0 &&
-        sandbox.currentSnapshotId !== authorSnapshotId;
-    if (hasFrameworkSnapshot) {
-        return {
-            sandboxName: sandbox.name,
-            snapshotId: sandbox.currentSnapshotId,
-            templateKey: input.templateKey,
-        };
-    }
-    await ensureSandboxWorkingDirectory(sandbox, input.createOptions);
-    const templateSession = buildSandboxSession(createVercelInternalSandboxSession(sandbox, input.templateKey));
-    if (input.bootstrap !== undefined) {
-        await input.bootstrap({
-            use: async (options) => {
-                if (options !== undefined) {
-                    await sandbox.update(options);
-                }
-                return templateSession;
-            },
-        });
-    }
-    for (const file of input.seedFiles) {
-        if (typeof file.content === "string") {
-            await templateSession.writeTextFile({ content: file.content, path: file.path });
-        }
-        else {
-            await templateSession.writeBinaryFile({ content: file.content, path: file.path });
-        }
-    }
-    const snapshot = await sandbox.snapshot();
-    return {
-        sandboxName: sandbox.name,
-        snapshotId: snapshot.snapshotId,
-        templateKey: input.templateKey,
-    };
-}
-async function ensureSession(input) {
-    const sandboxName = getVercelSandboxName(input.existingMetadata) ?? input.sessionKey;
-    const existing = await getNamedSandbox(input.sandboxModule, sandboxName);
-    if (existing !== null) {
-        await ensureVercelSandboxTags(existing, input.tags);
-        return existing;
-    }
-    /*
-     * Strip both `source` and `runtime` from author-supplied create
-     * options for the session path. The framework owns the session
-     * source — sessions always derive from the prewarmed template's
-     * snapshot, never the author's external source. And the Vercel SDK
-     * rejects `runtime` when `source` is a snapshot because the runtime
-     * is already baked into the snapshot's filesystem. Template prewarm
-     * still honors both fields.
-     */
-    const { runtime: _runtime, source: _source, ...sessionCreateOptions } = input.createOptions;
-    const createParams = {
-        ...sessionCreateOptions,
-        name: sandboxName,
-        persistent: true,
-        source: { snapshotId: input.snapshotId, type: "snapshot" },
-    };
-    if (input.tags !== undefined) {
-        createParams.tags = input.tags;
-    }
-    return await input.sandboxModule.Sandbox.create(createParams);
-}
-function createHandle(sandbox, sessionKey) {
-    return {
-        session: buildSandboxSession(createVercelInternalSandboxSession(sandbox, sessionKey)),
-        useSessionFn: async (options) => {
-            if (options !== undefined) {
-                await sandbox.update(options);
-            }
-            return buildSandboxSession(createVercelInternalSandboxSession(sandbox, sessionKey));
-        },
-        async captureState() {
-            return {
-                backendName: "vercel",
-                metadata: { sandboxName: sandbox.name },
-                sessionKey,
-            };
-        },
-        async dispose() { },
-    };
-}
-function createVercelInternalSandboxSession(sandbox, id) {
-    return {
-        id,
-        resolvePath: resolveVercelSandboxPath,
-        async runCommand(options) {
-            const result = await sandbox.runCommand({
-                args: ["-lc", options.command],
-                cmd: "bash",
-                cwd: options.workingDirectory ?? WORKSPACE_ROOT,
-                signal: options.abortSignal,
-            });
-            const [stdout, stderr] = await Promise.all([result.stdout(), result.stderr()]);
-            return { exitCode: result.exitCode, stderr, stdout };
-        },
-        async readFile(options) {
-            const stream = await sandbox.readFile({ path: options.path });
-            return stream ?? null;
-        },
-        async writeFile(options) {
-            const bytes = await streamToBuffer(options.content);
-            await sandbox.writeFiles([{ content: bytes, path: options.path }]);
-        },
-    };
-}
-function resolveVercelSandboxPath(path) {
-    if (path.startsWith("/")) {
-        return path;
-    }
-    return `${WORKSPACE_ROOT}/${path}`;
-}
-/**
- * Prepares a fresh Vercel sandbox for use by the framework.
- */
-async function ensureSandboxWorkingDirectory(sandbox, createOptions) {
-    await runSandboxBootstrapStep(sandbox, {
-        failureMessage: "Failed to initialize Vercel sandbox workspace.",
-        script: `mkdir -p ${WORKSPACE_ROOT} && chown ${SANDBOX_USER}:${SANDBOX_USER} ${WORKSPACE_ROOT}`,
-    });
-    if (createOptions.networkPolicy === "deny-all") {
-        return;
-    }
-    await runSandboxBootstrapStep(sandbox, {
-        failureMessage: "Failed to install ripgrep in Vercel sandbox.",
-        script: "command -v rg >/dev/null 2>&1 || { dnf install -y spal-release && dnf install -y ripgrep; }",
-    });
-}
-async function runSandboxBootstrapStep(sandbox, input) {
-    const result = await sandbox.runCommand({
-        args: ["-lc", input.script],
-        cmd: "bash",
-        sudo: true,
-    });
-    if (result.exitCode !== 0) {
-        const stderr = await result.stderr();
-        throw new Error(`${input.failureMessage} ${stderr}`.trim());
-    }
-}
-/**
- * The non-root user that Vercel Sandbox executes user code as. Documented
- * in the `@vercel/sandbox` README under "System". Used to hand ownership
- * of the framework-managed workspace directory back to the user after
- * creating it with `sudo`.
- */
-const SANDBOX_USER = "vercel-sandbox";
-async function getNamedSandbox(sandboxModule, sandboxName) {
-    try {
-        return await sandboxModule.Sandbox.get({ name: sandboxName });
-    }
-    catch (error) {
-        if (isSandboxMissingError(error)) {
-            return null;
-        }
-        throw new Error(`Failed to look up Vercel sandbox "${sandboxName}": ${errorMessage(error)}`, {
-            cause: error,
-        });
-    }
-}
-function isSandboxMissingError(error) {
-    if (!(error instanceof Error)) {
-        return false;
-    }
-    const status = error.response?.status ??
-        error.cause?.response?.status;
-    return status === 404;
-}
-/**
- * Pulls the snapshotId out of an author-supplied `source: { type:
- * "snapshot", ... }`. Returns undefined for git/tarball sources or when
- * no source was supplied — those don't seed `currentSnapshotId` with a
- * pre-existing value the way snapshot sources do.
- */
-function extractAuthorSnapshotId(createOptions) {
-    const source = createOptions.source;
-    if (source?.type === "snapshot" && typeof source.snapshotId === "string") {
-        return source.snapshotId;
-    }
-    return undefined;
-}
-function getVercelSandboxName(metadata) {
-    const sandboxName = metadata?.sandboxName;
-    return typeof sandboxName === "string" ? sandboxName : undefined;
-}
-function resolveVercelSandboxTags(userTags, ashTags) {
-    const tags = {};
-    if (userTags !== undefined) {
-        for (const [key, value] of Object.entries(userTags)) {
-            tags[key] = value;
-        }
-    }
-    if (ashTags !== undefined) {
-        for (const [key, value] of Object.entries(ashTags)) {
-            tags[key] = value;
-        }
-    }
-    const count = Object.keys(tags).length;
-    if (count === 0) {
-        return undefined;
-    }
-    if (count > VERCEL_SANDBOX_TAG_LIMIT) {
-        throw new Error(`Vercel Sandbox supports at most ${VERCEL_SANDBOX_TAG_LIMIT} tags. ` +
-            'Ash reserves "agent", "channel", and "sessionId"; remove or consolidate custom tags passed to vercelBackend().');
-    }
-    return tags;
-}
-async function ensureVercelSandboxTags(sandbox, tags) {
-    if (tags === undefined || areVercelSandboxTagsEqual(sandbox.tags, tags)) {
-        return;
-    }
-    await sandbox.update({ tags });
-}
-function areVercelSandboxTagsEqual(current, next) {
-    const currentTags = current ?? {};
-    const currentEntries = Object.entries(currentTags);
-    const nextEntries = Object.entries(next);
-    if (currentEntries.length !== nextEntries.length) {
-        return false;
-    }
-    return nextEntries.every(([key, value]) => currentTags[key] === value);
-}
-function errorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return String(error);
-}
-/**
- * 30 minutes. The `@vercel/sandbox` SDK defaults to 5 minutes which is
- * too short for multi-step workflows — the VM expires between steps.
- */
-const DEFAULT_SANDBOX_TIMEOUT_MS = 30 * 60 * 1_000;
-const VERCEL_SANDBOX_TAG_LIMIT = 5;
+import{SandboxTemplateNotProvisionedError}from"#public/definitions/sandbox-backend.js";import{WORKSPACE_ROOT}from"#runtime/workspace/types.js";import{buildSandboxSession}from"#execution/sandbox/session.js";import{streamToBuffer}from"#execution/sandbox/stream-utils.js";function createVercelSandboxBackend(t={}){let n=t.loadSandboxModule??(async()=>await import(`#compiled/@vercel/sandbox/index.js`)),r={timeout:DEFAULT_SANDBOX_TIMEOUT_MS,...t.createOptions},i=new Map;return{name:`vercel`,async create(t){let a=resolveVercelSandboxTags(r.tags,t.tags),o;try{o=await readTemplate({loadSandboxModule:n,prewarmedTemplates:i,templateKey:t.templateKey})}catch(n){throw SandboxTemplateNotProvisionedError.is(n)?n:Error(`Failed to read sandbox template "${t.templateKey}": ${errorMessage(n)}`,{cause:n})}let s;try{s=await ensureSession({createOptions:r,existingMetadata:t.existingMetadata,sandboxModule:await n(),sessionKey:t.sessionKey,snapshotId:o.snapshotId,tags:a})}catch(e){throw Error(`Failed to create sandbox session "${t.sessionKey}": ${errorMessage(e)}`,{cause:e})}return createHandle(s,t.sessionKey)},async prewarm(e){let t;try{t=await ensureTemplate({bootstrap:e.bootstrap,createOptions:r,loadSandboxModule:n,seedFiles:e.seedFiles,templateKey:e.templateKey})}catch(t){throw Error(`Failed to prewarm Vercel sandbox template "${e.templateKey}": ${errorMessage(t)}. Run \`vercel login\` and \`vercel link\` so the SDK can authenticate, or set VERCEL_TOKEN.`,{cause:t})}i.set(e.templateKey,t)}}}async function readTemplate(t){let n=t.prewarmedTemplates.get(t.templateKey);if(n!==void 0)return n;let r=await getNamedSandbox(await t.loadSandboxModule(),t.templateKey);if(r===null||typeof r.currentSnapshotId!=`string`)throw new SandboxTemplateNotProvisionedError({backendName:`vercel`,templateKey:t.templateKey});return{sandboxName:r.name,snapshotId:r.currentSnapshotId,templateKey:t.templateKey}}async function ensureTemplate(e){let t=await e.loadSandboxModule(),r=await getNamedSandbox(t,e.templateKey),i=resolveVercelSandboxTags(e.createOptions.tags,e.tags);if(r===null){let n={...e.createOptions,name:e.templateKey,persistent:!1};i!==void 0&&(n.tags=i),r=await t.Sandbox.create(n)}else await ensureVercelSandboxTags(r,i);let a=extractAuthorSnapshotId(e.createOptions);if(typeof r.currentSnapshotId==`string`&&r.currentSnapshotId.length>0&&r.currentSnapshotId!==a)return{sandboxName:r.name,snapshotId:r.currentSnapshotId,templateKey:e.templateKey};await ensureSandboxWorkingDirectory(r,e.createOptions);let o=buildSandboxSession(createVercelInternalSandboxSession(r,e.templateKey));e.bootstrap!==void 0&&await e.bootstrap({use:async e=>(e!==void 0&&await r.update(e),o)});for(let t of e.seedFiles)typeof t.content==`string`?await o.writeTextFile({content:t.content,path:t.path}):await o.writeBinaryFile({content:t.content,path:t.path});let s=await r.snapshot();return{sandboxName:r.name,snapshotId:s.snapshotId,templateKey:e.templateKey}}async function ensureSession(e){let t=getVercelSandboxName(e.existingMetadata)??e.sessionKey,n=await getNamedSandbox(e.sandboxModule,t);if(n!==null)return await ensureVercelSandboxTags(n,e.tags),n;let{runtime:r,source:i,...a}=e.createOptions,o={...a,name:t,persistent:!0,source:{snapshotId:e.snapshotId,type:`snapshot`}};return e.tags!==void 0&&(o.tags=e.tags),await e.sandboxModule.Sandbox.create(o)}function createHandle(e,t){return{session:buildSandboxSession(createVercelInternalSandboxSession(e,t)),useSessionFn:async r=>(r!==void 0&&await e.update(r),buildSandboxSession(createVercelInternalSandboxSession(e,t))),async captureState(){return{backendName:`vercel`,metadata:{sandboxName:e.name},sessionKey:t}},async dispose(){}}}function createVercelInternalSandboxSession(e,n){return{id:n,resolvePath:resolveVercelSandboxPath,async runCommand(n){let r=await e.runCommand({args:[`-lc`,n.command],cmd:`bash`,cwd:n.workingDirectory??WORKSPACE_ROOT,signal:n.abortSignal}),[i,a]=await Promise.all([r.stdout(),r.stderr()]);return{exitCode:r.exitCode,stderr:a,stdout:i}},async readFile(t){return await e.readFile({path:t.path})??null},async writeFile(t){let n=await streamToBuffer(t.content);await e.writeFiles([{content:n,path:t.path}])}}}function resolveVercelSandboxPath(e){return e.startsWith(`/`)?e:`${WORKSPACE_ROOT}/${e}`}async function ensureSandboxWorkingDirectory(e,n){await runSandboxBootstrapStep(e,{failureMessage:`Failed to initialize Vercel sandbox workspace.`,script:`mkdir -p ${WORKSPACE_ROOT} && chown ${SANDBOX_USER}:${SANDBOX_USER} ${WORKSPACE_ROOT}`}),n.networkPolicy!==`deny-all`&&await runSandboxBootstrapStep(e,{failureMessage:`Failed to install ripgrep in Vercel sandbox.`,script:`command -v rg >/dev/null 2>&1 || { dnf install -y spal-release && dnf install -y ripgrep; }`})}async function runSandboxBootstrapStep(e,t){let n=await e.runCommand({args:[`-lc`,t.script],cmd:`bash`,sudo:!0});if(n.exitCode!==0){let e=await n.stderr();throw Error(`${t.failureMessage} ${e}`.trim())}}var SANDBOX_USER=`vercel-sandbox`;async function getNamedSandbox(e,t){try{return await e.Sandbox.get({name:t})}catch(e){if(isSandboxMissingError(e))return null;throw Error(`Failed to look up Vercel sandbox "${t}": ${errorMessage(e)}`,{cause:e})}}function isSandboxMissingError(e){return e instanceof Error?(e.response?.status??e.cause?.response?.status)===404:!1}function extractAuthorSnapshotId(e){let t=e.source;if(t?.type===`snapshot`&&typeof t.snapshotId==`string`)return t.snapshotId}function getVercelSandboxName(e){let t=e?.sandboxName;return typeof t==`string`?t:void 0}function resolveVercelSandboxTags(e,t){let n={};if(e!==void 0)for(let[t,r]of Object.entries(e))n[t]=r;if(t!==void 0)for(let[e,r]of Object.entries(t))n[e]=r;let r=Object.keys(n).length;if(r!==0){if(r>VERCEL_SANDBOX_TAG_LIMIT)throw Error(`Vercel Sandbox supports at most ${VERCEL_SANDBOX_TAG_LIMIT} tags. Ash reserves "agent", "channel", and "sessionId"; remove or consolidate custom tags passed to vercelBackend().`);return n}}async function ensureVercelSandboxTags(e,t){t===void 0||areVercelSandboxTagsEqual(e.tags,t)||await e.update({tags:t})}function areVercelSandboxTagsEqual(e,t){let n=e??{},r=Object.entries(n),i=Object.entries(t);return r.length===i.length?i.every(([e,t])=>n[e]===t):!1}function errorMessage(e){return e instanceof Error?e.message:String(e)}var DEFAULT_SANDBOX_TIMEOUT_MS=1800*1e3,VERCEL_SANDBOX_TAG_LIMIT=5;export{createVercelSandboxBackend};

package/dist/src/execution/sandbox/ensure.js

@@ -1,91 +1 @@
-import { getRuntimeCompiledArtifactsAppRoot, } from "#runtime/compiled-artifacts-source.js";
-import { createRuntimeSandboxKeys } from "#runtime/sandbox/keys.js";
-/**
- * Creates or reattaches the live sandbox from the compiled agent bundle's
- * registry and persisted session state, returning a {@link SandboxAccess}
- * suitable for the runtime context.
- *
- * Every agent has exactly one sandbox. The sandbox carries its own
- * `SandboxBackend` value (resolved from the authored module or
- * substituted with `defaultBackend()` when omitted), and the runtime
- * simply calls `backend.create(...)`.
- */
-export async function ensureSandboxAccess(input) {
-    let initialized = input.state?.initialized ?? false;
-    let persistedSession = input.state?.session ?? null;
-    const appRoot = getRuntimeCompiledArtifactsAppRoot(input.compiledArtifactsSource) ?? process.cwd();
-    const registered = input.registry.sandbox;
-    let handlePromise;
-    function getHandle() {
-        if (handlePromise !== undefined) {
-            return handlePromise;
-        }
-        handlePromise = createHandle().catch((error) => {
-            handlePromise = undefined;
-            throw error;
-        });
-        return handlePromise;
-    }
-    async function createHandle() {
-        if (registered === null) {
-            return null;
-        }
-        const definition = registered.definition;
-        const backend = definition.backend;
-        const keys = await createRuntimeSandboxKeys({
-            backendName: backend.name,
-            compiledArtifactsSource: input.compiledArtifactsSource,
-            nodeId: input.nodeId,
-            sessionId: input.sessionId,
-            sourceId: definition.sourceId,
-        });
-        const handle = await backend.create({
-            existingMetadata: persistedSession?.backendName === backend.name &&
-                persistedSession.sessionKey === keys.sessionKey
-                ? persistedSession.metadata
-                : undefined,
-            runtimeContext: { appRoot },
-            sessionKey: keys.sessionKey,
-            tags: input.tags,
-            templateKey: keys.templateKey,
-        });
-        if (!initialized) {
-            await runOnSession(async () => {
-                await definition.onSession?.({ use: handle.useSessionFn });
-            });
-            initialized = true;
-        }
-        return handle;
-    }
-    async function runOnSession(callback) {
-        if (input.runOnSession !== undefined) {
-            await input.runOnSession(callback);
-            return;
-        }
-        await callback();
-    }
-    return {
-        async captureState() {
-            if (handlePromise !== undefined) {
-                const handle = await handlePromise;
-                if (handle !== null) {
-                    persistedSession = await handle.captureState();
-                }
-            }
-            return {
-                initialized,
-                session: persistedSession,
-            };
-        },
-        async dispose() {
-            if (handlePromise !== undefined) {
-                const handle = await handlePromise;
-                await handle?.dispose();
-            }
-        },
-        async get() {
-            const handle = await getHandle();
-            return handle?.session ?? null;
-        },
-    };
-}
+import{getRuntimeCompiledArtifactsAppRoot}from"#runtime/compiled-artifacts-source.js";import{createRuntimeSandboxKeys}from"#runtime/sandbox/keys.js";async function ensureSandboxAccess(t){let n=t.state?.initialized??!1,r=t.state?.session??null,i=getRuntimeCompiledArtifactsAppRoot(t.compiledArtifactsSource)??process.cwd(),a=t.registry.sandbox,o;function getHandle(){return o===void 0&&(o=createHandle().catch(e=>{throw o=void 0,e})),o}async function createHandle(){if(a===null)return null;let e=a.definition,o=e.backend,s=await createRuntimeSandboxKeys({backendName:o.name,compiledArtifactsSource:t.compiledArtifactsSource,nodeId:t.nodeId,sessionId:t.sessionId,sourceId:e.sourceId}),c=await o.create({existingMetadata:r?.backendName===o.name&&r.sessionKey===s.sessionKey?r.metadata:void 0,runtimeContext:{appRoot:i},sessionKey:s.sessionKey,tags:t.tags,templateKey:s.templateKey});return n||=(await runOnSession(async()=>{await e.onSession?.({use:c.useSessionFn})}),!0),c}async function runOnSession(e){if(t.runOnSession!==void 0){await t.runOnSession(e);return}await e()}return{async captureState(){if(o!==void 0){let e=await o;e!==null&&(r=await e.captureState())}return{initialized:n,session:r}},async dispose(){o!==void 0&&await(await o)?.dispose()},async get(){return(await getHandle())?.session??null}}}export{ensureSandboxAccess};

package/dist/src/execution/sandbox/glob-tool.js

@@ -1,146 +1,3 @@
-import { normalizeModelPath } from "#runtime/framework-tools/file-state.js";
-import { requireSandboxSession, validateAbsoluteFilePath, } from "#execution/sandbox/require-sandbox.js";
-import { ripgrepIsAvailable } from "#execution/sandbox/ripgrep-probe.js";
-import { shellQuote } from "#execution/sandbox/shell-quote.js";
-import { MAX_OUTPUT_BYTES } from "#execution/sandbox/truncate-output.js";
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const DEFAULT_GLOB_LIMIT = 100;
-const MAX_GLOB_LIMIT = 1000;
-const DEFAULT_PATH = "/workspace";
-// ---------------------------------------------------------------------------
-// Executor
-// ---------------------------------------------------------------------------
-/**
- * Searches for files matching a glob pattern inside the sandbox.
- */
-export async function executeGlobOnSandbox(args) {
-    const effectivePath = args.path ?? DEFAULT_PATH;
-    validateAbsoluteFilePath(effectivePath);
-    const normalizedPath = normalizeModelPath(effectivePath);
-    const effectiveLimit = Math.min(Math.max(1, args.limit ?? DEFAULT_GLOB_LIMIT), MAX_GLOB_LIMIT);
-    const sandbox = await requireSandboxSession();
-    const command = (await ripgrepIsAvailable(sandbox))
-        ? buildRipgrepCommand({ normalizedPath, pattern: args.pattern })
-        : buildPosixFindCommand({ normalizedPath, pattern: args.pattern });
-    const result = await sandbox.runCommand({ command });
-    // Both ripgrep and POSIX find use conventional exit code semantics:
-    //   0 — operation succeeded (results may be empty for find)
-    //   1 — ripgrep-specific: no matches found (legitimate empty result)
-    //  >1 — error occurred
-    // Any unexpected exit code (e.g. 127 from bash when the tool is
-    // missing) indicates a real failure. Surface these as structured
-    // errors rather than silently pretending the search returned zero
-    // files.
-    if (result.exitCode !== 0 && result.exitCode !== 1) {
-        throw buildGlobExecutionError(command, result.exitCode, result.stderr);
-    }
-    // Parse stdout into file paths.
-    const rawLines = result.stdout.split("\n").filter((line) => line.length > 0);
-    // Detect truncation: if we got more lines than the limit, the tool had more results.
-    const truncatedByCount = rawLines.length > effectiveLimit;
-    const boundedLines = truncatedByCount ? rawLines.slice(0, effectiveLimit) : rawLines;
-    // Normalize each path and enforce byte cap.
-    const paths = [];
-    let outputBytes = 0;
-    let truncatedByBytes = false;
-    for (const line of boundedLines) {
-        const normalized = normalizeModelPath(line);
-        const lineBytes = Buffer.byteLength(normalized, "utf8") + 1;
-        if (outputBytes + lineBytes > MAX_OUTPUT_BYTES && paths.length > 0) {
-            truncatedByBytes = true;
-            break;
-        }
-        paths.push(normalized);
-        outputBytes += lineBytes;
-    }
-    if (paths.length === 0) {
-        return {
-            content: "No files found",
-            count: 0,
-            path: normalizedPath,
-            truncated: false,
-        };
-    }
-    const truncated = truncatedByCount || truncatedByBytes;
-    const lines = [...paths];
-    if (truncated) {
-        lines.push("");
-        lines.push(`(Results truncated: showing first ${paths.length} results out of more. ` +
-            "Use a more specific path or pattern to narrow results.)");
-    }
-    return {
-        content: lines.join("\n"),
-        count: paths.length,
-        path: normalizedPath,
-        truncated,
-    };
-}
-/**
- * Builds the ripgrep form of the glob command. Preferred whenever
- * `rg` is on PATH.
- *
- * Truncation is enforced in JavaScript rather than via a shell `| head`
- * pipe: piping would mask ripgrep's exit code (the pipeline would adopt
- * `head`'s exit code, which is typically 0), making a missing `rg`
- * binary or a real IO failure indistinguishable from a successful
- * search with no results.
- */
-function buildRipgrepCommand(input) {
-    return [
-        "rg --files --hidden",
-        "--glob '!.git/*'",
-        `--glob ${shellQuote(input.pattern)}`,
-        `-- ${shellQuote(input.normalizedPath)}`,
-    ].join(" ");
-}
-// POSIX fallback used when ripgrep is unavailable. Globstars collapse
-// to GNU find's slash-spanning `*`; brace expansion is not supported.
-function buildPosixFindCommand(input) {
-    const translatedPattern = translateGlobToFindPattern(input.pattern);
-    // If the translated pattern has no slash after translation, it is
-    // a basename-only pattern — match against `-name` which is faster
-    // and semantically cleaner than `-path`. Otherwise match against
-    // the full path with `-path` (note: `-path` requires the full path
-    // prefix to match, so we include `*/` to anchor anywhere in the
-    // tree).
-    const isBasenameOnly = !translatedPattern.includes("/");
-    const matchExpression = isBasenameOnly
-        ? `-name ${shellQuote(translatedPattern)}`
-        : `-path ${shellQuote(`*/${translatedPattern}`)}`;
-    return [
-        `find ${shellQuote(input.normalizedPath)}`,
-        "-type f",
-        "-not -path '*/.git/*'",
-        matchExpression,
-    ].join(" ");
-}
-// Translates a ripgrep-style glob pattern to a POSIX `find`-compatible
-// pattern.
-//
-//   - A globstar (two `*` in a row) matches any number of directory
-//     segments. POSIX `find`'s single `*` also crosses `/` boundaries
-//     (unlike bash globs), so a globstar collapses to one `*`.
-//   - A leading globstar-slash prefix is equivalent to "at any
-//     depth". When the rest of the pattern has no directory
-//     component we return just the basename, letting the caller use
-//     `-name` for efficiency.
-function translateGlobToFindPattern(pattern) {
-    // Collapse `**` to `*` since find's `*` already crosses `/`.
-    let translated = pattern.replaceAll("**", "*");
-    // Strip a leading `*/` so a globstar-prefixed pattern like
-    // `**/*.ts` becomes `*.ts` (basename match).
-    while (translated.startsWith("*/")) {
-        translated = translated.slice(2);
-    }
-    return translated;
-}
-// ---------------------------------------------------------------------------
-// Error helpers
-// ---------------------------------------------------------------------------
-function buildGlobExecutionError(command, exitCode, stderr) {
-    const trimmed = stderr.trim();
-    const detail = trimmed.length > 0 ? trimmed : "no stderr output";
-    return new Error(`glob failed (exit ${exitCode}): ${detail}\nCommand: ${command}`);
-}
+import{requireSandboxSession,validateAbsoluteFilePath}from"#execution/sandbox/require-sandbox.js";import{MAX_OUTPUT_BYTES}from"#execution/sandbox/truncate-output.js";import{shellQuote}from"#execution/sandbox/shell-quote.js";import{normalizeModelPath}from"#runtime/framework-tools/file-state.js";import{ripgrepIsAvailable}from"#execution/sandbox/ripgrep-probe.js";var DEFAULT_GLOB_LIMIT=100,MAX_GLOB_LIMIT=1e3,DEFAULT_PATH=`/workspace`;async function executeGlobOnSandbox(r){let a=r.path??DEFAULT_PATH;validateAbsoluteFilePath(a);let o=normalizeModelPath(a),s=Math.min(Math.max(1,r.limit??DEFAULT_GLOB_LIMIT),MAX_GLOB_LIMIT),c=await requireSandboxSession(),l=await ripgrepIsAvailable(c)?buildRipgrepCommand({normalizedPath:o,pattern:r.pattern}):buildPosixFindCommand({normalizedPath:o,pattern:r.pattern}),u=await c.runCommand({command:l});if(u.exitCode!==0&&u.exitCode!==1)throw buildGlobExecutionError(l,u.exitCode,u.stderr);let d=u.stdout.split(`
+`).filter(e=>e.length>0),f=d.length>s,p=f?d.slice(0,s):d,m=[],h=0,g=!1;for(let e of p){let t=normalizeModelPath(e),r=Buffer.byteLength(t,`utf8`)+1;if(h+r>MAX_OUTPUT_BYTES&&m.length>0){g=!0;break}m.push(t),h+=r}if(m.length===0)return{content:`No files found`,count:0,path:o,truncated:!1};let _=f||g,v=[...m];return _&&(v.push(``),v.push(`(Results truncated: showing first ${m.length} results out of more. Use a more specific path or pattern to narrow results.)`)),{content:v.join(`
+`),count:m.length,path:o,truncated:_}}function buildRipgrepCommand(e){return[`rg --files --hidden`,`--glob '!.git/*'`,`--glob ${shellQuote(e.pattern)}`,`-- ${shellQuote(e.normalizedPath)}`].join(` `)}function buildPosixFindCommand(e){let t=translateGlobToFindPattern(e.pattern),n=t.includes(`/`)?`-path ${shellQuote(`*/${t}`)}`:`-name ${shellQuote(t)}`;return[`find ${shellQuote(e.normalizedPath)}`,`-type f`,`-not -path '*/.git/*'`,n].join(` `)}function translateGlobToFindPattern(e){let t=e.replaceAll(`**`,`*`);for(;t.startsWith(`*/`);)t=t.slice(2);return t}function buildGlobExecutionError(e,t,n){let r=n.trim(),i=r.length>0?r:`no stderr output`;return Error(`glob failed (exit ${t}): ${i}\nCommand: ${e}`)}export{executeGlobOnSandbox};