experimental-agent 0.2.1 → 0.3.0

package/dist/adapter-BigchkkI.d.ts

@@ -0,0 +1,201 @@
+import { WORKFLOW_SERIALIZE, WORKFLOW_DESERIALIZE } from '@workflow/serde';
+import { NetworkPolicy } from '@vercel/sandbox';
+import { UIMessage } from 'ai';
+
+type Session = {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+    model: string | null;
+    system: string | null;
+    sandboxId: string | null;
+    lastMessageId: string | null;
+    activeTools: string[] | null;
+    skillsDir: string[] | null;
+    generation: {
+        maxSteps?: number;
+        temperature?: number;
+        topK?: number;
+        topP?: number;
+        frequencyPenalty?: number;
+        presencePenalty?: number;
+        maxOutputTokens?: number;
+        headers?: Record<string, string>;
+    } | null;
+};
+type Message = {
+    id: string;
+    sessionId: string;
+    role: "user" | "assistant" | "system";
+    createdAt: number;
+    startedAt: number | null;
+    completedAt: number | null;
+    interruptedAt: number | null;
+    interruptedLastPart: {
+        index: number;
+        part: unknown;
+    } | null;
+    usage: {
+        steps: {
+            stepIndex: number;
+            model: string;
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            cacheReadTokens: number;
+            cacheWriteTokens: number;
+            reasoningTokens: number;
+        }[];
+        summary: {
+            model: string;
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            cacheReadTokens: number;
+            cacheWriteTokens: number;
+            reasoningTokens: number;
+            stepCount: number;
+        };
+    } | null;
+    workflowRunId?: string | null;
+};
+type Part = {
+    id: string;
+    messageId: string;
+    sessionId: string;
+    index: number;
+    part: UIMessage["parts"][number];
+};
+type Sandbox = {
+    id: string;
+    setup: {
+        binding: string;
+        version: string | null;
+        completedAt: number | null;
+        metadata: Record<string, unknown> | null;
+        networkPolicy: NetworkPolicy | null;
+    };
+    createdAt: number | null;
+    lastActiveAt: number | null;
+};
+type Setup = {
+    version: string;
+    snapshotId: string | null;
+    createdAt: number;
+    lastUsedAt: number | null;
+};
+type SetupSnapshot = Setup;
+
+type StorageHandlers = {
+    "session.get"(p: {
+        id: string;
+    }): Promise<Session | null>;
+    "session.set"(p: {
+        id: string;
+        value: Session;
+    }): Promise<void>;
+    "session.update"(p: {
+        id: string;
+        updates: Partial<Session>;
+    }): Promise<Session>;
+    "message.get"(p: {
+        id: string;
+    }): Promise<Message | null>;
+    "message.set"(p: {
+        id: string;
+        value: Message;
+    }): Promise<void>;
+    "message.update"(p: {
+        id: string;
+        updates: Partial<Message>;
+    }): Promise<Message>;
+    "message.listBySession"(p: {
+        sessionId: string;
+    }): Promise<Message[]>;
+    "part.get"(p: {
+        id: string;
+    }): Promise<Part | null>;
+    "part.set"(p: {
+        id: string;
+        value: Part;
+    }): Promise<void>;
+    "part.listBySession"(p: {
+        sessionId: string;
+    }): Promise<Part[]>;
+    "sandbox.get"(p: {
+        id: string;
+    }): Promise<Sandbox | null>;
+    "sandbox.set"(p: {
+        id: string;
+        value: Sandbox;
+    }): Promise<void>;
+    "sandbox.update"(p: {
+        id: string;
+        updates: Partial<Sandbox>;
+    }): Promise<Sandbox>;
+    "setup.get"(p: {
+        id: string;
+    }): Promise<Setup | null>;
+    "setup.set"(p: {
+        id: string;
+        value: Setup;
+    }): Promise<void>;
+};
+type StorageCall = {
+    [K in keyof StorageHandlers]: {
+        method: K;
+    } & Parameters<StorageHandlers[K]>[0];
+}[keyof StorageHandlers];
+declare class StorageStep {
+    event: StorageCall;
+    constructor(event: StorageCall);
+    static [WORKFLOW_SERIALIZE](instance: StorageStep): {
+        event: StorageCall;
+    };
+    static [WORKFLOW_DESERIALIZE](data: {
+        event: StorageCall;
+    }): StorageStep;
+    on(handlers: StorageHandlers): Promise<any>;
+}
+/**
+ * A single function that handles all storage operations. Intended to be
+ * marked with `"use step"` so that its body (and Node.js-dependent
+ * imports like database clients) is extracted by the workflow bundler
+ * and runs server-side.
+ *
+ * The step receives a `StorageStep` instance (serializable via
+ * `@workflow/serde`) and should call `step.handle({ ... })` with a
+ * `StorageHandlers` map.
+ */
+type StorageStepFunction = (store: StorageStep) => Promise<any>;
+interface Storage {
+    session: {
+        get(key: string): Promise<Session | null>;
+        set(key: string, value: Session): Promise<void>;
+        update(key: string, updates: Partial<Session>): Promise<Session>;
+    };
+    message: {
+        get(key: string): Promise<Message | null>;
+        set(key: string, value: Message): Promise<void>;
+        update(key: string, updates: Partial<Message>): Promise<Message>;
+        listBySession(sessionId: string): Promise<Message[]>;
+    };
+    part: {
+        get(key: string): Promise<Part | null>;
+        set(key: string, value: Part): Promise<void>;
+        listBySession(sessionId: string): Promise<Part[]>;
+    };
+    sandbox: {
+        get(key: string): Promise<Sandbox | null>;
+        set(key: string, value: Sandbox): Promise<void>;
+        update(key: string, updates: Partial<Sandbox>): Promise<Sandbox>;
+    };
+    setup: {
+        get(key: string): Promise<Setup | null>;
+        set(key: string, value: Setup): Promise<void>;
+    };
+}
+type StorageInput = StorageHandlers | StorageStepFunction;
+declare function toStorage(h: StorageInput): Storage;
+
+export { type Message as M, type Part as P, type StorageHandlers as S, type Sandbox as a, type Session as b, type Setup as c, type SetupSnapshot as d, type Storage as e, type StorageCall as f, StorageStep as g, type StorageStepFunction as h, type StorageInput as i, toStorage as t };

package/dist/chunk-BFFNCESS.mjs

@@ -0,0 +1,302 @@
+// src/sandbox/bindings/docker.ts
+import { ulid } from "ulid";
+async function execDocker(args, opts) {
+  const { spawn } = await import("child_process");
+  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;
+var _execSync = null;
+async function registerCleanup() {
+  if (cleanupRegistered) {
+    return;
+  }
+  cleanupRegistered = true;
+  const cp = await import("child_process");
+  _execSync = cp.execSync;
+  const cleanup = () => {
+    if (!_execSync) {
+      return;
+    }
+    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(sandboxName) {
+  const existing = ensurePromises.get(sandboxName);
+  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(sandboxName)) {
+      activeSandboxes.add(sandboxName);
+      registerCleanup();
+      return;
+    }
+    const path = await import("path");
+    const os = await import("os");
+    const fs = await import("fs/promises");
+    const workspaceDir = path.join(
+      os.tmpdir(),
+      "agent-docker-sandbox",
+      sandboxName
+    );
+    await fs.mkdir(workspaceDir, { recursive: true });
+    const create = await execDocker(
+      ["create", "--name", sandboxName, "shell", workspaceDir],
+      { timeoutMs: 6e4 }
+    );
+    if (create.exitCode !== 0) {
+      if (create.stderr.includes("already exists")) {
+        activeSandboxes.add(sandboxName);
+        registerCleanup();
+        return;
+      }
+      throw new Error(
+        `Failed to create docker sandbox "${sandboxName}": ${create.stderr}`
+      );
+    }
+    activeSandboxes.add(sandboxName);
+    registerCleanup();
+  })();
+  ensurePromises.set(sandboxName, promise);
+  try {
+    await promise;
+  } catch (e) {
+    ensurePromises.delete(sandboxName);
+    throw e;
+  }
+}
+var DEFAULT_DOCKER_CWD = "/home/agent/workspace";
+var DockerSandboxInstance = class {
+  cwd;
+  sandboxName;
+  processes = /* @__PURE__ */ new Map();
+  constructor(sandboxName, cwd) {
+    this.sandboxName = sandboxName;
+    this.cwd = cwd ?? DEFAULT_DOCKER_CWD;
+  }
+  async exec(opts) {
+    await ensureSandbox(this.sandboxName);
+    const { spawn } = await import("child_process");
+    const commandId = `command_${ulid()}`;
+    const envFlags = opts.env ? Object.entries(opts.env).flatMap(([k, v]) => ["-e", `${k}=${v}`]) : [];
+    const cwdFlags = opts.cwd ? ["-w", opts.cwd] : [];
+    const baseCmd = opts.sudo ? ["sudo", opts.command, ...opts.args ?? []] : opts.args ? [opts.command, ...opts.args] : [opts.command];
+    const fullCmd = baseCmd;
+    const child = spawn(
+      "docker",
+      [
+        "sandbox",
+        "exec",
+        ...envFlags,
+        ...cwdFlags,
+        this.sandboxName,
+        ...fullCmd
+      ],
+      { signal: opts.signal }
+    );
+    this.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) => {
+        this.processes.delete(commandId);
+        closed = true;
+        logResolve?.();
+        reject(err);
+      });
+      child.on("close", (code) => {
+        this.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((r) => {
+            logResolve = r;
+          });
+          logResolve = null;
+        }
+      }
+    }
+    return { commandId, logs, result };
+  }
+  async readFile(opts) {
+    await ensureSandbox(this.sandboxName);
+    const result = await execDocker(
+      [
+        "exec",
+        this.sandboxName,
+        "bash",
+        "-c",
+        `base64 '${opts.path.replace(/'/g, "'\\''")}'`
+      ],
+      { timeoutMs: 3e4, signal: opts.signal }
+    );
+    if (result.exitCode !== 0) {
+      if (result.stderr.includes("No such file") || result.stderr.includes("ENOENT")) {
+        return null;
+      }
+      throw new Error(`readFile failed: ${result.stderr}`);
+    }
+    return Buffer.from(result.stdout.trim(), "base64");
+  }
+  async writeFiles(opts) {
+    await ensureSandbox(this.sandboxName);
+    for (const file of opts.files) {
+      const fullPath = opts.destPath ? `${opts.destPath}/${file.path}` : file.path;
+      const parentDir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+      if (parentDir) {
+        await execDocker(["exec", this.sandboxName, "mkdir", "-p", parentDir], {
+          signal: opts.signal
+        });
+      }
+      const b64 = typeof file.content === "string" ? Buffer.from(file.content).toString("base64") : file.content.toString("base64");
+      await execDocker(
+        [
+          "exec",
+          this.sandboxName,
+          "bash",
+          "-c",
+          `echo '${b64}' | base64 -d > '${fullPath.replace(/'/g, "'\\''")}'`
+        ],
+        { signal: opts.signal }
+      );
+      if (file.path.endsWith(".sh")) {
+        await execDocker(["exec", this.sandboxName, "chmod", "+x", fullPath], {
+          signal: opts.signal
+        });
+      }
+    }
+  }
+  // biome-ignore lint/suspicious/useAwait: .
+  async getDomain(opts) {
+    return `http://localhost:${opts.port}`;
+  }
+  // biome-ignore lint/suspicious/useAwait: .
+  async kill(opts) {
+    const child = this.processes.get(opts.commandId);
+    if (child) {
+      child.kill("SIGTERM");
+      this.processes.delete(opts.commandId);
+    }
+  }
+  // biome-ignore lint/suspicious/useAwait: .
+  async getStatus() {
+    return "running";
+  }
+  async start() {
+    await ensureSandbox(this.sandboxName);
+  }
+  async stop() {
+    await execDocker(["stop", this.sandboxName], { timeoutMs: 3e4 });
+    activeSandboxes.delete(this.sandboxName);
+    ensurePromises.delete(this.sandboxName);
+  }
+  // biome-ignore lint/suspicious/useAwait: .
+  async snapshot() {
+    throw new Error("snapshot is not supported for docker sandboxes");
+  }
+  // biome-ignore lint/suspicious/useAwait: .
+  async updateNetworkPolicy() {
+    throw new Error(
+      "updateNetworkPolicy is not supported for docker sandboxes"
+    );
+  }
+};
+function dockerSandbox() {
+  return {
+    type: "docker",
+    async create(opts) {
+      const sandboxName = `agent-${ulid()}`;
+      const cwd = opts.setup?.config?.cwd;
+      await ensureSandbox(sandboxName);
+      const instance = new DockerSandboxInstance(sandboxName, cwd);
+      if (opts.setup?.run) {
+        await opts.setup.run(instance);
+      }
+      return {
+        instance,
+        metadata: { sandboxName }
+      };
+    },
+    // biome-ignore lint/suspicious/useAwait: .
+    async connect(opts) {
+      return new DockerSandboxInstance(opts.metadata.sandboxName);
+    }
+  };
+}
+
+export {
+  dockerSandbox
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/sandbox/bindings/docker.ts"],
  "sourcesContent": ["import { ulid } from \"ulid\";\nimport type { ExecResult, SandboxBinding, SandboxInstance } from \"../adapter\";\n\nexport type DockerBindingConfig = {\n  cwd?: string;\n};\n\nexport type DockerBindingMetadata = {\n  sandboxName: string;\n};\n\n/**\n * Run a `docker sandbox` CLI command and return its output.\n */\nasync function execDocker(\n  args: string[],\n  opts?: { timeoutMs?: number; signal?: AbortSignal }\n): Promise<{ stdout: string; stderr: string; exitCode: number }> {\n  const { spawn } = await import(\"node:child_process\");\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;\nlet _execSync: typeof import(\"node:child_process\").execSync | null = null;\n\nasync function registerCleanup() {\n  if (cleanupRegistered) {\n    return;\n  }\n  cleanupRegistered = true;\n\n  // Pre-load execSync so the synchronous exit handler can use it.\n  const cp = await import(\"node:child_process\");\n  _execSync = cp.execSync;\n\n  const cleanup = () => {\n    if (!_execSync) {\n      return;\n    }\n    for (const name of Array.from(activeSandboxes)) {\n      try {\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 name.\n * If it already exists (from a previous process), reuses it.\n * If it doesn't exist, creates it.\n */\nasync function ensureSandbox(sandboxName: string): Promise<void> {\n  const existing = ensurePromises.get(sandboxName);\n  if (existing) {\n    return existing;\n  }\n\n  const promise = (async () => {\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(sandboxName)) {\n      activeSandboxes.add(sandboxName);\n      registerCleanup();\n      return;\n    }\n\n    const path = await import(\"node:path\");\n    const os = await import(\"node:os\");\n    const fs = await import(\"node:fs/promises\");\n\n    const workspaceDir = path.join(\n      os.tmpdir(),\n      \"agent-docker-sandbox\",\n      sandboxName\n    );\n    await fs.mkdir(workspaceDir, { recursive: true });\n\n    const create = await execDocker(\n      [\"create\", \"--name\", sandboxName, \"shell\", workspaceDir],\n      { timeoutMs: 60_000 }\n    );\n\n    if (create.exitCode !== 0) {\n      if (create.stderr.includes(\"already exists\")) {\n        activeSandboxes.add(sandboxName);\n        registerCleanup();\n        return;\n      }\n      throw new Error(\n        `Failed to create docker sandbox \"${sandboxName}\": ${create.stderr}`\n      );\n    }\n\n    activeSandboxes.add(sandboxName);\n    registerCleanup();\n  })();\n\n  ensurePromises.set(sandboxName, promise);\n\n  try {\n    await promise;\n  } catch (e) {\n    ensurePromises.delete(sandboxName);\n    throw e;\n  }\n}\n\nconst DEFAULT_DOCKER_CWD = \"/home/agent/workspace\";\n\nclass DockerSandboxInstance implements SandboxInstance {\n  readonly cwd: string;\n  private readonly sandboxName: string;\n  private readonly processes = new Map<\n    string,\n    import(\"node:child_process\").ChildProcess\n  >();\n\n  constructor(sandboxName: string, cwd?: string) {\n    this.sandboxName = sandboxName;\n    this.cwd = cwd ?? DEFAULT_DOCKER_CWD;\n  }\n\n  async exec(opts: {\n    command: string;\n    args?: string[];\n    cwd?: string;\n    env?: Record<string, string>;\n    sudo?: boolean;\n    signal?: AbortSignal;\n  }): Promise<ExecResult> {\n    await ensureSandbox(this.sandboxName);\n\n    const { spawn } = await import(\"node:child_process\");\n    const commandId = `command_${ulid()}`;\n    const envFlags = opts.env\n      ? Object.entries(opts.env).flatMap(([k, v]) => [\"-e\", `${k}=${v}`])\n      : [];\n    const cwdFlags = opts.cwd ? [\"-w\", opts.cwd] : [];\n    const baseCmd = opts.sudo\n      ? [\"sudo\", opts.command, ...(opts.args ?? [])]\n      : opts.args\n        ? [opts.command, ...opts.args]\n        : [opts.command];\n    const fullCmd = baseCmd;\n\n    const child = spawn(\n      \"docker\",\n      [\n        \"sandbox\",\n        \"exec\",\n        ...envFlags,\n        ...cwdFlags,\n        this.sandboxName,\n        ...fullCmd,\n      ],\n      { signal: opts.signal }\n    );\n\n    this.processes.set(commandId, child);\n\n    let stdout = \"\";\n    let stderr = \"\";\n    const logQueue: { stream: \"stdout\" | \"stderr\"; data: string }[] = [];\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        this.processes.delete(commandId);\n        closed = true;\n        logResolve?.();\n        reject(err);\n      });\n\n      child.on(\"close\", (code: number | null) => {\n        this.processes.delete(commandId);\n        closed = true;\n        logResolve?.();\n        resolve({ stdout, stderr, exitCode: code ?? 0 });\n      });\n    });\n\n    async function* logs(): AsyncIterable<{\n      stream: \"stdout\" | \"stderr\";\n      data: string;\n    }> {\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>((r) => {\n            logResolve = r;\n          });\n          logResolve = null;\n        }\n      }\n    }\n\n    return { commandId, logs, result };\n  }\n\n  async readFile(opts: {\n    path: string;\n    signal?: AbortSignal;\n  }): Promise<Buffer | null> {\n    await ensureSandbox(this.sandboxName);\n\n    const result = await execDocker(\n      [\n        \"exec\",\n        this.sandboxName,\n        \"bash\",\n        \"-c\",\n        `base64 '${opts.path.replace(/'/g, \"'\\\\''\")}'`,\n      ],\n      { timeoutMs: 30_000, signal: opts.signal }\n    );\n\n    if (result.exitCode !== 0) {\n      if (\n        result.stderr.includes(\"No such file\") ||\n        result.stderr.includes(\"ENOENT\")\n      ) {\n        return null;\n      }\n      throw new Error(`readFile failed: ${result.stderr}`);\n    }\n\n    return Buffer.from(result.stdout.trim(), \"base64\");\n  }\n\n  async writeFiles(opts: {\n    files: { path: string; content: string | Buffer }[];\n    destPath: string;\n    signal?: AbortSignal;\n  }): Promise<void> {\n    await ensureSandbox(this.sandboxName);\n\n    for (const file of opts.files) {\n      const fullPath = opts.destPath\n        ? `${opts.destPath}/${file.path}`\n        : file.path;\n\n      // Ensure parent directory exists\n      const parentDir = fullPath.substring(0, fullPath.lastIndexOf(\"/\"));\n      if (parentDir) {\n        await execDocker([\"exec\", this.sandboxName, \"mkdir\", \"-p\", parentDir], {\n          signal: opts.signal,\n        });\n      }\n\n      // Write via base64 to handle both text and binary content\n      const b64 =\n        typeof file.content === \"string\"\n          ? Buffer.from(file.content).toString(\"base64\")\n          : file.content.toString(\"base64\");\n\n      await execDocker(\n        [\n          \"exec\",\n          this.sandboxName,\n          \"bash\",\n          \"-c\",\n          `echo '${b64}' | base64 -d > '${fullPath.replace(/'/g, \"'\\\\''\")}'`,\n        ],\n        { signal: opts.signal }\n      );\n\n      if (file.path.endsWith(\".sh\")) {\n        await execDocker([\"exec\", this.sandboxName, \"chmod\", \"+x\", fullPath], {\n          signal: opts.signal,\n        });\n      }\n    }\n  }\n\n  // biome-ignore lint/suspicious/useAwait: .\n  async getDomain(opts: {\n    port: number;\n    signal?: AbortSignal;\n  }): Promise<string> {\n    return `http://localhost:${opts.port}`;\n  }\n\n  // biome-ignore lint/suspicious/useAwait: .\n  async kill(opts: { commandId: string; signal?: AbortSignal }): Promise<void> {\n    const child = this.processes.get(opts.commandId);\n    if (child) {\n      child.kill(\"SIGTERM\");\n      this.processes.delete(opts.commandId);\n    }\n  }\n\n  // biome-ignore lint/suspicious/useAwait: .\n  async getStatus(): Promise<\n    \"pending\" | \"running\" | \"stopping\" | \"stopped\" | \"failed\"\n  > {\n    // docker sandbox CLI doesn't expose status \u2014 assume running if ensured\n    return \"running\";\n  }\n\n  async start(): Promise<void> {\n    await ensureSandbox(this.sandboxName);\n  }\n\n  async stop(): Promise<void> {\n    await execDocker([\"stop\", this.sandboxName], { timeoutMs: 30_000 });\n    activeSandboxes.delete(this.sandboxName);\n    ensurePromises.delete(this.sandboxName);\n  }\n\n  // biome-ignore lint/suspicious/useAwait: .\n  async snapshot(): Promise<{ snapshotId: string }> {\n    throw new Error(\"snapshot is not supported for docker sandboxes\");\n  }\n\n  // biome-ignore lint/suspicious/useAwait: .\n  async updateNetworkPolicy(): Promise<never> {\n    throw new Error(\n      \"updateNetworkPolicy is not supported for docker sandboxes\"\n    );\n  }\n}\n\nexport function dockerSandbox(): SandboxBinding<\n  \"docker\",\n  DockerBindingConfig,\n  DockerBindingMetadata\n> {\n  return {\n    type: \"docker\",\n    async create(opts) {\n      const sandboxName = `agent-${ulid()}`;\n      const cwd = opts.setup?.config?.cwd;\n\n      await ensureSandbox(sandboxName);\n\n      const instance = new DockerSandboxInstance(sandboxName, cwd);\n\n      if (opts.setup?.run) {\n        await opts.setup.run(instance);\n      }\n\n      return {\n        instance,\n        metadata: { sandboxName },\n      };\n    },\n\n    // biome-ignore lint/suspicious/useAwait: .\n    async connect(opts) {\n      return new DockerSandboxInstance(opts.metadata.sandboxName);\n    },\n  };\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/chunk-C4VSUEY2.mjs

@@ -0,0 +1,72 @@
+// src/sandbox/process-manager.ts
+var DEFAULT_WAIT_UNTIL = 2e3;
+var createProcessManager = (opts) => {
+  const { sandbox } = opts;
+  const run = async (runOpts) => {
+    const { command, waitUntil = DEFAULT_WAIT_UNTIL } = runOpts;
+    const execResult = await sandbox.exec({
+      command: "sh",
+      args: ["-c", command]
+    });
+    if (waitUntil === 0) {
+      return {
+        commandId: execResult.commandId,
+        stdout: "",
+        stderr: "",
+        exitCode: -1,
+        status: "running",
+        outputDir: ""
+      };
+    }
+    const completed = await raceTimeout(execResult, waitUntil);
+    if (!completed) {
+      return {
+        commandId: execResult.commandId,
+        stdout: "",
+        stderr: "",
+        exitCode: -1,
+        status: "running",
+        outputDir: ""
+      };
+    }
+    const outputDir = `.agent/bash/${Date.now()}-${execResult.commandId}`;
+    writeOutputDir(sandbox, outputDir, completed, command);
+    return {
+      commandId: execResult.commandId,
+      stdout: completed.stdout,
+      stderr: completed.stderr,
+      exitCode: completed.exitCode,
+      status: completed.exitCode === 0 ? "completed" : "failed",
+      outputDir
+    };
+  };
+  return { run };
+};
+async function raceTimeout(execResult, timeoutMs) {
+  const TIMED_OUT = /* @__PURE__ */ Symbol("timeout");
+  const timer = new Promise(
+    (resolve) => setTimeout(() => resolve(TIMED_OUT), timeoutMs)
+  );
+  const winner = await Promise.race([execResult.result, timer]);
+  return winner === TIMED_OUT ? null : winner;
+}
+function writeOutputDir(sandbox, dir, result, command) {
+  const files = [
+    { path: "stdout.txt", content: result.stdout },
+    {
+      path: "metadata.json",
+      content: JSON.stringify({ exitCode: result.exitCode, command }, null, 2)
+    }
+  ];
+  if (result.stderr) {
+    files.push({ path: "stderr.txt", content: result.stderr });
+  }
+  sandbox.writeFiles({ files, destPath: dir }).catch(() => {
+  });
+}
+
+export {
+  DEFAULT_WAIT_UNTIL,
+  createProcessManager
+};
+//# sourceMappingURL=data:application/json;base64,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