experimental-agent 0.1.4 → 0.2.1

package/dist/chunk-ZIAHPXOJ.mjs

@@ -0,0 +1,595 @@
+import {
+  createLogger
+} from "./chunk-OZZVS6L5.mjs";
+import {
+  SandboxError
+} from "./chunk-YRYXN7W4.mjs";
+
+// src/sandbox/bindings/docker.ts
+import { execSync, spawn } from "child_process";
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path2 from "path";
+import * as errore from "errore";
+import { ulid } from "ulid";
+
+// src/sandbox/setup-poll.ts
+var log = createLogger({ subsystem: "sandbox:setup" });
+var SETUP_POLL_TIMEOUT_MS = 5 * 60 * 1e3;
+var SETUP_POLL_INTERVAL_MS = 50;
+async function pollForSetupCompletion({
+  storage,
+  sandboxId,
+  setupKey
+}) {
+  const deadline = Date.now() + SETUP_POLL_TIMEOUT_MS;
+  const done = log.time(
+    "waiting for setup completion",
+    { sandboxId, setupKey },
+    { logOnStart: true }
+  );
+  while (Date.now() < deadline) {
+    const record = await storage.sandbox.get(sandboxId);
+    if (!(record instanceof Error) && record) {
+      if (record.setupCompletedAt && record.setupKey === setupKey) {
+        done();
+        return;
+      }
+      if (!record.setupKey) {
+        throw new Error(
+          `Setup was reset for sandbox "${sandboxId}" (setupKey cleared). Will retry on next operation.`
+        );
+      }
+    }
+    await new Promise((r) => setTimeout(r, SETUP_POLL_INTERVAL_MS));
+  }
+  throw new Error(
+    `Timed out waiting for sandbox setup to complete (sandbox="${sandboxId}")`
+  );
+}
+async function markSetupComplete({
+  storage,
+  sandboxId,
+  setupKey
+}) {
+  const result = await storage.sandbox.update({
+    id: sandboxId,
+    setupKey,
+    setupCompletedAt: Date.now()
+  });
+  if (result instanceof Error) {
+    throw result;
+  }
+}
+async function resetSetupState({
+  storage,
+  sandboxId,
+  setupKey
+}) {
+  await storage.sandbox.update({
+    id: sandboxId,
+    setupKey: null,
+    setupCompletedAt: null
+  }).catch((e) => {
+    log.warn("failed to clear setupKey", { sandboxId, error: String(e) });
+  });
+  await storage.setup.delete(setupKey).catch((e) => {
+    log.warn("failed to delete setup record", { setupKey, error: String(e) });
+  });
+}
+
+// src/sandbox/write-files.ts
+import * as path from "path";
+var MAX_RETRIES = 2;
+var RETRY_BASE_MS = 500;
+async function execChecked(sandbox, opts, errorLabel) {
+  for (let attempt = 0; ; attempt++) {
+    const execResult = await sandbox.exec(opts);
+    if (execResult instanceof Error) {
+      throw execResult;
+    }
+    const result = await execResult.result;
+    if (result.exitCode === 0) {
+      return result;
+    }
+    const isTransient = result.exitCode === 255 && !result.stderr.trim();
+    if (isTransient && attempt < MAX_RETRIES) {
+      await new Promise((r) => setTimeout(r, RETRY_BASE_MS * (attempt + 1)));
+      continue;
+    }
+    throw new Error(
+      `${errorLabel} with exit code ${result.exitCode}: ${result.stderr}`
+    );
+  }
+}
+async function writeFiles(opts) {
+  const { sandbox, files, destPath } = opts;
+  if (files.length === 0) {
+    return;
+  }
+  const filePaths = files.map((file) => path.posix.join(destPath, file.path));
+  const parentDirs = Array.from(
+    new Set(filePaths.map((p) => path.posix.dirname(p)))
+  );
+  const shellScripts = filePaths.filter((p) => p.endsWith(".sh"));
+  const mkdirResult = await sandbox.exec({
+    command: "mkdir",
+    args: ["-p", ...parentDirs]
+  });
+  if (mkdirResult instanceof Error) {
+    throw mkdirResult;
+  }
+  await mkdirResult.result;
+  const CHUNK_SIZE = 5e4;
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const fullPath = filePaths[i];
+    const base64Content = toBase64(file.content);
+    if (base64Content.length < CHUNK_SIZE) {
+      const marker = `EOF_${i}`;
+      await execChecked(
+        sandbox,
+        {
+          command: "bash",
+          args: [
+            "-c",
+            `base64 -d > ${quote(fullPath)} << '${marker}'
+${base64Content}
+${marker}`
+          ]
+        },
+        "writeFiles failed"
+      );
+    } else {
+      const tempB64 = `/tmp/chunk-${Date.now()}-${i}.b64`;
+      const clearResult = await sandbox.exec({
+        command: "bash",
+        args: ["-c", `> ${quote(tempB64)}`]
+      });
+      if (clearResult instanceof Error) {
+        throw clearResult;
+      }
+      await clearResult.result;
+      for (let offset = 0; offset < base64Content.length; offset += CHUNK_SIZE) {
+        const chunk = base64Content.slice(offset, offset + CHUNK_SIZE);
+        const marker = `CHUNK_${offset}`;
+        await execChecked(
+          sandbox,
+          {
+            command: "bash",
+            args: [
+              "-c",
+              `cat >> ${quote(tempB64)} << '${marker}'
+${chunk}
+${marker}`
+            ]
+          },
+          "writeFiles chunk failed"
+        );
+      }
+      await execChecked(
+        sandbox,
+        {
+          command: "bash",
+          args: [
+            "-c",
+            `base64 -d < ${quote(tempB64)} > ${quote(fullPath)} && rm -f ${quote(tempB64)}`
+          ]
+        },
+        "writeFiles decode failed"
+      );
+    }
+  }
+  if (shellScripts.length > 0) {
+    const chmodResult = await sandbox.exec({
+      command: "chmod",
+      args: ["+x", ...shellScripts]
+    });
+    if (chmodResult instanceof Error) {
+      throw chmodResult;
+    }
+    await chmodResult.result;
+  }
+}
+function toBase64(content) {
+  if (typeof content === "string") {
+    return Buffer.from(content).toString("base64");
+  }
+  return content.toString("base64");
+}
+function quote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+
+// src/sandbox/bindings/docker.ts
+var dockerAvailable = null;
+async function isDockerSandboxAvailable() {
+  if (dockerAvailable !== null) {
+    return dockerAvailable;
+  }
+  try {
+    const result = await execDocker(["version"], { timeoutMs: 5e3 });
+    dockerAvailable = result.exitCode === 0;
+  } catch {
+    dockerAvailable = false;
+  }
+  return dockerAvailable;
+}
+function execDocker(args, opts) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("docker", ["sandbox", ...args], {
+      signal: opts?.signal
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    const timeoutId = opts?.timeoutMs ? setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(new Error(`docker sandbox ${args[0]} timed out`));
+    }, opts.timeoutMs) : void 0;
+    child.on("error", (err) => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      reject(err);
+    });
+    child.on("close", (code) => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      resolve({ stdout, stderr, exitCode: code ?? 0 });
+    });
+  });
+}
+var ensurePromises = /* @__PURE__ */ new Map();
+var activeSandboxes = /* @__PURE__ */ new Set();
+var cleanupRegistered = false;
+function registerCleanup() {
+  if (cleanupRegistered) {
+    return;
+  }
+  cleanupRegistered = true;
+  const cleanup = () => {
+    for (const name of Array.from(activeSandboxes)) {
+      try {
+        execSync(`docker sandbox stop ${name}`, {
+          timeout: 1e4,
+          stdio: "pipe"
+        });
+      } catch {
+      }
+    }
+  };
+  process.on("exit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(143);
+  });
+}
+async function ensureSandbox(sandboxId) {
+  const existing = ensurePromises.get(sandboxId);
+  if (existing) {
+    return existing;
+  }
+  const promise = (async () => {
+    const ls = await execDocker(["ls", "-q"], { timeoutMs: 1e4 });
+    const existingNames = ls.exitCode === 0 ? ls.stdout.split("\n").map((s) => s.trim()).filter(Boolean) : [];
+    if (existingNames.includes(sandboxId)) {
+      activeSandboxes.add(sandboxId);
+      registerCleanup();
+      return;
+    }
+    const workspaceDir = path2.join(
+      os.tmpdir(),
+      "agent-docker-sandbox",
+      sandboxId
+    );
+    await fs.mkdir(workspaceDir, { recursive: true });
+    const create = await execDocker(
+      ["create", "--name", sandboxId, "shell", workspaceDir],
+      { timeoutMs: 6e4 }
+    );
+    if (create.exitCode !== 0) {
+      if (create.stderr.includes("already exists")) {
+        activeSandboxes.add(sandboxId);
+        registerCleanup();
+        return;
+      }
+      throw new Error(
+        `Failed to create docker sandbox "${sandboxId}": ${create.stderr}`
+      );
+    }
+    activeSandboxes.add(sandboxId);
+    registerCleanup();
+  })();
+  ensurePromises.set(sandboxId, promise);
+  try {
+    await promise;
+  } catch (e) {
+    ensurePromises.delete(sandboxId);
+    throw e;
+  }
+}
+var dockerSandbox = ({
+  sandboxRecord,
+  storage,
+  setup,
+  onRestart
+}) => {
+  const sandboxName = sandboxRecord.id;
+  const cwd = sandboxRecord.config.cwd ?? "/home/agent/workspace";
+  const processes = /* @__PURE__ */ new Map();
+  let startPromise = null;
+  const sandbox = {
+    id: sandboxRecord.id,
+    config: sandboxRecord.config,
+    cwd,
+    exec: ({ command, args, cwd: cwd2, env, signal, sudo }) => {
+      return errore.tryAsync({
+        try: async () => {
+          await ensureSandbox(sandboxName);
+          const commandId = `command_${ulid()}`;
+          const envFlags = env === void 0 ? [] : Object.entries(env).flatMap(([k, v]) => ["-e", `${k}=${v}`]);
+          const cwdFlags = cwd2 ? ["-w", cwd2] : [];
+          const baseCmd = sudo ? ["sudo", command, ...args ?? []] : args ? [command, ...args] : [command];
+          const fullCmd = baseCmd;
+          const child = spawn(
+            "docker",
+            [
+              "sandbox",
+              "exec",
+              ...envFlags,
+              ...cwdFlags,
+              sandboxName,
+              ...fullCmd
+            ],
+            { signal }
+          );
+          processes.set(commandId, child);
+          let stdout = "";
+          let stderr = "";
+          const logQueue = [];
+          let logResolve = null;
+          let closed = false;
+          child.stdout.on("data", (data) => {
+            const str = String(data);
+            stdout += str;
+            logQueue.push({ stream: "stdout", data: str });
+            logResolve?.();
+          });
+          child.stderr.on("data", (data) => {
+            const str = String(data);
+            stderr += str;
+            logQueue.push({ stream: "stderr", data: str });
+            logResolve?.();
+          });
+          const result = new Promise((resolve, reject) => {
+            child.on("error", (err) => {
+              processes.delete(commandId);
+              closed = true;
+              logResolve?.();
+              reject(err);
+            });
+            child.on("close", (code) => {
+              processes.delete(commandId);
+              closed = true;
+              logResolve?.();
+              resolve({ stdout, stderr, exitCode: code ?? 0 });
+            });
+          });
+          async function* logs() {
+            while (!closed || logQueue.length > 0) {
+              const entry = logQueue.shift();
+              if (entry) {
+                yield entry;
+              } else if (!closed) {
+                await new Promise((resolve) => {
+                  logResolve = resolve;
+                });
+                logResolve = null;
+              }
+            }
+          }
+          return { commandId, logs, result };
+        },
+        catch: (e) => new SandboxError({ reason: String(e), cause: e })
+      });
+    },
+    getDomain: (port) => {
+      return Promise.resolve(`http://localhost:${port}`);
+    },
+    kill: async ({ commandId, storage: storage2 }) => {
+      const child = processes.get(commandId);
+      if (!child) {
+        return new SandboxError({
+          reason: `Command ${commandId} not found or already finished`
+        });
+      }
+      child.kill("SIGTERM");
+      const cmd = await storage2.command.get(commandId);
+      if (cmd instanceof Error) {
+        return new SandboxError({ reason: cmd.message, cause: cmd });
+      }
+      if (cmd && cmd.status === "running") {
+        const result = await storage2.command.set({
+          ...cmd,
+          status: "killed"
+        });
+        if (result instanceof Error) {
+          return new SandboxError({ reason: result.message, cause: result });
+        }
+      }
+    },
+    readFile: async ({ path: filePath }) => {
+      try {
+        await ensureSandbox(sandboxName);
+        const result = await execDocker(
+          [
+            "exec",
+            sandboxName,
+            "bash",
+            "-c",
+            `base64 '${filePath.replace(/'/g, "'\\''")}'`
+          ],
+          { timeoutMs: 3e4 }
+        );
+        if (result.exitCode !== 0) {
+          if (result.stderr.includes("No such file") || result.stderr.includes("ENOENT")) {
+            return null;
+          }
+          return new SandboxError({
+            reason: `readFile failed: ${result.stderr}`
+          });
+        }
+        return Buffer.from(result.stdout.trim(), "base64");
+      } catch (e) {
+        return new SandboxError({ reason: String(e), cause: e });
+      }
+    },
+    writeFiles: (opts) => writeFiles({ sandbox, ...opts }),
+    updateNetworkPolicy: () => Promise.resolve(
+      new SandboxError({
+        reason: "updateNetworkPolicy is not yet available for Docker sandboxes"
+      })
+    ),
+    lifecycle: {
+      start: () => {
+        if (startPromise) {
+          return startPromise;
+        }
+        startPromise = (async () => {
+          await ensureSandbox(sandboxName);
+          if (!setup && sandboxRecord.setupKey) {
+            await pollForSetupCompletion({
+              storage,
+              sandboxId: sandboxRecord.id,
+              setupKey: sandboxRecord.setupKey
+            });
+          }
+          if (setup) {
+            const existing = await storage.setup.get(setup.key);
+            if (existing instanceof Error || !existing) {
+              try {
+                await setup.run(sandbox);
+                await storage.setup.set({
+                  key: setup.key,
+                  snapshotId: null,
+                  createdAt: Date.now(),
+                  lastUsedAt: null,
+                  acquiringLockId: null,
+                  acquiringLockAt: null
+                });
+                await markSetupComplete({
+                  storage,
+                  sandboxId: sandboxRecord.id,
+                  setupKey: setup.key
+                });
+              } catch (e) {
+                await resetSetupState({
+                  storage,
+                  sandboxId: sandboxRecord.id,
+                  setupKey: setup.key
+                });
+                throw e;
+              }
+            }
+          }
+          if (onRestart) {
+            await onRestart(sandbox);
+          }
+          return void 0;
+        })().catch((e) => {
+          startPromise = null;
+          throw e;
+        });
+        return startPromise;
+      },
+      snapshot: () => Promise.resolve(
+        new SandboxError({
+          reason: "snapshot is not supported for Docker sandboxes"
+        })
+      ),
+      stop: async () => {
+        try {
+          await execDocker(["stop", sandboxName], { timeoutMs: 3e4 });
+          activeSandboxes.delete(sandboxName);
+          ensurePromises.delete(sandboxName);
+          return void 0;
+        } catch (e) {
+          return new SandboxError({ reason: String(e), cause: e });
+        }
+      },
+      getStatus: () => Promise.resolve(
+        new SandboxError({
+          reason: "getStatus is not supported for Docker sandboxes"
+        })
+      ),
+      getCreatedAt: () => Promise.resolve(
+        new SandboxError({
+          reason: "getCreatedAt is not supported for Docker sandboxes"
+        })
+      ),
+      getRemainingTimeout: () => Promise.resolve(
+        new SandboxError({
+          reason: "getRemainingTimeout is not supported for Docker sandboxes"
+        })
+      )
+    },
+    tag: {
+      list: async () => {
+        const sandboxRecord2 = await storage.sandbox.get(sandbox.id);
+        if (sandboxRecord2 instanceof Error) {
+          return sandboxRecord2;
+        }
+        return sandboxRecord2.tags ?? {};
+      },
+      get: async (key) => {
+        const sandboxRecord2 = await storage.sandbox.get(sandbox.id);
+        if (sandboxRecord2 instanceof Error) {
+          return sandboxRecord2;
+        }
+        return sandboxRecord2.tags?.[key];
+      },
+      set: async (key, value) => {
+        const result = await storage.sandbox.tag.set({
+          sandboxId: sandbox.id,
+          tags: { [key]: value }
+        });
+        if (result instanceof Error) {
+          return result;
+        }
+        return void 0;
+      },
+      setMany: async (tags) => {
+        const result = await storage.sandbox.tag.set({
+          sandboxId: sandbox.id,
+          tags
+        });
+        if (result instanceof Error) {
+          return result;
+        }
+        return void 0;
+      }
+    }
+  };
+  return sandbox;
+};
+
+export {
+  pollForSetupCompletion,
+  markSetupComplete,
+  resetSetupState,
+  writeFiles,
+  isDockerSandboxAvailable,
+  dockerSandbox
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/sandbox/bindings/docker.ts", "../src/sandbox/setup-poll.ts", "../src/sandbox/write-files.ts"],
  "sourcesContent": ["import type { ChildProcess } from \"node:child_process\";\nimport { execSync, spawn } from \"node:child_process\";\nimport * as fs from \"node:fs/promises\";\nimport * as os from \"node:os\";\nimport * as path from \"node:path\";\nimport * as errore from \"errore\";\nimport { ulid } from \"ulid\";\nimport { SandboxError } from \"../../errors\";\nimport type { TagsSchema } from \"../../index\";\nimport type { SandboxRecord, Storage } from \"../../storage\";\nimport {\n  markSetupComplete,\n  pollForSetupCompletion,\n  resetSetupState,\n} from \"../setup-poll\";\nimport type { LogEntry, OnRestart, Sandbox, SandboxSetup } from \"../types\";\nimport { writeFiles } from \"../write-files\";\n\n/**\n * Check whether `docker sandbox` CLI is available.\n * Caches the result for the lifetime of the process.\n */\nlet dockerAvailable: boolean | null = null;\nexport async function isDockerSandboxAvailable(): Promise<boolean> {\n  if (dockerAvailable !== null) {\n    return dockerAvailable;\n  }\n  try {\n    const result = await execDocker([\"version\"], { timeoutMs: 5_000 });\n    dockerAvailable = result.exitCode === 0;\n  } catch {\n    dockerAvailable = false;\n  }\n  return dockerAvailable;\n}\n\n/**\n * Run a `docker sandbox` CLI command and return its output.\n */\nfunction execDocker(\n  args: string[],\n  opts?: { timeoutMs?: number; signal?: AbortSignal }\n): Promise<{ stdout: string; stderr: string; exitCode: number }> {\n  return new Promise((resolve, reject) => {\n    const child = spawn(\"docker\", [\"sandbox\", ...args], {\n      signal: opts?.signal,\n    });\n\n    let stdout = \"\";\n    let stderr = \"\";\n\n    child.stdout.on(\"data\", (data: Buffer) => {\n      stdout += data.toString();\n    });\n    child.stderr.on(\"data\", (data: Buffer) => {\n      stderr += data.toString();\n    });\n\n    const timeoutId = opts?.timeoutMs\n      ? setTimeout(() => {\n          child.kill(\"SIGTERM\");\n          reject(new Error(`docker sandbox ${args[0]} timed out`));\n        }, opts.timeoutMs)\n      : undefined;\n\n    child.on(\"error\", (err) => {\n      if (timeoutId) {\n        clearTimeout(timeoutId);\n      }\n      reject(err);\n    });\n\n    child.on(\"close\", (code) => {\n      if (timeoutId) {\n        clearTimeout(timeoutId);\n      }\n      resolve({ stdout, stderr, exitCode: code ?? 0 });\n    });\n  });\n}\n\n/**\n * Track which sandboxes have been verified to exist in this process.\n * Maps sandbox name -> Promise so concurrent callers wait on the same check.\n */\nconst ensurePromises = new Map<string, Promise<void>>();\n\n/**\n * Sandboxes that this process has used. Stopped on process exit.\n */\nconst activeSandboxes = new Set<string>();\n\nlet cleanupRegistered = false;\nfunction registerCleanup() {\n  if (cleanupRegistered) {\n    return;\n  }\n  cleanupRegistered = true;\n\n  const cleanup = () => {\n    for (const name of Array.from(activeSandboxes)) {\n      try {\n        // execSync is the only option in exit/signal handlers\n        execSync(`docker sandbox stop ${name}`, {\n          timeout: 10_000,\n          stdio: \"pipe\",\n        });\n      } catch {\n        // Best-effort \u2014 sandbox may already be stopped\n      }\n    }\n  };\n\n  process.on(\"exit\", cleanup);\n  process.on(\"SIGINT\", () => {\n    cleanup();\n    process.exit(130);\n  });\n  process.on(\"SIGTERM\", () => {\n    cleanup();\n    process.exit(143);\n  });\n}\n\n/**\n * Ensure a Docker sandbox exists for the given ID.\n * If it already exists (from a previous process), reuses it.\n * If it doesn't exist, creates it.\n */\nasync function ensureSandbox(sandboxId: string): Promise<void> {\n  const existing = ensurePromises.get(sandboxId);\n  if (existing) {\n    return existing;\n  }\n\n  const promise = (async () => {\n    // Check if sandbox already exists via ls -q (survives process restarts)\n    const ls = await execDocker([\"ls\", \"-q\"], { timeoutMs: 10_000 });\n    const existingNames =\n      ls.exitCode === 0\n        ? ls.stdout\n            .split(\"\\n\")\n            .map((s) => s.trim())\n            .filter(Boolean)\n        : [];\n\n    if (existingNames.includes(sandboxId)) {\n      activeSandboxes.add(sandboxId);\n      registerCleanup();\n      return;\n    }\n\n    // Create a temp workspace directory on the host to mount into the sandbox.\n    // Each sandbox gets its own directory for filesystem isolation.\n    const workspaceDir = path.join(\n      os.tmpdir(),\n      \"agent-docker-sandbox\",\n      sandboxId\n    );\n    await fs.mkdir(workspaceDir, { recursive: true });\n\n    const create = await execDocker(\n      [\"create\", \"--name\", sandboxId, \"shell\", workspaceDir],\n      { timeoutMs: 60_000 }\n    );\n\n    if (create.exitCode !== 0) {\n      // Another process may have created it between inspect and create\n      if (create.stderr.includes(\"already exists\")) {\n        activeSandboxes.add(sandboxId);\n        registerCleanup();\n        return;\n      }\n      throw new Error(\n        `Failed to create docker sandbox \"${sandboxId}\": ${create.stderr}`\n      );\n    }\n\n    activeSandboxes.add(sandboxId);\n    registerCleanup();\n  })();\n\n  ensurePromises.set(sandboxId, promise);\n\n  try {\n    await promise;\n  } catch (e) {\n    // Allow retry on failure\n    ensurePromises.delete(sandboxId);\n    throw e;\n  }\n}\n\nexport const dockerSandbox = <TTags extends TagsSchema = TagsSchema>({\n  sandboxRecord,\n  storage,\n  setup,\n  onRestart,\n}: {\n  sandboxRecord: SandboxRecord & { config: { type: \"docker\" } };\n  storage: Storage;\n  setup?: SandboxSetup;\n  onRestart?: OnRestart;\n}): Sandbox<TTags> => {\n  const sandboxName = sandboxRecord.id;\n  const cwd = sandboxRecord.config.cwd ?? \"/home/agent/workspace\";\n  const processes = new Map<string, ChildProcess>();\n\n  let startPromise: Promise<SandboxError | undefined> | null = null;\n\n  const sandbox: Sandbox<TTags> = {\n    id: sandboxRecord.id,\n    config: sandboxRecord.config,\n    cwd,\n\n    exec: ({ command, args, cwd, env, signal, sudo }) => {\n      return errore.tryAsync({\n        try: async () => {\n          await ensureSandbox(sandboxName);\n\n          const commandId = `command_${ulid()}`;\n          const envFlags =\n            env === undefined\n              ? []\n              : Object.entries(env).flatMap(([k, v]) => [\"-e\", `${k}=${v}`]);\n          const cwdFlags = cwd ? [\"-w\", cwd] : [];\n          const baseCmd = sudo\n            ? [\"sudo\", command, ...(args ?? [])]\n            : args\n              ? [command, ...args]\n              : [command];\n          const fullCmd = baseCmd;\n\n          const child = spawn(\n            \"docker\",\n            [\n              \"sandbox\",\n              \"exec\",\n              ...envFlags,\n              ...cwdFlags,\n              sandboxName,\n              ...fullCmd,\n            ],\n            { signal }\n          );\n\n          processes.set(commandId, child);\n\n          let stdout = \"\";\n          let stderr = \"\";\n          const logQueue: LogEntry[] = [];\n          let logResolve: (() => void) | null = null;\n          let closed = false;\n\n          child.stdout.on(\"data\", (data: string | Buffer) => {\n            const str = String(data);\n            stdout += str;\n            logQueue.push({ stream: \"stdout\", data: str });\n            logResolve?.();\n          });\n\n          child.stderr.on(\"data\", (data: string | Buffer) => {\n            const str = String(data);\n            stderr += str;\n            logQueue.push({ stream: \"stderr\", data: str });\n            logResolve?.();\n          });\n\n          const result = new Promise<{\n            stdout: string;\n            stderr: string;\n            exitCode: number;\n          }>((resolve, reject) => {\n            child.on(\"error\", (err) => {\n              processes.delete(commandId);\n              closed = true;\n              logResolve?.();\n              reject(err);\n            });\n\n            child.on(\"close\", (code: number | null) => {\n              processes.delete(commandId);\n              closed = true;\n              logResolve?.();\n              resolve({ stdout, stderr, exitCode: code ?? 0 });\n            });\n          });\n\n          async function* logs(): AsyncIterable<LogEntry> {\n            while (!closed || logQueue.length > 0) {\n              const entry = logQueue.shift();\n              if (entry) {\n                yield entry;\n              } else if (!closed) {\n                await new Promise<void>((resolve) => {\n                  logResolve = resolve;\n                });\n                logResolve = null;\n              }\n            }\n          }\n\n          return { commandId, logs, result };\n        },\n        catch: (e: unknown) =>\n          new SandboxError({ reason: String(e), cause: e }),\n      });\n    },\n\n    getDomain: (port) => {\n      return Promise.resolve(`http://localhost:${port}`);\n    },\n\n    kill: async ({ commandId, storage }) => {\n      const child = processes.get(commandId);\n      if (!child) {\n        return new SandboxError({\n          reason: `Command ${commandId} not found or already finished`,\n        });\n      }\n\n      child.kill(\"SIGTERM\");\n\n      const cmd = await storage.command.get(commandId);\n      if (cmd instanceof Error) {\n        return new SandboxError({ reason: cmd.message, cause: cmd });\n      }\n      if (cmd && cmd.status === \"running\") {\n        const result = await storage.command.set({\n          ...cmd,\n          status: \"killed\",\n        });\n        if (result instanceof Error) {\n          return new SandboxError({ reason: result.message, cause: result });\n        }\n      }\n    },\n\n    readFile: async ({ path: filePath }) => {\n      try {\n        await ensureSandbox(sandboxName);\n\n        // Use docker sandbox exec to cat the file and get its base64 content\n        const result = await execDocker(\n          [\n            \"exec\",\n            sandboxName,\n            \"bash\",\n            \"-c\",\n            `base64 '${filePath.replace(/'/g, \"'\\\\''\")}'`,\n          ],\n          { timeoutMs: 30_000 }\n        );\n\n        if (result.exitCode !== 0) {\n          // File not found\n          if (\n            result.stderr.includes(\"No such file\") ||\n            result.stderr.includes(\"ENOENT\")\n          ) {\n            return null;\n          }\n          return new SandboxError({\n            reason: `readFile failed: ${result.stderr}`,\n          });\n        }\n\n        return Buffer.from(result.stdout.trim(), \"base64\");\n      } catch (e: unknown) {\n        return new SandboxError({ reason: String(e), cause: e });\n      }\n    },\n\n    writeFiles: (opts) => writeFiles({ sandbox, ...opts }),\n\n    updateNetworkPolicy: () =>\n      Promise.resolve(\n        new SandboxError({\n          reason:\n            \"updateNetworkPolicy is not yet available for Docker sandboxes\",\n        })\n      ),\n\n    lifecycle: {\n      start: () => {\n        if (startPromise) {\n          return startPromise;\n        }\n        startPromise = (async () => {\n          await ensureSandbox(sandboxName);\n\n          if (!setup && sandboxRecord.setupKey) {\n            await pollForSetupCompletion({\n              storage,\n              sandboxId: sandboxRecord.id,\n              setupKey: sandboxRecord.setupKey,\n            });\n          }\n\n          if (setup) {\n            const existing = await storage.setup.get(setup.key);\n            if (existing instanceof Error || !existing) {\n              try {\n                await setup.run(sandbox);\n                await storage.setup.set({\n                  key: setup.key,\n                  snapshotId: null,\n                  createdAt: Date.now(),\n                  lastUsedAt: null,\n                  acquiringLockId: null,\n                  acquiringLockAt: null,\n                });\n                await markSetupComplete({\n                  storage,\n                  sandboxId: sandboxRecord.id,\n                  setupKey: setup.key,\n                });\n              } catch (e) {\n                await resetSetupState({\n                  storage,\n                  sandboxId: sandboxRecord.id,\n                  setupKey: setup.key,\n                });\n                throw e;\n              }\n            }\n          }\n\n          if (onRestart) {\n            await onRestart(sandbox);\n          }\n          return undefined;\n        })().catch((e) => {\n          startPromise = null;\n          throw e;\n        });\n        return startPromise;\n      },\n      snapshot: () =>\n        Promise.resolve(\n          new SandboxError({\n            reason: \"snapshot is not supported for Docker sandboxes\",\n          })\n        ),\n      stop: async () => {\n        try {\n          await execDocker([\"stop\", sandboxName], { timeoutMs: 30_000 });\n          activeSandboxes.delete(sandboxName);\n          ensurePromises.delete(sandboxName);\n          return undefined;\n        } catch (e) {\n          return new SandboxError({ reason: String(e), cause: e });\n        }\n      },\n      getStatus: () =>\n        Promise.resolve(\n          new SandboxError({\n            reason: \"getStatus is not supported for Docker sandboxes\",\n          })\n        ),\n      getCreatedAt: () =>\n        Promise.resolve(\n          new SandboxError({\n            reason: \"getCreatedAt is not supported for Docker sandboxes\",\n          })\n        ),\n      getRemainingTimeout: () =>\n        Promise.resolve(\n          new SandboxError({\n            reason: \"getRemainingTimeout is not supported for Docker sandboxes\",\n          })\n        ),\n    },\n\n    tag: {\n      list: async () => {\n        const sandboxRecord = await storage.sandbox.get(sandbox.id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return (sandboxRecord.tags ?? {}) as TTags;\n      },\n      get: async (key: string) => {\n        const sandboxRecord = await storage.sandbox.get(sandbox.id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return sandboxRecord.tags?.[key as string] as\n          | TTags[typeof key]\n          | undefined;\n      },\n      set: async (key: string, value: unknown) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: sandbox.id,\n          tags: { [key]: value } as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n      setMany: async (tags: Record<string, unknown>) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: sandbox.id,\n          tags: tags as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n    },\n  };\n\n  return sandbox;\n};\n", "import type { Storage } from \"../storage\";\nimport { createLogger } from \"../utils/logger\";\n\nconst log = createLogger({ subsystem: \"sandbox:setup\" });\n\nconst SETUP_POLL_TIMEOUT_MS = 5 * 60 * 1000;\nconst SETUP_POLL_INTERVAL_MS = 50;\n\n/**\n * Polls storage until setupCompletedAt is written for the given sandbox+key.\n * Used by cold-start workers that don't have the setup function (it's not\n * serializable) but need to wait until the session worker finishes setup\n * before executing commands.\n *\n * Also detects when setupKey is cleared (setup failed and state was reset),\n * throwing immediately so the caller can retry instead of polling to timeout.\n */\nexport async function pollForSetupCompletion({\n  storage,\n  sandboxId,\n  setupKey,\n}: {\n  storage: Storage;\n  sandboxId: string;\n  setupKey: string;\n}): Promise<void> {\n  const deadline = Date.now() + SETUP_POLL_TIMEOUT_MS;\n  const done = log.time(\n    \"waiting for setup completion\",\n    { sandboxId, setupKey },\n    { logOnStart: true }\n  );\n\n  while (Date.now() < deadline) {\n    const record = await storage.sandbox.get(sandboxId);\n    if (!(record instanceof Error) && record) {\n      if (record.setupCompletedAt && record.setupKey === setupKey) {\n        done();\n        return;\n      }\n      if (!record.setupKey) {\n        throw new Error(\n          `Setup was reset for sandbox \"${sandboxId}\" (setupKey cleared). Will retry on next operation.`\n        );\n      }\n    }\n    await new Promise((r) => setTimeout(r, SETUP_POLL_INTERVAL_MS));\n  }\n  throw new Error(\n    `Timed out waiting for sandbox setup to complete (sandbox=\"${sandboxId}\")`\n  );\n}\n\n/**\n * Writes setupCompletedAt to the sandbox record so cold-start workers\n * polling for setup completion know it's safe to proceed.\n */\nexport async function markSetupComplete({\n  storage,\n  sandboxId,\n  setupKey,\n}: {\n  storage: Storage;\n  sandboxId: string;\n  setupKey: string;\n}): Promise<void> {\n  const result = await storage.sandbox.update({\n    id: sandboxId,\n    setupKey,\n    setupCompletedAt: Date.now(),\n  });\n  if (result instanceof Error) {\n    throw result;\n  }\n}\n\n/**\n * Resets setup-related state on the sandbox record and deletes the setup\n * record. Called when setup fails so that:\n * 1. Cold-start workers detect the cleared setupKey and stop polling\n * 2. Any worker retrying will see no setup record and re-run setup\n *\n * Best-effort: failures are logged but not thrown, since we're already\n * in an error path and the original error matters more.\n */\nexport async function resetSetupState({\n  storage,\n  sandboxId,\n  setupKey,\n}: {\n  storage: Storage;\n  sandboxId: string;\n  setupKey: string;\n}): Promise<void> {\n  await storage.sandbox\n    .update({\n      id: sandboxId,\n      setupKey: null,\n      setupCompletedAt: null,\n    })\n    .catch((e) => {\n      log.warn(\"failed to clear setupKey\", { sandboxId, error: String(e) });\n    });\n\n  await storage.setup.delete(setupKey).catch((e) => {\n    log.warn(\"failed to delete setup record\", { setupKey, error: String(e) });\n  });\n}\n", "import * as path from \"node:path\";\nimport type { UploadableFile } from \"../skills/types\";\nimport type { Sandbox } from \"./types\";\n\nconst MAX_RETRIES = 2;\nconst RETRY_BASE_MS = 500;\n\n/**\n * Exec a command and assert exit code 0. Retries on transient failures\n * (exit code 255 with empty stderr \u2014 typically a sandbox process killed\n * before it could produce output).\n */\nasync function execChecked(\n  sandbox: Pick<Sandbox, \"exec\">,\n  opts: { command: string; args?: string[] },\n  errorLabel: string\n): Promise<{ stdout: string; stderr: string; exitCode: number }> {\n  for (let attempt = 0; ; attempt++) {\n    const execResult = await sandbox.exec(opts);\n    if (execResult instanceof Error) {\n      throw execResult;\n    }\n    const result = await execResult.result;\n    if (result.exitCode === 0) {\n      return result;\n    }\n\n    const isTransient = result.exitCode === 255 && !result.stderr.trim();\n    if (isTransient && attempt < MAX_RETRIES) {\n      await new Promise((r) => setTimeout(r, RETRY_BASE_MS * (attempt + 1)));\n      continue;\n    }\n\n    throw new Error(\n      `${errorLabel} with exit code ${result.exitCode}: ${result.stderr}`\n    );\n  }\n}\n\n/**\n * Writes files to a sandbox at the specified destination path.\n * Shell scripts (.sh files) are automatically made executable.\n *\n * For small files (<100KB total), uses single exec with heredoc.\n * For large files, writes base64 chunks then decodes to avoid ARG_MAX limits.\n */\nexport async function writeFiles(opts: {\n  sandbox: Pick<Sandbox, \"exec\">;\n  files: UploadableFile[];\n  destPath: string;\n}): Promise<void> {\n  const { sandbox, files, destPath } = opts;\n\n  if (files.length === 0) {\n    return;\n  }\n\n  const filePaths = files.map((file) => path.posix.join(destPath, file.path));\n  const parentDirs = Array.from(\n    new Set(filePaths.map((p) => path.posix.dirname(p)))\n  );\n  const shellScripts = filePaths.filter((p) => p.endsWith(\".sh\"));\n\n  const mkdirResult = await sandbox.exec({\n    command: \"mkdir\",\n    args: [\"-p\", ...parentDirs],\n  });\n  if (mkdirResult instanceof Error) {\n    throw mkdirResult;\n  }\n  await mkdirResult.result;\n\n  const CHUNK_SIZE = 50_000;\n\n  for (let i = 0; i < files.length; i++) {\n    const file = files[i];\n    const fullPath = filePaths[i];\n    const base64Content = toBase64(file.content);\n\n    if (base64Content.length < CHUNK_SIZE) {\n      const marker = `EOF_${i}`;\n      await execChecked(\n        sandbox,\n        {\n          command: \"bash\",\n          args: [\n            \"-c\",\n            `base64 -d > ${quote(fullPath)} << '${marker}'\n${base64Content}\n${marker}`,\n          ],\n        },\n        \"writeFiles failed\"\n      );\n    } else {\n      const tempB64 = `/tmp/chunk-${Date.now()}-${i}.b64`;\n\n      const clearResult = await sandbox.exec({\n        command: \"bash\",\n        args: [\"-c\", `> ${quote(tempB64)}`],\n      });\n      if (clearResult instanceof Error) {\n        throw clearResult;\n      }\n      await clearResult.result;\n\n      for (\n        let offset = 0;\n        offset < base64Content.length;\n        offset += CHUNK_SIZE\n      ) {\n        const chunk = base64Content.slice(offset, offset + CHUNK_SIZE);\n        const marker = `CHUNK_${offset}`;\n        await execChecked(\n          sandbox,\n          {\n            command: \"bash\",\n            args: [\n              \"-c\",\n              `cat >> ${quote(tempB64)} << '${marker}'\n${chunk}\n${marker}`,\n            ],\n          },\n          \"writeFiles chunk failed\"\n        );\n      }\n\n      await execChecked(\n        sandbox,\n        {\n          command: \"bash\",\n          args: [\n            \"-c\",\n            `base64 -d < ${quote(tempB64)} > ${quote(fullPath)} && rm -f ${quote(tempB64)}`,\n          ],\n        },\n        \"writeFiles decode failed\"\n      );\n    }\n  }\n\n  if (shellScripts.length > 0) {\n    const chmodResult = await sandbox.exec({\n      command: \"chmod\",\n      args: [\"+x\", ...shellScripts],\n    });\n    if (chmodResult instanceof Error) {\n      throw chmodResult;\n    }\n    await chmodResult.result;\n  }\n}\n\nfunction toBase64(content: string | Buffer): string {\n  if (typeof content === \"string\") {\n    return Buffer.from(content).toString(\"base64\");\n  }\n  return content.toString(\"base64\");\n}\n\nfunction quote(s: string): string {\n  return `'${s.replace(/'/g, \"'\\\\''\")}'`;\n}\n"],
  "mappings": "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",
  "names": ["path", "cwd", "storage", "sandboxRecord"]
}
