@finalai/final-agent-provider 0.10.0 → 0.11.0

package/dist/modules/sandboxes/local.mjs

@@ -0,0 +1,499 @@
+import { Capability, FilesAccess, ShellAccess } from "@finalai/agent-protocol";
+import {
+  defineSandboxProvider,
+  encodeSandboxText,
+  platformProcessEnvironment,
+  PortProtocol,
+  readTextFileStream,
+  runCollect,
+  SandboxEntryType
+} from "@finalai/agent-provider/sandbox";
+import * as z from "zod";
+const LOCAL_PROVIDER = "local";
+const LOCAL_INHERITED_ENV = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LANG",
+  "LC_ALL",
+  "TMPDIR",
+  "TERM",
+  "SHELL"
+];
+const fsError = (code, message) => Object.assign(new Error(`${code}: ${message}`), { code });
+const errorCode = (error) => {
+  const parsed = z.object({ code: z.string() }).safeParse(error);
+  return parsed.success ? parsed.data.code : null;
+};
+const missing = (error) => {
+  const code = errorCode(error);
+  return code === "ENOENT" || code === "ENOTDIR";
+};
+const signalExitCode = (signal) => {
+  if (signal === "SIGKILL") return 137;
+  if (signal === "SIGINT") return 130;
+  return 143;
+};
+const loadNode = () => {
+  if (globalThis.process?.getBuiltinModule == null)
+    throw new Error("A local sandbox runs only in Node");
+  return {
+    childProcess: process.getBuiltinModule("node:child_process"),
+    fs: process.getBuiltinModule("node:fs"),
+    fsPromises: process.getBuiltinModule("node:fs/promises"),
+    os: process.getBuiltinModule("node:os"),
+    path: process.getBuiltinModule("node:path"),
+    streamPromises: process.getBuiltinModule("node:stream/promises")
+  };
+};
+let loaded = null;
+const node = () => loaded ??= loadNode();
+const isSignal = (value) => value in node().os.constants.signals;
+const drained = (stream) => new Promise((resolve) => {
+  const done = () => {
+    stream.off("drain", done);
+    stream.off("close", done);
+    stream.off("error", done);
+    resolve();
+  };
+  stream.once("drain", done);
+  stream.once("close", done);
+  stream.once("error", done);
+});
+const BRIDGE_HIGH_WATER_BYTES = 64 * 1024;
+const nodeToWeb = (readable, extra) => {
+  let open = true;
+  return new ReadableStream(
+    {
+      start: (controller) => {
+        const close = () => {
+          if (!open) return;
+          open = false;
+          controller.close();
+        };
+        const push = (bytes) => {
+          if (!open) return;
+          controller.enqueue(bytes);
+          if ((controller.desiredSize ?? 0) <= 0) readable?.pause();
+        };
+        extra?.({ push, close });
+        if (readable == null) {
+          close();
+          return;
+        }
+        readable.on("data", (chunk) => push(new Uint8Array(chunk)));
+        readable.pause();
+        readable.once("end", close);
+        readable.once("error", (error) => {
+          if (!open) return;
+          open = false;
+          controller.error(error);
+        });
+      },
+      pull: () => {
+        readable?.resume();
+      },
+      cancel: () => {
+        open = false;
+        readable?.destroy();
+      }
+    },
+    { highWaterMark: BRIDGE_HIGH_WATER_BYTES, size: (chunk) => chunk.byteLength }
+  );
+};
+const LOCAL_STOP_GRACE_MS = 2e3;
+const pause = (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+const within = async (promise, ms) => {
+  let timer;
+  try {
+    return await Promise.race([
+      promise.then(() => true),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(false), Math.max(0, ms));
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+};
+const MAX_SYMLINKS = 40;
+const ownGroup = () => process.platform !== "win32";
+const signalProcessTree = (child, signal) => {
+  if (ownGroup() && child.pid != null) {
+    try {
+      process.kill(-child.pid, signal);
+      return;
+    } catch {
+    }
+  }
+  child.kill(signal);
+};
+const inside = (root, path) => {
+  const { isAbsolute, relative, sep } = node().path;
+  const rel = relative(root, path);
+  return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+};
+const createLocalSandbox = async (options) => {
+  const { childProcess, fs, fsPromises, path: paths, streamPromises } = node();
+  const root = paths.resolve(options.root);
+  await fsPromises.mkdir(root, { recursive: true });
+  const realRoot = await fsPromises.realpath(root);
+  const id = options.id ?? `local-${crypto.randomUUID()}`;
+  const processes = /* @__PURE__ */ new Set();
+  const groups = /* @__PURE__ */ new Set();
+  const groupAlive = (pgid) => {
+    try {
+      process.kill(-pgid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const inherited = {};
+  for (const name of options.inheritEnv ?? LOCAL_INHERITED_ENV) {
+    const value = process.env[name];
+    if (value != null) inherited[name] = value;
+  }
+  const resolvePath = (path) => paths.isAbsolute(path) ? paths.resolve(path) : paths.join(root, path);
+  const confined = async (path, within2) => {
+    const bounds = within2 == null ? [realRoot] : [realRoot, await confined(within2)];
+    let existing = resolvePath(path);
+    const rest = [];
+    let links = 0;
+    for (; ; ) {
+      const real = await fsPromises.realpath(existing).catch((error) => {
+        if (missing(error)) return null;
+        throw error;
+      });
+      if (real != null) {
+        const target = paths.join(real, ...rest.toReversed());
+        for (const bound of bounds)
+          if (!inside(bound, target)) throw fsError("EACCES", `${path} is outside the sandbox`);
+        return target;
+      }
+      const entry = await fsPromises.lstat(existing).catch((error) => {
+        if (missing(error)) return null;
+        throw error;
+      });
+      if (entry?.isSymbolicLink() === true) {
+        links += 1;
+        if (links > MAX_SYMLINKS) throw fsError("ELOOP", `${path} has too many symlinks`);
+        const directory = await fsPromises.realpath(paths.dirname(existing));
+        existing = paths.resolve(directory, await fsPromises.readlink(existing));
+        continue;
+      }
+      const parent = paths.dirname(existing);
+      if (parent === existing) throw fsError("ENOENT", `${path} does not exist`);
+      rest.push(paths.basename(existing));
+      existing = parent;
+    }
+  };
+  const confinedEntry = async (path) => {
+    const logical = resolvePath(path);
+    if (logical === root) throw fsError("EPERM", "refusing to remove the sandbox root");
+    return paths.join(await confined(paths.dirname(logical)), paths.basename(logical));
+  };
+  const statOf = async (path, within2) => {
+    let target;
+    try {
+      target = await confined(path, within2);
+      const entry = await fsPromises.stat(target);
+      return {
+        path: resolvePath(path),
+        type: entry.isDirectory() ? SandboxEntryType.Directory : entry.isFile() ? SandboxEntryType.File : SandboxEntryType.Other,
+        size: entry.isDirectory() ? 0 : entry.size,
+        modifiedAt: entry.mtime.toISOString(),
+        mode: entry.mode & 4095
+      };
+    } catch (error) {
+      if (missing(error)) return null;
+      throw error;
+    }
+  };
+  const writeBytes = async (path, data) => {
+    const target = await confined(path);
+    await fsPromises.mkdir(paths.dirname(target), { recursive: true });
+    await fsPromises.writeFile(target, data);
+  };
+  const spawn = async (spawnOptions) => {
+    const signal = spawnOptions.abortSignal;
+    signal?.throwIfAborted();
+    const cwd = await confined(spawnOptions.cwd ?? ".");
+    signal?.throwIfAborted();
+    const base = await options.baseEnv?.();
+    signal?.throwIfAborted();
+    const env = { ...inherited, ...options.env, ...base, ...spawnOptions.env };
+    const shell = spawnOptions.shell === true;
+    const child = childProcess.spawn(
+      shell ? [spawnOptions.command, ...spawnOptions.args ?? []].join(" ") : spawnOptions.command,
+      shell ? [] : spawnOptions.args ?? [],
+      { cwd, env, shell, stdio: ["pipe", "pipe", "pipe"], detached: ownGroup() }
+    );
+    processes.add(child);
+    if (ownGroup() && child.pid != null) {
+      for (const pgid of groups) if (!groupAlive(pgid)) groups.delete(pgid);
+      groups.add(child.pid);
+    }
+    let timedOut = false;
+    const stderr = nodeToWeb(
+      child.stderr,
+      ({ push, close }) => child.once("error", (error) => {
+        push(new TextEncoder().encode(`${error.message}
+`));
+        close();
+      })
+    );
+    const exited = new Promise((settle) => {
+      child.once("error", (error) => {
+        processes.delete(child);
+        settle({ exitCode: errorCode(error) === "ENOENT" ? 127 : 126 });
+      });
+      child.once("exit", (code, signal2) => {
+        processes.delete(child);
+        settle({ exitCode: timedOut ? 124 : code ?? signalExitCode(signal2) });
+      });
+    });
+    const timer = spawnOptions.timeoutMs == null ? null : setTimeout(() => {
+      timedOut = true;
+      signalProcessTree(child, "SIGKILL");
+    }, spawnOptions.timeoutMs);
+    let escalation = null;
+    const terminate = (signal2) => {
+      signalProcessTree(child, signal2);
+      if (signal2 !== "SIGTERM" || escalation != null) return;
+      escalation = setTimeout(() => signalProcessTree(child, "SIGKILL"), LOCAL_STOP_GRACE_MS);
+    };
+    const onAbort = () => terminate("SIGTERM");
+    spawnOptions.abortSignal?.addEventListener("abort", onAbort, { once: true });
+    const settled = () => {
+      if (timer != null) clearTimeout(timer);
+      const groupLeft = ownGroup() && child.pid != null && groupAlive(child.pid);
+      if (escalation != null && !groupLeft) clearTimeout(escalation);
+      spawnOptions.abortSignal?.removeEventListener("abort", onAbort);
+    };
+    child.once("close", settled);
+    child.once("error", settled);
+    const stdin = child.stdin;
+    stdin?.on("error", () => void 0);
+    if (typeof spawnOptions.stdin === "string") stdin?.end(spawnOptions.stdin);
+    else if (spawnOptions.stdin != null) {
+      const reader = spawnOptions.stdin.getReader();
+      let finished = false;
+      void exited.then(() => {
+        finished = true;
+        void reader.cancel().catch(() => void 0);
+      });
+      void (async () => {
+        for (; ; ) {
+          const next = await reader.read();
+          if (next.done || finished || stdin == null || stdin.destroyed) break;
+          if (!stdin.write(next.value)) await Promise.race([drained(stdin), exited]);
+        }
+        stdin?.end();
+      })().catch(() => stdin?.destroy());
+    }
+    return {
+      pid: child.pid == null ? null : String(child.pid),
+      ref: null,
+      stdout: nodeToWeb(child.stdout),
+      stderr,
+      write: async (data, writeOptions) => {
+        if (spawnOptions.stdin != null) throw new Error("stdin was provided at spawn");
+        if (stdin == null) throw new Error("the process has no stdin");
+        await new Promise(
+          (done, fail) => stdin.write(data, (error) => error == null ? done() : fail(error))
+        );
+        if (writeOptions?.end === true) stdin.end();
+      },
+      wait: () => exited,
+      // SIGTERM (killed after the grace period if ignored) and SIGKILL resolve once the
+      // command has ended; any other signal (SIGSTOP, SIGCONT, ...) once it is sent.
+      kill: async (signal2) => {
+        const name = signal2 ?? "SIGTERM";
+        const sent = isSignal(name) ? name : "SIGTERM";
+        terminate(sent);
+        if (sent === "SIGTERM" || sent === "SIGKILL") await exited;
+      }
+    };
+  };
+  const sandbox = {
+    id,
+    root,
+    defaultWorkingDirectory: root,
+    ports: [],
+    description: `This machine, in ${root}.`,
+    readFile: async ({ path, root: within2 }) => {
+      let target;
+      try {
+        target = await confined(path, within2);
+        const entry = await fsPromises.stat(target);
+        if (entry.isDirectory()) throw fsError("EISDIR", `${path} is a directory`);
+      } catch (error) {
+        if (missing(error)) return null;
+        throw error;
+      }
+      return nodeToWeb(fs.createReadStream(target));
+    },
+    readBinaryFile: async ({ path }) => {
+      try {
+        return new Uint8Array(await fsPromises.readFile(await confined(path)));
+      } catch (error) {
+        if (missing(error)) return null;
+        throw error;
+      }
+    },
+    readTextFile: async (readOptions) => {
+      const stream = await sandbox.readFile({ path: readOptions.path });
+      return stream == null ? null : readTextFileStream(stream, readOptions);
+    },
+    writeFile: async ({ path, content }) => {
+      const target = await confined(path);
+      await fsPromises.mkdir(paths.dirname(target), { recursive: true });
+      const reader = content.getReader();
+      const output = fs.createWriteStream(target);
+      await streamPromises.pipeline(
+        (async function* () {
+          for (; ; ) {
+            const next = await reader.read();
+            if (next.done) return;
+            yield next.value;
+          }
+        })(),
+        output
+      );
+    },
+    writeBinaryFile: ({ path, content }) => writeBytes(path, content),
+    writeTextFile: ({ path, content, encoding }) => writeBytes(path, encodeSandboxText(content, encoding)),
+    spawn,
+    run: (runOptions) => runCollect({ spawn }, runOptions),
+    stat: ({ path, root: within2 }) => statOf(path, within2),
+    readDir: async ({ path, root: within2 }) => {
+      const target = await confined(path, within2);
+      const logical = resolvePath(path);
+      const entries = await fsPromises.readdir(target, { withFileTypes: true });
+      return Promise.all(
+        entries.map(async (entry) => {
+          const type = entry.isDirectory() ? SandboxEntryType.Directory : entry.isFile() ? SandboxEntryType.File : entry.isSymbolicLink() ? SandboxEntryType.Symlink : SandboxEntryType.Other;
+          const size = entry.isFile() ? (await fsPromises.lstat(paths.join(target, entry.name))).size : null;
+          return { name: entry.name, path: paths.join(logical, entry.name), type, size };
+        })
+      );
+    },
+    resolvePath,
+    removePath: async ({ path, recursive, force }) => {
+      const target = await confinedEntry(path);
+      await fsPromises.rm(target, { recursive: recursive === true, force: force === true });
+    },
+    getPortEndpoint: async ({ port, protocol }) => ({
+      url: `${protocol ?? PortProtocol.Http}://127.0.0.1:${port}`
+    }),
+    getPortUrl: async (portOptions) => (await sandbox.getPortEndpoint(portOptions)).url,
+    // Stopping ends the commands it started; the directory is the caller's and stays.
+    // A command that ignores SIGTERM is killed once the grace period ends.
+    stop: async () => {
+      const children = [...processes];
+      const pgids = new Set(groups);
+      groups.clear();
+      for (const child of children) if (ownGroup() && child.pid != null) pgids.add(child.pid);
+      const closed = Promise.all(
+        children.map(
+          (child) => new Promise((done) => {
+            if (child.exitCode != null || child.signalCode != null) done();
+            else child.once("exit", () => done());
+          })
+        )
+      );
+      const signalAll = (signal) => {
+        for (const child of children) signalProcessTree(child, signal);
+        for (const pgid of pgids) {
+          try {
+            process.kill(-pgid, signal);
+          } catch {
+          }
+        }
+      };
+      const settled = async (deadline) => {
+        if (!await within(closed, deadline - Date.now())) return false;
+        while ([...pgids].some(groupAlive)) {
+          if (Date.now() >= deadline) return false;
+          await pause(25);
+        }
+        return true;
+      };
+      signalAll("SIGTERM");
+      if (await settled(Date.now() + LOCAL_STOP_GRACE_MS)) return;
+      signalAll("SIGKILL");
+      await settled(Date.now() + LOCAL_STOP_GRACE_MS);
+    },
+    destroy: () => sandbox.stop()
+  };
+  return sandbox;
+};
+const localEnvironmentSchema = z.strictObject({
+  root: z.string().min(1),
+  env: z.record(z.string(), z.string()).optional(),
+  inheritEnv: z.array(z.string().min(1)).optional()
+});
+const localStateSchema = z.object({ version: z.literal(1), root: z.string() });
+const handleOf = (sandbox) => ({
+  sandbox,
+  onSandboxStop: () => sandbox.stop(),
+  onSandboxDelete: () => sandbox.destroy(),
+  onRuntimeShutdown: () => sandbox.stop()
+});
+const createLocalSandboxProvider = () => {
+  const live = /* @__PURE__ */ new Map();
+  return defineSandboxProvider({
+    name: LOCAL_PROVIDER,
+    environment: (rawOptions) => {
+      const options = localEnvironmentSchema.parse(rawOptions);
+      const root = node().path.resolve(options.root);
+      const open = async (ctx, sandboxId) => {
+        const sandbox = await createLocalSandbox({
+          root,
+          id: sandboxId,
+          env: options.env,
+          inheritEnv: options.inheritEnv,
+          baseEnv: platformProcessEnvironment(ctx, {})
+        });
+        live.set(sandboxId, sandbox);
+        return sandbox;
+      };
+      return {
+        capabilities: async () => ({
+          [Capability.Files]: FilesAccess.Write,
+          [Capability.Shell]: ShellAccess.Execute
+        }),
+        artifactKey: async () => `local:${root}`,
+        prepare: async () => ({ version: 1, root }),
+        create: async () => ({ state: { version: 1, root } }),
+        // This process is the machine: it runs as long as the sandbox can be reached.
+        awaitRunning: async () => void 0,
+        attach: async (ctx, { state }) => {
+          const existing = live.get(ctx.sandboxId);
+          const fresh = existing == null && await node().fsPromises.stat(root).catch(() => null) == null;
+          const sandbox = existing ?? await open(ctx, ctx.sandboxId);
+          return { handle: handleOf(sandbox), state, fresh, booted: existing == null };
+        },
+        detach: async (_ctx, { state }) => state,
+        park: async (ctx, { state }) => {
+          await live.get(ctx.sandboxId)?.stop();
+          live.delete(ctx.sandboxId);
+          return state;
+        },
+        delete: async (ctx) => {
+          await live.get(ctx.sandboxId)?.destroy();
+          live.delete(ctx.sandboxId);
+        }
+      };
+    }
+  });
+};
+export {
+  LOCAL_INHERITED_ENV,
+  LOCAL_PROVIDER,
+  LOCAL_STOP_GRACE_MS,
+  createLocalSandbox,
+  createLocalSandboxProvider
+};
+//# sourceMappingURL=local.mjs.map

package/dist/modules/sandboxes/local.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/sandboxes/local.ts"],
+  "sourcesContent": ["import { Capability, FilesAccess, ShellAccess } from '@finalai/agent-protocol';\nimport type { JsonValue } from '@finalai/agent-provider';\nimport {\n  defineSandboxProvider,\n  encodeSandboxText,\n  platformProcessEnvironment,\n  PortProtocol,\n  readTextFileStream,\n  runCollect,\n  SandboxEntryType,\n  type DirEntryIface,\n  type NetworkSandboxSessionIface,\n  type SandboxProcessIface,\n  type SandboxProcessOptionsIface,\n  type SandboxProviderHandleIface,\n  type SandboxProviderIface,\n  type SandboxResourceContextIface,\n  type StatIface,\n} from '@finalai/agent-provider/sandbox';\nimport type { ChildProcess } from 'node:child_process';\nimport type { Readable, Writable } from 'node:stream';\nimport * as z from 'zod';\n\n// A sandbox served from the calling process: files under one directory of\n// this machine and commands run in it, with Node's own fs and child_process.\n// The agents client provides it for any `files` or `shell` capability the\n// caller left out; nothing it does leaves this machine except what the model\n// asks for through the handle. Node only.\n\nexport const LOCAL_PROVIDER = 'local';\n\n// Variables a local command inherits from this process; anything else (API\n// keys, tokens) stays out of the model's shell unless passed in `env`.\nexport const LOCAL_INHERITED_ENV = [\n  'PATH',\n  'HOME',\n  'USER',\n  'LANG',\n  'LC_ALL',\n  'TMPDIR',\n  'TERM',\n  'SHELL',\n];\n\nexport interface LocalSandboxOptionsIface {\n  // The directory the sandbox is confined to; created when missing.\n  root: string;\n  // Plain variables for every command, over the inherited ones.\n  env?: Record<string, string>;\n  // Names inherited from this process's environment (default LOCAL_INHERITED_ENV).\n  inheritEnv?: string[];\n  id?: string;\n  // Every process's environment from the host, read again for each process.\n  baseEnv?: () => Promise<Record<string, string>>;\n}\n\nexport interface LocalSandboxIface extends NetworkSandboxSessionIface {\n  readonly root: string;\n}\n\nconst fsError = (code: string, message: string) =>\n  Object.assign(new Error(`${code}: ${message}`), { code });\n\nconst errorCode = (error: unknown): string | null => {\n  const parsed = z.object({ code: z.string() }).safeParse(error);\n  return parsed.success ? parsed.data.code : null;\n};\n\nconst missing = (error: unknown) => {\n  const code = errorCode(error);\n  return code === 'ENOENT' || code === 'ENOTDIR';\n};\n\nconst signalExitCode = (signal: NodeJS.Signals | null): number => {\n  if (signal === 'SIGKILL') return 137;\n  if (signal === 'SIGINT') return 130;\n  return 143;\n};\n\n// Node's built-ins, read on first use so that importing this module does not\n// tie a browser bundle of the client to Node.\nconst loadNode = () => {\n  if (globalThis.process?.getBuiltinModule == null)\n    throw new Error('A local sandbox runs only in Node');\n  return {\n    childProcess: process.getBuiltinModule('node:child_process'),\n    fs: process.getBuiltinModule('node:fs'),\n    fsPromises: process.getBuiltinModule('node:fs/promises'),\n    os: process.getBuiltinModule('node:os'),\n    path: process.getBuiltinModule('node:path'),\n    streamPromises: process.getBuiltinModule('node:stream/promises'),\n  };\n};\nlet loaded: ReturnType<typeof loadNode> | null = null;\nconst node = () => (loaded ??= loadNode());\n\nconst isSignal = (value: string): value is NodeJS.Signals => value in node().os.constants.signals;\n\n// Settles when a writable can take more, or will take nothing more.\nconst drained = (stream: Writable): Promise<void> =>\n  new Promise((resolve) => {\n    const done = () => {\n      stream.off('drain', done);\n      stream.off('close', done);\n      stream.off('error', done);\n      resolve();\n    };\n    stream.once('drain', done);\n    stream.once('close', done);\n    stream.once('error', done);\n  });\n\n// How much a bridged stream buffers before it stops reading its Node stream.\nconst BRIDGE_HIGH_WATER_BYTES = 64 * 1024;\n\n// A Node stream as a web stream, with backpressure: the Node stream pauses\n// whenever the web stream's queue is full and reads on when its reader pulls.\n// `extra` may push bytes and close the stream from elsewhere.\nconst nodeToWeb = (\n  readable: Readable | null,\n  extra?: (bridge: { push: (bytes: Uint8Array) => void; close: () => void }) => void,\n): ReadableStream<Uint8Array> => {\n  let open = true;\n  return new ReadableStream<Uint8Array>(\n    {\n      start: (controller) => {\n        const close = () => {\n          if (!open) return;\n          open = false;\n          controller.close();\n        };\n        const push = (bytes: Uint8Array) => {\n          if (!open) return;\n          controller.enqueue(bytes);\n          if ((controller.desiredSize ?? 0) <= 0) readable?.pause();\n        };\n        extra?.({ push, close });\n        if (readable == null) {\n          close();\n          return;\n        }\n        readable.on('data', (chunk: Buffer) => push(new Uint8Array(chunk)));\n        // Reads start when the reader pulls.\n        readable.pause();\n        readable.once('end', close);\n        readable.once('error', (error) => {\n          if (!open) return;\n          open = false;\n          controller.error(error);\n        });\n      },\n      pull: () => {\n        readable?.resume();\n      },\n      cancel: () => {\n        open = false;\n        readable?.destroy();\n      },\n    },\n    { highWaterMark: BRIDGE_HIGH_WATER_BYTES, size: (chunk) => chunk.byteLength },\n  );\n};\n\n// How long stopping waits for commands to end on SIGTERM before SIGKILL.\nexport const LOCAL_STOP_GRACE_MS = 2_000;\n\n// Referenced on purpose: a script that ends with `await sandbox.stop()` stays\n// alive until a stubborn command has been killed.\nconst pause = (ms: number): Promise<void> =>\n  new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));\n\n// Whether `promise` settles within `ms`; the timer is cleared either way.\nconst within = async (promise: Promise<unknown>, ms: number): Promise<boolean> => {\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  try {\n    return await Promise.race([\n      promise.then(() => true),\n      new Promise<boolean>((resolve) => {\n        timer = setTimeout(() => resolve(false), Math.max(0, ms));\n      }),\n    ]);\n  } finally {\n    clearTimeout(timer);\n  }\n};\n\n// Symlinks one path may pass through before it is refused as a loop.\nconst MAX_SYMLINKS = 40;\n\n// A command runs in its own process group (POSIX), so that a timeout, a cancel\n// or a stop ends everything it started; a shell's children would otherwise\n// outlive it and hold its output open.\nconst ownGroup = (): boolean => process.platform !== 'win32';\n\nconst signalProcessTree = (child: ChildProcess, signal: NodeJS.Signals): void => {\n  if (ownGroup() && child.pid != null) {\n    try {\n      process.kill(-child.pid, signal);\n      return;\n    } catch {\n      // The group has already exited; signal the child itself.\n    }\n  }\n  child.kill(signal);\n};\n\n// A leading `..` component leaves the root; a name that merely starts with\n// two dots (`..config`) does not.\nconst inside = (root: string, path: string): boolean => {\n  const { isAbsolute, relative, sep } = node().path;\n  const rel = relative(root, path);\n  return rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);\n};\n\nexport const createLocalSandbox = async (\n  options: LocalSandboxOptionsIface,\n): Promise<LocalSandboxIface> => {\n  const { childProcess, fs, fsPromises, path: paths, streamPromises } = node();\n  const root = paths.resolve(options.root);\n  await fsPromises.mkdir(root, { recursive: true });\n  const realRoot = await fsPromises.realpath(root);\n  const id = options.id ?? `local-${crypto.randomUUID()}`;\n  const processes = new Set<ChildProcess>();\n  // Every process group a command started: a shell's backgrounded children\n  // outlive it in its group, and stopping the sandbox ends them too.\n  const groups = new Set<number>();\n  const groupAlive = (pgid: number): boolean => {\n    try {\n      process.kill(-pgid, 0);\n      return true;\n    } catch {\n      return false;\n    }\n  };\n  const inherited: Record<string, string> = {};\n  for (const name of options.inheritEnv ?? LOCAL_INHERITED_ENV) {\n    const value = process.env[name];\n    if (value != null) inherited[name] = value;\n  }\n\n  const resolvePath = (path: string): string =>\n    paths.isAbsolute(path) ? paths.resolve(path) : paths.join(root, path);\n\n  // The real location of `path` (or of its nearest existing ancestor, for a\n  // path about to be created), refused unless it stays under `within`: no `..`\n  // and no symlink leads out of the sandbox. A dangling symlink is followed to\n  // where it points, since writing through it creates its target.\n  const confined = async (path: string, within?: string): Promise<string> => {\n    const bounds = within == null ? [realRoot] : [realRoot, await confined(within)];\n    let existing = resolvePath(path);\n    const rest: string[] = [];\n    let links = 0;\n    for (;;) {\n      const real = await fsPromises.realpath(existing).catch((error: unknown) => {\n        if (missing(error)) return null;\n        throw error;\n      });\n      if (real != null) {\n        const target = paths.join(real, ...rest.toReversed());\n        for (const bound of bounds)\n          if (!inside(bound, target)) throw fsError('EACCES', `${path} is outside the sandbox`);\n        return target;\n      }\n      const entry = await fsPromises.lstat(existing).catch((error: unknown) => {\n        if (missing(error)) return null;\n        throw error;\n      });\n      if (entry?.isSymbolicLink() === true) {\n        links += 1;\n        if (links > MAX_SYMLINKS) throw fsError('ELOOP', `${path} has too many symlinks`);\n        // Relative to the link's real directory, as the kernel resolves it.\n        const directory = await fsPromises.realpath(paths.dirname(existing));\n        existing = paths.resolve(directory, await fsPromises.readlink(existing));\n        continue;\n      }\n      const parent = paths.dirname(existing);\n      if (parent === existing) throw fsError('ENOENT', `${path} does not exist`);\n      rest.push(paths.basename(existing));\n      existing = parent;\n    }\n  };\n\n  // The real location of the entry `path` names, its last component not\n  // followed: removing a symlink removes the link, not what it points to.\n  const confinedEntry = async (path: string): Promise<string> => {\n    const logical = resolvePath(path);\n    if (logical === root) throw fsError('EPERM', 'refusing to remove the sandbox root');\n    return paths.join(await confined(paths.dirname(logical)), paths.basename(logical));\n  };\n\n  const statOf = async (path: string, within?: string): Promise<StatIface | null> => {\n    let target: string;\n    try {\n      target = await confined(path, within);\n      const entry = await fsPromises.stat(target);\n      return {\n        path: resolvePath(path),\n        type: entry.isDirectory()\n          ? SandboxEntryType.Directory\n          : entry.isFile()\n            ? SandboxEntryType.File\n            : SandboxEntryType.Other,\n        size: entry.isDirectory() ? 0 : entry.size,\n        modifiedAt: entry.mtime.toISOString(),\n        mode: entry.mode & 0o7777,\n      };\n    } catch (error) {\n      if (missing(error)) return null;\n      throw error;\n    }\n  };\n\n  const writeBytes = async (path: string, data: Uint8Array): Promise<void> => {\n    const target = await confined(path);\n    await fsPromises.mkdir(paths.dirname(target), { recursive: true });\n    await fsPromises.writeFile(target, data);\n  };\n\n  const spawn = async (spawnOptions: SandboxProcessOptionsIface): Promise<SandboxProcessIface> => {\n    // A command cancelled before it starts never runs.\n    const signal = spawnOptions.abortSignal;\n    signal?.throwIfAborted();\n    const cwd = await confined(spawnOptions.cwd ?? '.');\n    signal?.throwIfAborted();\n    const base = await options.baseEnv?.();\n    signal?.throwIfAborted();\n    const env = { ...inherited, ...options.env, ...base, ...spawnOptions.env };\n    const shell = spawnOptions.shell === true;\n    const child = childProcess.spawn(\n      shell ? [spawnOptions.command, ...(spawnOptions.args ?? [])].join(' ') : spawnOptions.command,\n      shell ? [] : (spawnOptions.args ?? []),\n      { cwd, env, shell, stdio: ['pipe', 'pipe', 'pipe'], detached: ownGroup() },\n    );\n    processes.add(child);\n    if (ownGroup() && child.pid != null) {\n      for (const pgid of groups) if (!groupAlive(pgid)) groups.delete(pgid);\n      groups.add(child.pid);\n    }\n    let timedOut = false;\n    // A command that never started reports why on stderr.\n    const stderr = nodeToWeb(child.stderr, ({ push, close }) =>\n      child.once('error', (error) => {\n        push(new TextEncoder().encode(`${error.message}\\n`));\n        close();\n      }),\n    );\n    const exited = new Promise<{ exitCode: number }>((settle) => {\n      child.once('error', (error) => {\n        processes.delete(child);\n        settle({ exitCode: errorCode(error) === 'ENOENT' ? 127 : 126 });\n      });\n      // Exit, not close: output nobody reads holds the pipes (and `close`) open, and the\n      // command has ended all the same.\n      child.once('exit', (code, signal) => {\n        processes.delete(child);\n        settle({ exitCode: timedOut ? 124 : (code ?? signalExitCode(signal)) });\n      });\n    });\n    const timer =\n      spawnOptions.timeoutMs == null\n        ? null\n        : setTimeout(() => {\n            timedOut = true;\n            signalProcessTree(child, 'SIGKILL');\n          }, spawnOptions.timeoutMs);\n    // A command that ignores SIGTERM is killed once the stop grace period ends.\n    let escalation: ReturnType<typeof setTimeout> | null = null;\n    const terminate = (signal: NodeJS.Signals) => {\n      signalProcessTree(child, signal);\n      if (signal !== 'SIGTERM' || escalation != null) return;\n      escalation = setTimeout(() => signalProcessTree(child, 'SIGKILL'), LOCAL_STOP_GRACE_MS);\n    };\n    const onAbort = () => terminate('SIGTERM');\n    spawnOptions.abortSignal?.addEventListener('abort', onAbort, { once: true });\n    // The deadline, a cancel and the SIGKILL escalation stand until the output closes: a\n    // descendant that outlives the command holds it open and is ended with the group.\n    const settled = () => {\n      if (timer != null) clearTimeout(timer);\n      const groupLeft = ownGroup() && child.pid != null && groupAlive(child.pid);\n      if (escalation != null && !groupLeft) clearTimeout(escalation);\n      spawnOptions.abortSignal?.removeEventListener('abort', onAbort);\n    };\n    child.once('close', settled);\n    child.once('error', settled);\n    const stdin = child.stdin;\n    stdin?.on('error', () => undefined);\n    if (typeof spawnOptions.stdin === 'string') stdin?.end(spawnOptions.stdin);\n    else if (spawnOptions.stdin != null) {\n      const reader = spawnOptions.stdin.getReader();\n      // Reads on only as fast as the command takes its input, and stops when it exits.\n      let finished = false;\n      void exited.then(() => {\n        finished = true;\n        void reader.cancel().catch(() => undefined);\n      });\n      void (async () => {\n        for (;;) {\n          const next = await reader.read();\n          if (next.done || finished || stdin == null || stdin.destroyed) break;\n          if (!stdin.write(next.value)) await Promise.race([drained(stdin), exited]);\n        }\n        stdin?.end();\n      })().catch(() => stdin?.destroy());\n    }\n    return {\n      pid: child.pid == null ? null : String(child.pid),\n      ref: null,\n      stdout: nodeToWeb(child.stdout),\n      stderr,\n      write: async (data, writeOptions) => {\n        if (spawnOptions.stdin != null) throw new Error('stdin was provided at spawn');\n        if (stdin == null) throw new Error('the process has no stdin');\n        await new Promise<void>((done, fail) =>\n          stdin.write(data, (error) => (error == null ? done() : fail(error))),\n        );\n        if (writeOptions?.end === true) stdin.end();\n      },\n      wait: () => exited,\n      // SIGTERM (killed after the grace period if ignored) and SIGKILL resolve once the\n      // command has ended; any other signal (SIGSTOP, SIGCONT, ...) once it is sent.\n      kill: async (signal) => {\n        const name = signal ?? 'SIGTERM';\n        const sent = isSignal(name) ? name : 'SIGTERM';\n        terminate(sent);\n        if (sent === 'SIGTERM' || sent === 'SIGKILL') await exited;\n      },\n    };\n  };\n\n  const sandbox: LocalSandboxIface = {\n    id,\n    root,\n    defaultWorkingDirectory: root,\n    ports: [],\n    description: `This machine, in ${root}.`,\n    readFile: async ({ path, root: within }) => {\n      let target: string;\n      try {\n        target = await confined(path, within);\n        const entry = await fsPromises.stat(target);\n        if (entry.isDirectory()) throw fsError('EISDIR', `${path} is a directory`);\n      } catch (error) {\n        if (missing(error)) return null;\n        throw error;\n      }\n      return nodeToWeb(fs.createReadStream(target));\n    },\n    readBinaryFile: async ({ path }) => {\n      try {\n        return new Uint8Array(await fsPromises.readFile(await confined(path)));\n      } catch (error) {\n        if (missing(error)) return null;\n        throw error;\n      }\n    },\n    readTextFile: async (readOptions) => {\n      const stream = await sandbox.readFile({ path: readOptions.path });\n      return stream == null ? null : readTextFileStream(stream, readOptions);\n    },\n    writeFile: async ({ path, content }) => {\n      const target = await confined(path);\n      await fsPromises.mkdir(paths.dirname(target), { recursive: true });\n      const reader = content.getReader();\n      const output = fs.createWriteStream(target);\n      await streamPromises.pipeline(\n        (async function* () {\n          for (;;) {\n            const next = await reader.read();\n            if (next.done) return;\n            yield next.value;\n          }\n        })(),\n        output,\n      );\n    },\n    writeBinaryFile: ({ path, content }) => writeBytes(path, content),\n    writeTextFile: ({ path, content, encoding }) =>\n      writeBytes(path, encodeSandboxText(content, encoding)),\n    spawn,\n    run: (runOptions) => runCollect({ spawn }, runOptions),\n    stat: ({ path, root: within }) => statOf(path, within),\n    readDir: async ({ path, root: within }): Promise<DirEntryIface[]> => {\n      const target = await confined(path, within);\n      const logical = resolvePath(path);\n      const entries = await fsPromises.readdir(target, { withFileTypes: true });\n      return Promise.all(\n        entries.map(async (entry) => {\n          const type = entry.isDirectory()\n            ? SandboxEntryType.Directory\n            : entry.isFile()\n              ? SandboxEntryType.File\n              : entry.isSymbolicLink()\n                ? SandboxEntryType.Symlink\n                : SandboxEntryType.Other;\n          const size = entry.isFile()\n            ? (await fsPromises.lstat(paths.join(target, entry.name))).size\n            : null;\n          return { name: entry.name, path: paths.join(logical, entry.name), type, size };\n        }),\n      );\n    },\n    resolvePath,\n    removePath: async ({ path, recursive, force }) => {\n      const target = await confinedEntry(path);\n      await fsPromises.rm(target, { recursive: recursive === true, force: force === true });\n    },\n    getPortEndpoint: async ({ port, protocol }) => ({\n      url: `${protocol ?? PortProtocol.Http}://127.0.0.1:${port}`,\n    }),\n    getPortUrl: async (portOptions) => (await sandbox.getPortEndpoint(portOptions)).url,\n    // Stopping ends the commands it started; the directory is the caller's and stays.\n    // A command that ignores SIGTERM is killed once the grace period ends.\n    stop: async () => {\n      const children = [...processes];\n      const pgids = new Set(groups);\n      groups.clear();\n      for (const child of children) if (ownGroup() && child.pid != null) pgids.add(child.pid);\n      const closed = Promise.all(\n        children.map(\n          (child) =>\n            new Promise<void>((done) => {\n              if (child.exitCode != null || child.signalCode != null) done();\n              else child.once('exit', () => done());\n            }),\n        ),\n      );\n      const signalAll = (signal: NodeJS.Signals) => {\n        for (const child of children) signalProcessTree(child, signal);\n        for (const pgid of pgids) {\n          try {\n            process.kill(-pgid, signal);\n          } catch {\n            // The group has already exited.\n          }\n        }\n      };\n      // Whether every command closed and every group is gone by the deadline.\n      const settled = async (deadline: number): Promise<boolean> => {\n        if (!(await within(closed, deadline - Date.now()))) return false;\n        while ([...pgids].some(groupAlive)) {\n          if (Date.now() >= deadline) return false;\n          await pause(25);\n        }\n        return true;\n      };\n      signalAll('SIGTERM');\n      if (await settled(Date.now() + LOCAL_STOP_GRACE_MS)) return;\n      signalAll('SIGKILL');\n      await settled(Date.now() + LOCAL_STOP_GRACE_MS);\n    },\n    destroy: () => sandbox.stop(),\n  };\n  return sandbox;\n};\n\nconst localEnvironmentSchema = z.strictObject({\n  root: z.string().min(1),\n  env: z.record(z.string(), z.string()).optional(),\n  inheritEnv: z.array(z.string().min(1)).optional(),\n});\n\nconst localStateSchema = z.object({ version: z.literal(1), root: z.string() });\n\ntype LocalArtifact = { version: 1; root: string };\ntype LocalState = z.infer<typeof localStateSchema>;\n\nconst handleOf = (sandbox: LocalSandboxIface): SandboxProviderHandleIface<LocalSandboxIface> => ({\n  sandbox,\n  onSandboxStop: () => sandbox.stop(),\n  onSandboxDelete: () => sandbox.destroy(),\n  onRuntimeShutdown: () => sandbox.stop(),\n});\n\n// The local sandbox as a provider, for a host that drives sandboxes through\n// the provider lifecycle. Deleting it stops its commands and leaves the\n// directory, which belongs to whoever runs this process.\nexport const createLocalSandboxProvider = (): SandboxProviderIface<\n  JsonValue,\n  LocalArtifact,\n  LocalState,\n  LocalSandboxIface\n> => {\n  const live = new Map<string, LocalSandboxIface>();\n  return defineSandboxProvider<JsonValue, LocalArtifact, LocalState, LocalSandboxIface>({\n    name: LOCAL_PROVIDER,\n    environment: (rawOptions) => {\n      const options = localEnvironmentSchema.parse(rawOptions);\n      const root = node().path.resolve(options.root);\n      const open = async (ctx: SandboxResourceContextIface, sandboxId: string) => {\n        const sandbox = await createLocalSandbox({\n          root,\n          id: sandboxId,\n          env: options.env,\n          inheritEnv: options.inheritEnv,\n          baseEnv: platformProcessEnvironment(ctx, {}),\n        });\n        live.set(sandboxId, sandbox);\n        return sandbox;\n      };\n      return {\n        capabilities: async () => ({\n          [Capability.Files]: FilesAccess.Write,\n          [Capability.Shell]: ShellAccess.Execute,\n        }),\n        artifactKey: async () => `local:${root}`,\n        prepare: async () => ({ version: 1, root }),\n        create: async () => ({ state: { version: 1, root } }),\n        // This process is the machine: it runs as long as the sandbox can be reached.\n        awaitRunning: async () => undefined,\n        attach: async (ctx, { state }) => {\n          const existing = live.get(ctx.sandboxId);\n          const fresh =\n            existing == null &&\n            (await node()\n              .fsPromises.stat(root)\n              .catch(() => null)) == null;\n          const sandbox = existing ?? (await open(ctx, ctx.sandboxId));\n          return { handle: handleOf(sandbox), state, fresh, booted: existing == null };\n        },\n        detach: async (_ctx, { state }) => state,\n        park: async (ctx, { state }) => {\n          await live.get(ctx.sandboxId)?.stop();\n          live.delete(ctx.sandboxId);\n          return state;\n        },\n        delete: async (ctx) => {\n          await live.get(ctx.sandboxId)?.destroy();\n          live.delete(ctx.sandboxId);\n        },\n      };\n    },\n  });\n};\n"],
+  "mappings": "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",
+  "names": ["within", "signal"]
+}

package/dist/modules/sandboxes/session.d.mts

@@ -1,4 +1,3 @@
-import { SandboxAccess } from '@finalai/agent-provider';
 import type { NetworkSandboxSessionIface, PortProtocol } from '@finalai/agent-provider/sandbox';
 import { type SandboxCommandEncoderIface } from "./commands.mjs";
 import { type SandboxPathsIface } from "./paths.mjs";
@@ -29,5 +28,3 @@ export interface CreateTransportSessionArgsIface {
 }
 export declare const createTransportSession: (args: CreateTransportSessionArgsIface) => NetworkSandboxSessionIface;
 export declare const readOnlySession: <S extends NetworkSandboxSessionIface>(session: S) => S;
-export declare const executeOnlySession: <S extends NetworkSandboxSessionIface>(session: S) => S;
-export declare const sessionForAccess: <S extends NetworkSandboxSessionIface>(session: S, access: SandboxAccess) => S;

package/dist/modules/sandboxes/session.mjs

@@ -1,4 +1,3 @@
-import { SandboxAccess } from "@finalai/agent-provider";
 import { createConfinedFileReader, SandboxEntryType } from "@finalai/agent-provider/sandbox";
 import { encodeSandboxText } from "@finalai/agent-provider/sandbox/bytes";
 import { readTextFileStream } from "@finalai/agent-provider/sandbox/convenience";
@@ -299,7 +298,7 @@ const createTransportSession = (args) => {
   return { ...session, confinedFileReader: createConfinedFileReader(session) };
 };
 const readOnlyRefusal = async () => {
-  throw new Error("this sandbox binding is read-only");
+  throw new Error("this sandbox handle is read-only");
 };
 const readOnlySession = (session) => {
   const restricted = {
@@ -324,27 +323,8 @@ const readOnlySession = (session) => {
     };
   return restricted;
 };
-const fileWriteRefusal = async () => {
-  throw new Error("this sandbox binding runs processes but does not write files");
-};
-const executeOnlySession = (session) => {
-  const restricted = {
-    ...session,
-    writeFile: fileWriteRefusal,
-    writeBinaryFile: fileWriteRefusal,
-    writeTextFile: fileWriteRefusal,
-    removePath: fileWriteRefusal,
-    stop: fileWriteRefusal,
-    destroy: fileWriteRefusal
-  };
-  delete restricted.egress;
-  return restricted;
-};
-const sessionForAccess = (session, access) => access === SandboxAccess.Read ? readOnlySession(session) : access === SandboxAccess.Execute ? executeOnlySession(session) : session;
 export {
   createTransportSession,
-  executeOnlySession,
-  readOnlySession,
-  sessionForAccess
+  readOnlySession
 };
 //# sourceMappingURL=session.mjs.map