agentbox-sdk 0.0.0 → 0.1.1

package/dist/chunk-X7AWPYDK.js

@@ -0,0 +1,1824 @@
+import {
+  AsyncQueue,
+  UnsupportedProviderError,
+  collectAllAgentReservedPorts,
+  pipeReadableStream,
+  readNodeStream,
+  readStreamAsText,
+  sleep,
+  suppressUnhandledRejection
+} from "./chunk-O7HCJXKW.js";
+import {
+  shellQuote,
+  toShellCommand
+} from "./chunk-NSJM57Z4.js";
+import {
+  SandboxProvider
+} from "./chunk-2NKMDGYH.js";
+
+// src/sandboxes/git.ts
+function encodeExtraHeader(name, value) {
+  return `http.extraHeader=${name}: ${value}`;
+}
+function buildGitCloneCommand(options) {
+  const targetDir = options.targetDir ?? ".";
+  const cloneArgs = [];
+  if (options.depth) {
+    cloneArgs.push("--depth", String(options.depth));
+  }
+  if (options.branch) {
+    cloneArgs.push("--branch", options.branch, "--single-branch");
+  }
+  const configArgs = [];
+  if (options.token) {
+    configArgs.push(
+      "-c",
+      encodeExtraHeader("Authorization", `Bearer ${options.token}`)
+    );
+  }
+  for (const [name, value] of Object.entries(options.headers ?? {})) {
+    configArgs.push("-c", encodeExtraHeader(name, value));
+  }
+  const command = [
+    "git",
+    ...configArgs.map(shellQuote),
+    "clone",
+    ...cloneArgs.map(shellQuote),
+    shellQuote(options.repoUrl),
+    shellQuote(targetDir)
+  ].join(" ");
+  if (targetDir === ".") {
+    return command;
+  }
+  return `mkdir -p ${shellQuote(targetDir)} && rm -rf ${shellQuote(targetDir)} && ${command}`;
+}
+
+// src/sandboxes/base.ts
+var SandboxAdapter = class {
+  options;
+  secrets = {};
+  baseEnv;
+  provisioned = false;
+  provisioning;
+  constructor(options) {
+    this.options = options;
+    this.baseEnv = { ...options.env ?? {} };
+  }
+  async uploadFile(_content, _targetPath) {
+    void _content;
+    void _targetPath;
+    throw new Error(
+      `uploadFile is not supported by the ${this.provider} provider.`
+    );
+  }
+  async downloadFile(_sourcePath) {
+    void _sourcePath;
+    throw new Error(
+      `downloadFile is not supported by the ${this.provider} provider.`
+    );
+  }
+  async ensureProvisioned() {
+    if (this.provisioned) {
+      return;
+    }
+    if (!this.provisioning) {
+      this.provisioning = (async () => {
+        await this.provision();
+        this.provisioned = true;
+      })().finally(() => {
+        this.provisioning = void 0;
+      });
+    }
+    await this.provisioning;
+  }
+  get tags() {
+    return { ...this.options.tags ?? {} };
+  }
+  get workingDir() {
+    return this.options.workingDir ?? "/workspace";
+  }
+  /**
+   * Headers that callers should attach to HTTP / WebSocket requests they make
+   * against this sandbox's preview URL. Default is empty; providers like
+   * Vercel override this to inject Deployment Protection bypass tokens.
+   */
+  get previewHeaders() {
+    return {};
+  }
+  getMergedEnv(extra) {
+    return {
+      ...this.baseEnv,
+      ...this.secrets,
+      ...extra ?? {}
+    };
+  }
+  setSecret(name, value) {
+    this.secrets[name] = value;
+  }
+  setSecrets(values) {
+    Object.assign(this.secrets, values);
+  }
+  async gitClone(options) {
+    await this.ensureProvisioned();
+    return this.run(buildGitCloneCommand(options), {
+      cwd: this.workingDir,
+      env: this.getMergedEnv()
+    });
+  }
+};
+
+// src/sandboxes/providers/daytona.ts
+import { Daytona } from "@daytonaio/sdk";
+
+// src/sandboxes/image-utils.ts
+function resolveSandboxImage(image) {
+  return image;
+}
+function resolveSandboxResources(resources) {
+  return resources && Object.values(resources).some((value) => value !== void 0) ? resources : void 0;
+}
+
+// src/sandboxes/providers/daytona.ts
+var DaytonaSandboxAdapter = class extends SandboxAdapter {
+  client;
+  sandbox;
+  constructor(options) {
+    super(options);
+    this.client = new Daytona({
+      apiKey: options.provider?.apiKey,
+      jwtToken: options.provider?.jwtToken,
+      organizationId: options.provider?.organizationId,
+      apiUrl: options.provider?.apiUrl,
+      target: options.provider?.target
+    });
+  }
+  get provider() {
+    return SandboxProvider.Daytona;
+  }
+  get raw() {
+    return {
+      client: this.client,
+      sandbox: this.sandbox
+    };
+  }
+  get id() {
+    return this.sandbox?.id;
+  }
+  async provision() {
+    const existing = await this.findMatchingSandbox();
+    if (existing) {
+      this.sandbox = existing;
+      await existing.start();
+      return;
+    }
+    const labels = this.getLabels();
+    const autoStopInterval = this.options.idleTimeoutMs ? Math.max(1, Math.ceil(this.options.idleTimeoutMs / 6e4)) : void 0;
+    const autoDeleteInterval = this.options.autoStopMs ? Math.max(1, Math.ceil(this.options.autoStopMs / 6e4)) : void 0;
+    const image = resolveSandboxImage(this.options.image);
+    const resources = resolveSandboxResources(this.options.resources);
+    if (!image) {
+      throw new Error(
+        "daytona sandboxes require options.image to reference a prebuilt Daytona snapshot."
+      );
+    }
+    if (resources) {
+      throw new Error(
+        "daytona sandbox sizing is embedded in the image id and cannot be set via options.resources."
+      );
+    }
+    const createBase = {
+      name: this.options.provider?.name,
+      language: this.options.provider?.language ?? "typescript",
+      user: this.options.provider?.user,
+      envVars: this.getMergedEnv(),
+      labels,
+      public: this.options.provider?.public ?? true,
+      autoStopInterval,
+      autoDeleteInterval
+    };
+    const sandbox = await this.client.create({
+      ...createBase,
+      snapshot: image
+    });
+    await sandbox.start();
+    this.sandbox = sandbox;
+  }
+  async run(command, options) {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    const result = await sandbox.process.executeCommand(
+      toShellCommand(command),
+      options?.cwd ?? this.workingDir,
+      this.getMergedEnv(options?.env),
+      options?.timeoutMs ? Math.ceil(options.timeoutMs / 1e3) : void 0
+    );
+    const output = result.result ?? "";
+    return {
+      exitCode: result.exitCode,
+      stdout: output,
+      stderr: output,
+      combinedOutput: output,
+      raw: result
+    };
+  }
+  async runAsync(command, options) {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    const sessionId = `agentbox-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    await sandbox.process.createSession(sessionId);
+    const response = await sandbox.process.executeSessionCommand(
+      sessionId,
+      {
+        command: this.buildSessionCommand(command, options),
+        runAsync: true
+      },
+      options?.timeoutMs ? Math.ceil(options.timeoutMs / 1e3) : void 0
+    );
+    const commandId = response.cmdId;
+    const queue = new AsyncQueue();
+    let stdout = "";
+    let stderr = "";
+    let exitCode = 0;
+    let killed = false;
+    const streamLogs = sandbox.process.getSessionCommandLogs(
+      sessionId,
+      commandId,
+      (chunk) => {
+        stdout += chunk;
+        queue.push({
+          type: "stdout",
+          chunk,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      },
+      (chunk) => {
+        stderr += chunk;
+        queue.push({
+          type: "stderr",
+          chunk,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    );
+    const pollTimeoutMs = options?.timeoutMs ?? 0;
+    const completion = (async () => {
+      const pollStart = Date.now();
+      while (true) {
+        let status;
+        try {
+          status = await sandbox.process.getSessionCommand(
+            sessionId,
+            commandId
+          );
+        } catch (error) {
+          if (killed) {
+            break;
+          }
+          throw error;
+        }
+        if (status.exitCode !== null && status.exitCode !== void 0) {
+          if (!killed) {
+            exitCode = status.exitCode;
+          }
+          break;
+        }
+        if (pollTimeoutMs > 0 && Date.now() - pollStart > pollTimeoutMs) {
+          await sandbox.process.deleteSession(sessionId).catch(() => void 0);
+          killed = true;
+          exitCode = 130;
+          break;
+        }
+        await sleep(500);
+      }
+      try {
+        await streamLogs;
+      } catch (error) {
+        if (!killed) {
+          throw error;
+        }
+      }
+      queue.push({
+        type: "exit",
+        exitCode,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      queue.finish();
+      return {
+        exitCode,
+        stdout,
+        stderr,
+        combinedOutput: `${stdout}${stderr}`,
+        raw: { sessionId, commandId }
+      };
+    })().catch((error) => {
+      queue.fail(error);
+      throw error;
+    });
+    suppressUnhandledRejection(completion);
+    return {
+      id: commandId,
+      raw: { sessionId, commandId },
+      wait: () => completion,
+      kill: async () => {
+        killed = true;
+        exitCode = 130;
+        await sandbox.process.deleteSession(sessionId).catch(() => void 0);
+      },
+      [Symbol.asyncIterator]: () => queue[Symbol.asyncIterator]()
+    };
+  }
+  async list(options) {
+    const result = await this.client.list(options?.tags ?? this.getLabels());
+    return result.items.map((sandbox) => ({
+      provider: this.provider,
+      id: sandbox.id,
+      state: sandbox.state,
+      tags: sandbox.labels ?? {},
+      createdAt: sandbox.createdAt,
+      raw: sandbox
+    }));
+  }
+  async snapshot() {
+    return null;
+  }
+  async stop() {
+    const sandbox = this.sandbox;
+    if (!sandbox) {
+      return;
+    }
+    await sandbox.stop();
+    this.sandbox = void 0;
+  }
+  async delete() {
+    const sandbox = this.sandbox;
+    if (!sandbox) {
+      return;
+    }
+    await sandbox.delete();
+    this.sandbox = void 0;
+  }
+  async openPort(port) {
+    await this.ensureProvisioned();
+    await this.requireSandbox().getPreviewLink(port);
+  }
+  async getPreviewLink(port) {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    const preview = await sandbox.getPreviewLink(port);
+    return preview.url;
+  }
+  getLabels() {
+    return {
+      "agentbox.provider": this.provider,
+      ...this.options.tags ?? {}
+    };
+  }
+  buildSessionCommand(command, options) {
+    const statements = [];
+    const cwd = options?.cwd ?? this.workingDir;
+    const env = this.getMergedEnv(options?.env);
+    if (cwd) {
+      statements.push(`cd ${shellQuote(cwd)}`);
+    }
+    for (const [name, value] of Object.entries(env)) {
+      statements.push(`export ${name}=${shellQuote(value)}`);
+    }
+    statements.push(toShellCommand(command));
+    return statements.join(" && ");
+  }
+  async findMatchingSandbox() {
+    const result = await this.client.list(this.getLabels());
+    return result.items[0];
+  }
+  requireSandbox() {
+    if (!this.sandbox) {
+      throw new Error("Daytona sandbox has not been provisioned.");
+    }
+    return this.sandbox;
+  }
+};
+
+// src/sandboxes/providers/e2b.ts
+var e2bModulePromise;
+async function loadE2bModule() {
+  if (!e2bModulePromise) {
+    e2bModulePromise = import("e2b");
+  }
+  return e2bModulePromise;
+}
+var E2bSandboxAdapter = class extends SandboxAdapter {
+  sandbox;
+  get provider() {
+    return SandboxProvider.E2B;
+  }
+  get raw() {
+    return {
+      sandbox: this.sandbox
+    };
+  }
+  get id() {
+    return this.sandbox?.sandboxId;
+  }
+  async provision() {
+    const { Sandbox: E2bSandbox } = await loadE2bModule();
+    const existing = await this.findMatchingSandbox();
+    if (existing) {
+      this.sandbox = existing;
+      return;
+    }
+    const template = resolveSandboxImage(this.options.image);
+    const resources = resolveSandboxResources(this.options.resources);
+    if (!template) {
+      throw new Error(
+        "e2b sandboxes require options.image to reference an existing E2B template name or tag."
+      );
+    }
+    if (resources) {
+      throw new Error(
+        "e2b sandbox sizing must be defined when building the E2B template and cannot be set via options.resources."
+      );
+    }
+    const timeout = this.resolveTimeoutConfig();
+    this.sandbox = await E2bSandbox.create(template, {
+      ...this.getConnectionOptions(),
+      metadata: this.getMetadata(),
+      envs: this.getMergedEnv(),
+      secure: this.options.provider?.secure,
+      allowInternetAccess: this.options.provider?.allowInternetAccess,
+      ...timeout
+    });
+  }
+  async run(command, options) {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    const { CommandExitError } = await loadE2bModule();
+    if (options?.pty) {
+      const queue = new AsyncQueue();
+      const handle = await this.runAsyncWithPty(
+        sandbox,
+        command,
+        options,
+        queue
+      );
+      const result = await handle.wait();
+      return result;
+    }
+    try {
+      const result = await sandbox.commands.run(
+        toShellCommand(command),
+        this.getCommandStartOptions(options)
+      );
+      return this.toCommandResult(result, result);
+    } catch (error) {
+      if (error instanceof CommandExitError) {
+        return this.toCommandResult(error, error);
+      }
+      throw error;
+    }
+  }
+  async runAsync(command, options) {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    const { CommandExitError } = await loadE2bModule();
+    const queue = new AsyncQueue();
+    let stdout = "";
+    let stderr = "";
+    if (options?.pty) {
+      return this.runAsyncWithPty(sandbox, command, options, queue);
+    }
+    const handle = await sandbox.commands.run(toShellCommand(command), {
+      ...this.getCommandStartOptions(options),
+      timeoutMs: options?.timeoutMs ?? 0,
+      background: true,
+      stdin: true,
+      onStdout: async (chunk) => {
+        stdout += chunk;
+        queue.push({
+          type: "stdout",
+          chunk,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      },
+      onStderr: async (chunk) => {
+        stderr += chunk;
+        queue.push({
+          type: "stderr",
+          chunk,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    });
+    const completion = handle.wait().then((result) => {
+      const mapped = this.toCommandResult(
+        {
+          exitCode: result.exitCode,
+          stdout: stdout || result.stdout,
+          stderr: stderr || result.stderr,
+          error: result.error
+        },
+        result
+      );
+      queue.push({
+        type: "exit",
+        exitCode: mapped.exitCode,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      queue.finish();
+      return mapped;
+    }).catch((error) => {
+      if (error instanceof CommandExitError) {
+        const mapped = this.toCommandResult(
+          {
+            exitCode: error.exitCode,
+            stdout: stdout || error.stdout,
+            stderr: stderr || error.stderr,
+            error: error.error
+          },
+          error
+        );
+        queue.push({
+          type: "exit",
+          exitCode: mapped.exitCode,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        queue.finish();
+        return mapped;
+      }
+      queue.fail(error);
+      throw error;
+    });
+    suppressUnhandledRejection(completion);
+    return {
+      id: String(handle.pid),
+      raw: handle,
+      write: async (input) => {
+        await sandbox.commands.sendStdin(handle.pid, input);
+      },
+      wait: () => completion,
+      kill: async () => {
+        await handle.kill();
+      },
+      [Symbol.asyncIterator]: () => queue[Symbol.asyncIterator]()
+    };
+  }
+  async runAsyncWithPty(sandbox, command, options, queue) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let output = "";
+    const handle = await sandbox.pty.create({
+      cols: 120,
+      rows: 40,
+      cwd: options?.cwd ?? this.workingDir,
+      envs: this.getMergedEnv(options?.env),
+      timeoutMs: options?.timeoutMs ?? 0,
+      onData: async (chunk) => {
+        const text = decoder.decode(chunk, { stream: true });
+        output += text;
+        queue.push({
+          type: "stdout",
+          chunk: text,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    });
+    await sandbox.pty.sendInput(
+      handle.pid,
+      encoder.encode(`${toShellCommand(command)}
+`)
+    );
+    const completion = handle.wait().then((result) => {
+      const flush = decoder.decode();
+      if (flush) {
+        output += flush;
+        queue.push({
+          type: "stdout",
+          chunk: flush,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      queue.push({
+        type: "exit",
+        exitCode: result.exitCode,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      queue.finish();
+      return {
+        exitCode: result.exitCode,
+        stdout: output || result.stdout,
+        stderr: result.stderr,
+        combinedOutput: `${output || result.stdout}${result.stderr}`,
+        raw: result
+      };
+    }).catch((error) => {
+      queue.fail(error);
+      throw error;
+    });
+    suppressUnhandledRejection(completion);
+    return {
+      id: String(handle.pid),
+      raw: handle,
+      write: async (input) => {
+        await sandbox.pty.sendInput(handle.pid, encoder.encode(input));
+      },
+      wait: () => completion,
+      kill: async () => {
+        await handle.kill();
+      },
+      [Symbol.asyncIterator]: () => queue[Symbol.asyncIterator]()
+    };
+  }
+  async list(options) {
+    const { Sandbox: E2bSandbox } = await loadE2bModule();
+    const paginator = E2bSandbox.list({
+      ...this.getConnectionOptions(),
+      query: {
+        metadata: options?.tags ?? this.getMetadata(),
+        state: ["running", "paused"]
+      }
+    });
+    const sandboxes = [];
+    while (paginator.hasNext) {
+      const items = await paginator.nextItems();
+      for (const sandbox of items) {
+        sandboxes.push({
+          provider: this.provider,
+          id: sandbox.sandboxId,
+          state: sandbox.state,
+          tags: sandbox.metadata,
+          createdAt: sandbox.startedAt.toISOString(),
+          raw: sandbox
+        });
+      }
+    }
+    return sandboxes;
+  }
+  async snapshot() {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    const snapshot = await sandbox.createSnapshot();
+    return snapshot.snapshotId;
+  }
+  async stop() {
+    const sandbox = this.sandbox;
+    if (!sandbox) {
+      return;
+    }
+    await sandbox.kill();
+    this.sandbox = void 0;
+  }
+  async delete() {
+    await this.stop();
+  }
+  async openPort(_port) {
+    void _port;
+  }
+  async getPreviewLink(port) {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    const host = sandbox.getHost(port);
+    return host.startsWith("localhost:") ? `http://${host}` : `https://${host}`;
+  }
+  async findMatchingSandbox() {
+    const { Sandbox: E2bSandbox } = await loadE2bModule();
+    const matches = await this.list();
+    const match = matches[0];
+    if (!match) {
+      return void 0;
+    }
+    const timeout = this.resolveTimeoutConfig();
+    return E2bSandbox.connect(match.id, {
+      ...this.getConnectionOptions(),
+      timeoutMs: timeout.timeoutMs
+    });
+  }
+  getMetadata() {
+    return {
+      "agentbox.provider": this.provider,
+      ...this.options.tags ?? {}
+    };
+  }
+  getConnectionOptions() {
+    return {
+      accessToken: this.options.provider?.accessToken,
+      apiKey: this.options.provider?.apiKey,
+      apiUrl: this.options.provider?.apiUrl,
+      debug: this.options.provider?.debug,
+      domain: this.options.provider?.domain,
+      headers: this.options.provider?.headers,
+      requestTimeoutMs: this.options.provider?.requestTimeoutMs,
+      sandboxUrl: this.options.provider?.sandboxUrl
+    };
+  }
+  getCommandStartOptions(options) {
+    return {
+      cwd: options?.cwd ?? this.workingDir,
+      envs: this.getMergedEnv(options?.env),
+      timeoutMs: options?.timeoutMs
+    };
+  }
+  resolveTimeoutConfig() {
+    const providerTimeoutMs = this.options.provider?.timeoutMs;
+    const providerLifecycle = this.options.provider?.lifecycle;
+    const hasProviderTimeoutOverride = providerTimeoutMs !== void 0 || providerLifecycle !== void 0;
+    const normalizedLifecycle = providerLifecycle?.onTimeout ? {
+      onTimeout: providerLifecycle.onTimeout,
+      autoResume: providerLifecycle.autoResume
+    } : void 0;
+    if (hasProviderTimeoutOverride && (this.options.idleTimeoutMs !== void 0 || this.options.autoStopMs !== void 0)) {
+      throw new Error(
+        "e2b sandbox timeout configuration must use either provider.timeoutMs/provider.lifecycle or the shared idleTimeoutMs/autoStopMs fields, but not both."
+      );
+    }
+    if (providerLifecycle?.autoResume && providerLifecycle.onTimeout !== "pause") {
+      throw new Error(
+        "e2b provider.lifecycle.autoResume can only be enabled when provider.lifecycle.onTimeout is 'pause'."
+      );
+    }
+    if (hasProviderTimeoutOverride) {
+      return {
+        timeoutMs: providerTimeoutMs,
+        lifecycle: normalizedLifecycle
+      };
+    }
+    if (this.options.idleTimeoutMs !== void 0 && this.options.autoStopMs !== void 0) {
+      throw new Error(
+        "e2b sandboxes do not support combining idleTimeoutMs and autoStopMs because the provider exposes a single timeout/lifecycle configuration."
+      );
+    }
+    if (this.options.idleTimeoutMs !== void 0) {
+      return {
+        timeoutMs: this.options.idleTimeoutMs,
+        lifecycle: {
+          onTimeout: "pause",
+          autoResume: false
+        }
+      };
+    }
+    if (this.options.autoStopMs !== void 0) {
+      return {
+        timeoutMs: this.options.autoStopMs,
+        lifecycle: {
+          onTimeout: "kill",
+          autoResume: false
+        }
+      };
+    }
+    return {};
+  }
+  requireSandbox() {
+    if (!this.sandbox) {
+      throw new Error("E2B sandbox has not been provisioned.");
+    }
+    return this.sandbox;
+  }
+  toCommandResult(result, raw) {
+    return {
+      exitCode: result.exitCode,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      combinedOutput: `${result.stdout}${result.stderr}`,
+      raw
+    };
+  }
+};
+
+// src/sandboxes/providers/local-docker.ts
+import Docker from "dockerode";
+import tar from "tar-stream";
+import { PassThrough } from "stream";
+import { finished } from "stream/promises";
+var LocalDockerSandboxAdapter = class extends SandboxAdapter {
+  client = new Docker();
+  container;
+  get provider() {
+    return SandboxProvider.LocalDocker;
+  }
+  get raw() {
+    return {
+      client: this.client,
+      container: this.container
+    };
+  }
+  get id() {
+    return this.container?.id;
+  }
+  async provision() {
+    const existing = await this.findMatchingContainer();
+    if (existing) {
+      this.container = this.client.getContainer(existing.Id);
+      if (existing.State !== "running") {
+        await this.container.start();
+      }
+      return;
+    }
+    const normalizedImage = resolveSandboxImage(this.options.image);
+    const image = await this.resolveContainerImage(normalizedImage);
+    const resources = resolveSandboxResources(this.options.resources);
+    const labels = this.getLabels();
+    const env = Object.entries(this.getMergedEnv()).map(
+      ([key, value]) => `${key}=${value}`
+    );
+    const publishedPorts = this.options.provider?.publishedPorts ?? [];
+    const portBindings = publishedPorts.length > 0 ? Object.fromEntries(
+      publishedPorts.map((port) => [
+        `${port}/tcp`,
+        [{ HostIp: "127.0.0.1", HostPort: String(port) }]
+      ])
+    ) : void 0;
+    const exposedPorts = publishedPorts.length > 0 ? Object.fromEntries(publishedPorts.map((port) => [`${port}/tcp`, {}])) : void 0;
+    const container = await this.client.createContainer({
+      Image: image,
+      name: this.options.provider?.name,
+      Cmd: this.options.provider?.command ?? ["sleep", "infinity"],
+      WorkingDir: this.workingDir,
+      Env: env,
+      Labels: labels,
+      Tty: false,
+      OpenStdin: true,
+      ...exposedPorts ? { ExposedPorts: exposedPorts } : {},
+      HostConfig: {
+        AutoRemove: this.options.provider?.autoRemove ?? false,
+        Binds: this.options.provider?.binds,
+        NetworkMode: this.options.provider?.networkMode,
+        ExtraHosts: ["host.docker.internal:host-gateway"],
+        ...portBindings ? { PortBindings: portBindings } : {},
+        ...resources?.cpu ? { NanoCpus: Math.round(resources.cpu * 1e9) } : {},
+        ...resources?.memoryMiB ? { Memory: resources.memoryMiB * 1024 * 1024 } : {}
+      }
+    });
+    this.container = container;
+    await container.start();
+  }
+  async run(command, options) {
+    await this.ensureProvisioned();
+    const container = this.requireContainer();
+    const exec = await container.exec({
+      AttachStdout: true,
+      AttachStderr: true,
+      Cmd: ["/bin/sh", "-lc", toShellCommand(command)],
+      Env: this.toDockerEnv(options?.env),
+      WorkingDir: options?.cwd ?? this.workingDir
+    });
+    const stream = await exec.start({ hijack: true, stdin: false, Tty: false });
+    const { stdout, stderr } = this.demuxExecStream(container, stream);
+    const work = Promise.all([
+      readNodeStream(stdout),
+      readNodeStream(stderr),
+      finished(stream)
+    ]).then(([out, err]) => [out, err]);
+    let result;
+    if (options?.timeoutMs && options.timeoutMs > 0) {
+      const timeout = new Promise(
+        (_, reject) => setTimeout(
+          () => reject(
+            new Error(`Command timed out after ${options.timeoutMs}ms.`)
+          ),
+          options.timeoutMs
+        )
+      );
+      result = await Promise.race([work, timeout]);
+    } else {
+      result = await work;
+    }
+    const [stdoutBuffer, stderrBuffer] = result;
+    const inspect = await exec.inspect();
+    const stdoutText = stdoutBuffer.toString("utf8");
+    const stderrText = stderrBuffer.toString("utf8");
+    return {
+      exitCode: inspect.ExitCode ?? 0,
+      stdout: stdoutText,
+      stderr: stderrText,
+      combinedOutput: `${stdoutText}${stderrText}`,
+      raw: { exec, inspect }
+    };
+  }
+  async runAsync(command, options) {
+    await this.ensureProvisioned();
+    const container = this.requireContainer();
+    const exec = await container.exec({
+      AttachStdin: true,
+      AttachStdout: true,
+      AttachStderr: true,
+      Cmd: ["/bin/sh", "-lc", toShellCommand(command)],
+      Env: this.toDockerEnv(options?.env),
+      WorkingDir: options?.cwd ?? this.workingDir,
+      Tty: options?.pty ?? false
+    });
+    const tty = options?.pty ?? false;
+    const stream = await exec.start({ hijack: true, stdin: true, Tty: tty });
+    const { stdout, stderr } = tty ? this.wrapTtyExecStream(stream) : this.demuxExecStream(container, stream);
+    const queue = new AsyncQueue();
+    let stdoutText = "";
+    let stderrText = "";
+    stdout.on("data", (chunk) => {
+      const text = chunk.toString("utf8");
+      stdoutText += text;
+      queue.push({
+        type: "stdout",
+        chunk: text,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+    stderr.on("data", (chunk) => {
+      const text = chunk.toString("utf8");
+      stderrText += text;
+      queue.push({
+        type: "stderr",
+        chunk: text,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+    const completion = (async () => {
+      await finished(stream);
+      const inspect = await exec.inspect();
+      const exitCode = inspect.ExitCode ?? 0;
+      queue.push({
+        type: "exit",
+        exitCode,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        raw: inspect
+      });
+      queue.finish();
+      return {
+        exitCode,
+        stdout: stdoutText,
+        stderr: stderrText,
+        combinedOutput: `${stdoutText}${stderrText}`,
+        raw: { exec, inspect }
+      };
+    })().catch((error) => {
+      queue.fail(error);
+      throw error;
+    });
+    suppressUnhandledRejection(completion);
+    return {
+      id: exec.id,
+      raw: { exec, stream },
+      write: async (input) => {
+        stream.write(input);
+      },
+      wait: () => completion,
+      kill: async () => {
+        try {
+          stream.write("");
+          stream.end();
+        } catch {
+        }
+      },
+      [Symbol.asyncIterator]: () => queue[Symbol.asyncIterator]()
+    };
+  }
+  demuxExecStream(container, stream) {
+    const stdout = new PassThrough();
+    const stderr = new PassThrough();
+    container.modem.demuxStream(stream, stdout, stderr);
+    const endOutputs = () => {
+      stdout.end();
+      stderr.end();
+    };
+    stream.on("end", endOutputs);
+    stream.on("close", endOutputs);
+    stream.on("error", (error) => {
+      stdout.destroy(error);
+      stderr.destroy(error);
+    });
+    return { stdout, stderr };
+  }
+  wrapTtyExecStream(stream) {
+    const stdout = new PassThrough();
+    const stderr = new PassThrough();
+    stream.on("data", (chunk) => {
+      stdout.write(chunk);
+    });
+    stream.on("end", () => {
+      stdout.end();
+      stderr.end();
+    });
+    stream.on("close", () => {
+      stdout.end();
+      stderr.end();
+    });
+    stream.on("error", (error) => {
+      stdout.destroy(error);
+      stderr.destroy(error);
+    });
+    return { stdout, stderr };
+  }
+  async list(options) {
+    const filters = {
+      label: this.toDockerLabelFilters(options?.tags)
+    };
+    const containers = await this.client.listContainers({ all: true, filters });
+    return containers.map((container) => ({
+      provider: this.provider,
+      id: container.Id,
+      state: container.State,
+      tags: container.Labels ?? {},
+      raw: container
+    }));
+  }
+  async snapshot() {
+    return null;
+  }
+  async stop() {
+    const container = this.container;
+    if (!container) {
+      return;
+    }
+    await container.stop().catch(() => void 0);
+  }
+  async delete() {
+    const container = this.container;
+    if (!container) {
+      return;
+    }
+    await container.remove({ force: true }).catch(() => void 0);
+    this.container = void 0;
+  }
+  async openPort(port) {
+    const provider = this.options.provider ?? (this.options.provider = {});
+    if (provider.networkMode === "host") {
+      return;
+    }
+    provider.publishedPorts = provider.publishedPorts?.includes(port) ? provider.publishedPorts : [...provider.publishedPorts ?? [], port];
+  }
+  async getPreviewLink(port) {
+    const networkMode = this.options.provider?.networkMode;
+    if (networkMode === "host") {
+      return `http://127.0.0.1:${port}`;
+    }
+    if (this.options.provider?.publishedPorts?.includes(port)) {
+      return `http://127.0.0.1:${port}`;
+    }
+    throw new Error(
+      `Port ${port} is not reachable from the host. Use local-docker provider.networkMode="host" or provider.publishedPorts to expose it.`
+    );
+  }
+  async uploadFile(content, targetPath) {
+    await this.ensureProvisioned();
+    const container = this.requireContainer();
+    const pack = tar.pack();
+    const body = Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8");
+    pack.entry({ name: targetPath.replace(/^\/+/, "") }, body);
+    pack.finalize();
+    await container.putArchive(pack, { path: "/" });
+  }
+  async downloadFile(sourcePath) {
+    await this.ensureProvisioned();
+    const container = this.requireContainer();
+    const archive = await container.getArchive({ path: sourcePath });
+    const chunks = [];
+    for await (const chunk of archive) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+  }
+  requireContainer() {
+    if (!this.container) {
+      throw new Error("Docker container is not provisioned.");
+    }
+    return this.container;
+  }
+  getLabels() {
+    return {
+      "agentbox.provider": this.provider,
+      ...this.options.tags ?? {}
+    };
+  }
+  toDockerEnv(extra) {
+    return Object.entries(this.getMergedEnv(extra)).map(
+      ([key, value]) => `${key}=${value}`
+    );
+  }
+  toDockerLabelFilters(tags) {
+    const labels = {
+      "agentbox.provider": this.provider,
+      ...tags ?? {}
+    };
+    return Object.entries(labels).map(([key, value]) => `${key}=${value}`);
+  }
+  async findMatchingContainer() {
+    const containers = await this.client.listContainers({
+      all: true,
+      filters: { label: this.toDockerLabelFilters(this.options.tags) }
+    });
+    return containers[0];
+  }
+  async pullImage(image) {
+    const stream = await this.client.pull(image);
+    await new Promise((resolve, reject) => {
+      this.client.modem.followProgress(stream, (error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+  async resolveContainerImage(image) {
+    if (!image) {
+      throw new Error(
+        "local-docker sandboxes require options.image to reference a local Docker image."
+      );
+    }
+    if (this.options.provider?.pull) {
+      await this.pullImage(image);
+    }
+    return image;
+  }
+};
+
+// src/sandboxes/providers/modal.ts
+import { ModalClient } from "modal";
+var ModalSandboxAdapter = class extends SandboxAdapter {
+  client;
+  sandbox;
+  clientClosed = false;
+  constructor(options) {
+    super(options);
+    this.client = new ModalClient({
+      tokenId: options.provider?.tokenId,
+      tokenSecret: options.provider?.tokenSecret,
+      environment: options.provider?.environment,
+      endpoint: options.provider?.endpoint
+    });
+  }
+  get provider() {
+    return SandboxProvider.Modal;
+  }
+  get raw() {
+    return {
+      client: this.client,
+      sandbox: this.sandbox
+    };
+  }
+  get id() {
+    return this.sandbox?.sandboxId;
+  }
+  async provision() {
+    const existing = await this.findMatchingSandbox();
+    if (existing) {
+      this.sandbox = existing;
+      return;
+    }
+    const appName = this.options.provider?.appName ?? "agentbox";
+    const app = await this.client.apps.fromName(appName, {
+      createIfMissing: true,
+      environment: this.options.provider?.environment
+    });
+    const image = await this.resolveModalImage();
+    const resources = resolveSandboxResources(this.options.resources);
+    const unencryptedPorts = this.resolveDefaultUnencryptedPorts();
+    const sandbox = await this.client.sandboxes.create(app, image, {
+      cpu: resources?.cpu,
+      memoryMiB: resources?.memoryMiB,
+      timeoutMs: this.options.autoStopMs,
+      idleTimeoutMs: this.options.idleTimeoutMs,
+      workdir: this.workingDir,
+      command: this.options.provider?.command ?? ["sleep", "infinity"],
+      env: this.getMergedEnv(),
+      encryptedPorts: this.options.provider?.encryptedPorts,
+      unencryptedPorts,
+      verbose: this.options.provider?.verbose
+    });
+    await sandbox.setTags(this.getTags());
+    this.sandbox = sandbox;
+  }
+  /**
+   * Modal requires ports to be declared at sandbox creation time — a running
+   * sandbox cannot gain new tunnels. To make `openPort` work predictably
+   * across providers, we pre-declare all well-known agent-harness ports on
+   * every Modal sandbox we create, unless the caller has explicitly pinned
+   * them to a specific (possibly empty) list.
+   */
+  resolveDefaultUnencryptedPorts() {
+    const declared = this.options.provider?.unencryptedPorts;
+    const encrypted = new Set(this.options.provider?.encryptedPorts ?? []);
+    const reserved = collectAllAgentReservedPorts().filter(
+      (port) => !encrypted.has(port)
+    );
+    if (declared === void 0) {
+      return reserved.length > 0 ? reserved : void 0;
+    }
+    const merged = new Set(declared);
+    for (const port of reserved) {
+      merged.add(port);
+    }
+    return Array.from(merged);
+  }
+  async run(command, options) {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    const process2 = await sandbox.exec(
+      ["/bin/sh", "-lc", toShellCommand(command)],
+      {
+        workdir: options?.cwd ?? this.workingDir,
+        timeoutMs: options?.timeoutMs,
+        env: this.getMergedEnv(options?.env),
+        pty: options?.pty,
+        mode: "text"
+      }
+    );
+    const [stdout, stderr, exitCode] = await Promise.all([
+      readStreamAsText(process2.stdout),
+      readStreamAsText(process2.stderr),
+      process2.wait()
+    ]);
+    return {
+      exitCode,
+      stdout,
+      stderr,
+      combinedOutput: `${stdout}${stderr}`,
+      raw: process2
+    };
+  }
+  async runAsync(command, options) {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    const process2 = await sandbox.exec(
+      ["/bin/sh", "-lc", toShellCommand(command)],
+      {
+        workdir: options?.cwd ?? this.workingDir,
+        timeoutMs: options?.timeoutMs,
+        env: this.getMergedEnv(options?.env),
+        pty: options?.pty,
+        mode: "text"
+      }
+    );
+    const queue = new AsyncQueue();
+    let stdout = "";
+    let stderr = "";
+    const stdoutPump = pipeReadableStream(process2.stdout, (chunk) => {
+      stdout += chunk;
+      queue.push({
+        type: "stdout",
+        chunk,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+    const stderrPump = pipeReadableStream(process2.stderr, (chunk) => {
+      stderr += chunk;
+      queue.push({
+        type: "stderr",
+        chunk,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+    const completion = Promise.all([stdoutPump, stderrPump, process2.wait()]).then(([, , exitCode]) => {
+      queue.push({
+        type: "exit",
+        exitCode,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      queue.finish();
+      return {
+        exitCode,
+        stdout,
+        stderr,
+        combinedOutput: `${stdout}${stderr}`,
+        raw: process2
+      };
+    }).catch((error) => {
+      queue.fail(error);
+      throw error;
+    });
+    suppressUnhandledRejection(completion);
+    return {
+      id: `${sandbox.sandboxId}:${Date.now()}`,
+      raw: process2,
+      write: async (input) => {
+        await process2.stdin.writeText(input);
+      },
+      wait: () => completion,
+      kill: async () => {
+        try {
+          await process2.stdin.writeText("");
+        } catch {
+        }
+      },
+      [Symbol.asyncIterator]: () => queue[Symbol.asyncIterator]()
+    };
+  }
+  async list(options) {
+    const sandboxes = [];
+    for await (const sandbox of this.client.sandboxes.list({
+      tags: options?.tags ?? this.tags
+    })) {
+      sandboxes.push({
+        provider: this.provider,
+        id: sandbox.sandboxId,
+        state: await sandbox.poll() === null ? "running" : "finished",
+        tags: await sandbox.getTags(),
+        raw: sandbox
+      });
+    }
+    return sandboxes;
+  }
+  async snapshot() {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    const image = await sandbox.snapshotFilesystem();
+    return image.imageId;
+  }
+  async stop() {
+    const sandbox = this.sandbox;
+    if (!sandbox) {
+      return;
+    }
+    await sandbox.terminate();
+    this.sandbox = void 0;
+  }
+  async delete() {
+    await this.stop();
+    await this.closeClient();
+  }
+  async openPort(port) {
+    const provider = this.options.provider ?? (this.options.provider = {});
+    if (provider.encryptedPorts?.includes(port)) {
+      return;
+    }
+    const alreadyDeclared = provider.unencryptedPorts?.includes(port) ?? false;
+    if (!alreadyDeclared) {
+      provider.unencryptedPorts = [...provider.unencryptedPorts ?? [], port];
+    }
+    if (!this.sandbox) {
+      return;
+    }
+    try {
+      const tunnels = await this.sandbox.tunnels();
+      if (tunnels[port]) {
+        return;
+      }
+    } catch {
+      return;
+    }
+    throw new Error(
+      `Modal sandbox is already running and cannot expose port ${port} dynamically. Declare it at creation time via \`provider.unencryptedPorts\` (e.g. \`provider: { unencryptedPorts: [${port}] }\`) or use \`AGENT_RESERVED_PORTS\` / \`collectAllAgentReservedPorts()\` from agentbox-sdk to pre-declare the agent harness ports.`
+    );
+  }
+  async getPreviewLink(port) {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    const tunnels = await sandbox.tunnels();
+    const tunnel = tunnels[port];
+    if (!tunnel) {
+      throw new Error(`Modal sandbox does not expose port ${port}.`);
+    }
+    return tunnel.url;
+  }
+  async findMatchingSandbox() {
+    for await (const sandbox of this.client.sandboxes.list({
+      tags: this.getTags()
+    })) {
+      return sandbox;
+    }
+    return void 0;
+  }
+  getTags() {
+    return {
+      "agentbox.provider": this.provider,
+      ...this.options.tags ?? {}
+    };
+  }
+  async closeClient() {
+    if (this.clientClosed) {
+      return;
+    }
+    this.clientClosed = true;
+    const swallowGrpcShutdown = (reason) => {
+      if (reason instanceof Error && reason.message.includes("Channel has been shut down")) {
+        return;
+      }
+      throw reason;
+    };
+    process.on("unhandledRejection", swallowGrpcShutdown);
+    try {
+      this.client.close();
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    } catch {
+    } finally {
+      process.off("unhandledRejection", swallowGrpcShutdown);
+    }
+  }
+  requireSandbox() {
+    if (!this.sandbox) {
+      throw new Error("Modal sandbox has not been provisioned.");
+    }
+    return this.sandbox;
+  }
+  async resolveModalImage() {
+    const image = resolveSandboxImage(this.options.image);
+    if (!image) {
+      throw new Error(
+        "modal sandboxes require options.image to reference an existing Modal image id."
+      );
+    }
+    return this.client.images.fromId(image);
+  }
+};
+
+// src/sandboxes/providers/vercel.ts
+import { Sandbox as VercelSandbox } from "@vercel/sandbox";
+function pickFirstTag(tags) {
+  if (!tags) return void 0;
+  const entries = Object.entries(tags);
+  if (entries.length === 0) return void 0;
+  const [key, value] = entries[0];
+  return { [key]: value };
+}
+function matchesAllTags(candidateTags, required) {
+  return Object.entries(required).every(
+    ([key, value]) => candidateTags?.[key] === value
+  );
+}
+function describeVercelApiError(error, action) {
+  if (error && typeof error === "object" && "response" in error && error.response instanceof Response) {
+    const apiError = error;
+    const status = apiError.response.status;
+    const body = apiError.json !== void 0 ? JSON.stringify(apiError.json) : apiError.text ?? "";
+    return new Error(
+      `Vercel ${action} failed with HTTP ${status}: ${body || apiError.message}`
+    );
+  }
+  return error instanceof Error ? error : new Error(String(error));
+}
+async function wrapVercelApiError(action, fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    throw describeVercelApiError(error, action);
+  }
+}
+function buildTimeoutSignal(timeoutMs) {
+  if (!timeoutMs || timeoutMs <= 0) return void 0;
+  return AbortSignal.timeout(timeoutMs);
+}
+function getCredentials(options) {
+  const token = options.provider?.token ?? process.env.VERCEL_TOKEN;
+  const teamId = options.provider?.teamId ?? process.env.VERCEL_TEAM_ID;
+  const projectId = options.provider?.projectId ?? process.env.VERCEL_PROJECT_ID;
+  if (token && teamId && projectId) {
+    return { token, teamId, projectId };
+  }
+  return {};
+}
+var VercelSandboxAdapter = class extends SandboxAdapter {
+  sandbox;
+  get provider() {
+    return SandboxProvider.Vercel;
+  }
+  get raw() {
+    return { sandbox: this.sandbox };
+  }
+  get id() {
+    return this.sandbox?.name;
+  }
+  get workingDir() {
+    return this.options.workingDir ?? "/vercel/sandbox";
+  }
+  get previewHeaders() {
+    const token = this.options.provider?.protectionBypass;
+    return token ? { "x-vercel-protection-bypass": token } : {};
+  }
+  async provision() {
+    const existing = await this.findExistingSandbox();
+    if (existing) {
+      this.sandbox = existing;
+      return;
+    }
+    const credentials = getCredentials(this.options);
+    const provider = this.options.provider;
+    const snapshotId = provider?.snapshotId;
+    const timeout = provider?.timeoutMs ?? 12e4;
+    const runtime = provider?.runtime ?? "node24";
+    const resources = resolveSandboxResources(this.options.resources);
+    const vcpus = resources?.cpu ? { resources: { vcpus: resources.cpu } } : {};
+    const base = {
+      ...credentials,
+      timeout,
+      env: this.getMergedEnv(),
+      ...vcpus,
+      tags: this.getTags(),
+      ...provider?.ports?.length ? { ports: provider.ports } : {}
+    };
+    const sandbox = await wrapVercelApiError("create sandbox", () => {
+      if (snapshotId) {
+        return VercelSandbox.create({
+          ...base,
+          source: { type: "snapshot", snapshotId }
+        });
+      }
+      if (provider?.gitSource) {
+        const git = provider.gitSource;
+        const source = {
+          type: "git",
+          url: git.url,
+          depth: git.depth,
+          revision: git.revision,
+          ...git.username && git.password ? { username: git.username, password: git.password } : {}
+        };
+        return VercelSandbox.create({ ...base, runtime, source });
+      }
+      return VercelSandbox.create({ ...base, runtime });
+    });
+    this.sandbox = sandbox;
+    if (this.workingDir !== "/vercel/sandbox") {
+      await wrapVercelApiError(
+        "create working directory",
+        () => sandbox.runCommand({
+          cmd: "mkdir",
+          args: ["-p", this.workingDir],
+          sudo: true
+        })
+      );
+    }
+  }
+  async run(command, options) {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    const signal = buildTimeoutSignal(options?.timeoutMs);
+    const result = await wrapVercelApiError(
+      "run command",
+      () => sandbox.runCommand({
+        cmd: "sh",
+        args: ["-lc", toShellCommand(command)],
+        cwd: options?.cwd ?? this.workingDir,
+        env: this.getMergedEnv(options?.env),
+        ...signal ? { signal } : {}
+      })
+    );
+    const [stdout, stderr] = await Promise.all([
+      result.stdout(),
+      result.stderr()
+    ]);
+    return {
+      exitCode: result.exitCode,
+      stdout,
+      stderr,
+      combinedOutput: `${stdout}${stderr}`,
+      raw: result
+    };
+  }
+  async runAsync(command, options) {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    const signal = buildTimeoutSignal(options?.timeoutMs);
+    const cmd = await wrapVercelApiError(
+      "start async command",
+      () => sandbox.runCommand({
+        cmd: "sh",
+        args: ["-lc", toShellCommand(command)],
+        cwd: options?.cwd ?? this.workingDir,
+        env: this.getMergedEnv(options?.env),
+        detached: true,
+        ...signal ? { signal } : {}
+      })
+    );
+    const queue = new AsyncQueue();
+    let stdout = "";
+    let stderr = "";
+    const completion = (async () => {
+      for await (const log of cmd.logs()) {
+        if (log.stream === "stdout") {
+          stdout += log.data;
+          queue.push({
+            type: "stdout",
+            chunk: log.data,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        } else {
+          stderr += log.data;
+          queue.push({
+            type: "stderr",
+            chunk: log.data,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      }
+      const finished2 = await cmd.wait();
+      const exitCode = finished2.exitCode;
+      queue.push({
+        type: "exit",
+        exitCode,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      queue.finish();
+      return {
+        exitCode,
+        stdout,
+        stderr,
+        combinedOutput: `${stdout}${stderr}`,
+        raw: finished2
+      };
+    })().catch((error) => {
+      queue.fail(error);
+      throw error;
+    });
+    suppressUnhandledRejection(completion);
+    return {
+      id: cmd.cmdId,
+      raw: cmd,
+      wait: () => completion,
+      kill: async () => {
+        await cmd.kill();
+      },
+      [Symbol.asyncIterator]: () => queue[Symbol.asyncIterator]()
+    };
+  }
+  async list(options) {
+    const filterTags = options?.tags ?? this.getTags();
+    const sandboxes = await this.listSandboxesByTags(filterTags);
+    return sandboxes.map(
+      (s) => ({
+        provider: this.provider,
+        id: s.name,
+        state: s.status,
+        tags: s.tags ?? {},
+        createdAt: new Date(s.createdAt).toISOString(),
+        raw: s
+      })
+    );
+  }
+  async snapshot() {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    const snap = await wrapVercelApiError(
+      "snapshot sandbox",
+      () => sandbox.snapshot()
+    );
+    return snap.snapshotId;
+  }
+  async stop() {
+    const sandbox = this.sandbox;
+    if (!sandbox) {
+      return;
+    }
+    await wrapVercelApiError("stop sandbox", () => sandbox.stop());
+    this.sandbox = void 0;
+  }
+  async delete() {
+    await this.stop();
+  }
+  async openPort(_port) {
+    void _port;
+  }
+  async getPreviewLink(port) {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    return sandbox.domain(port);
+  }
+  async uploadFile(content, targetPath) {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    const data = typeof content === "string" ? content : new Uint8Array(content);
+    await sandbox.writeFiles([{ path: targetPath, content: data }]);
+  }
+  async downloadFile(sourcePath) {
+    await this.ensureProvisioned();
+    const sandbox = this.requireSandbox();
+    const result = await sandbox.readFileToBuffer({ path: sourcePath });
+    if (!result) {
+      throw new Error(`File not found in Vercel sandbox: ${sourcePath}`);
+    }
+    return result;
+  }
+  getTags() {
+    return {
+      "agentbox.provider": this.provider,
+      ...this.options.tags ?? {}
+    };
+  }
+  async listSandboxesByTags(tags) {
+    const credentials = getCredentials(this.options);
+    const result = await wrapVercelApiError(
+      "list sandboxes",
+      () => VercelSandbox.list({
+        ...credentials,
+        tags: pickFirstTag(tags)
+      })
+    );
+    return result.sandboxes.filter(
+      (s) => matchesAllTags(s.tags, tags)
+    );
+  }
+  async findExistingSandbox() {
+    const credentials = getCredentials(this.options);
+    const sandboxes = await this.listSandboxesByTags(this.getTags());
+    const match = sandboxes.find((s) => s.status === "running");
+    if (!match) {
+      return void 0;
+    }
+    return wrapVercelApiError(
+      "get sandbox",
+      () => VercelSandbox.get({ ...credentials, name: match.name })
+    );
+  }
+  requireSandbox() {
+    if (!this.sandbox) {
+      throw new Error("Vercel sandbox has not been provisioned.");
+    }
+    return this.sandbox;
+  }
+};
+
+// src/sandboxes/Sandbox.ts
+function createSandboxAdapter(provider, options) {
+  switch (provider) {
+    case SandboxProvider.LocalDocker:
+      return new LocalDockerSandboxAdapter(
+        options
+      );
+    case SandboxProvider.Modal:
+      return new ModalSandboxAdapter(
+        options
+      );
+    case SandboxProvider.Daytona:
+      return new DaytonaSandboxAdapter(
+        options
+      );
+    case SandboxProvider.Vercel:
+      return new VercelSandboxAdapter(
+        options
+      );
+    case SandboxProvider.E2B:
+      return new E2bSandboxAdapter(
+        options
+      );
+    default:
+      throw new UnsupportedProviderError("sandbox", provider);
+  }
+}
+var Sandbox = class {
+  constructor(providerName, options) {
+    this.providerName = providerName;
+    this.options = options;
+    this.adapter = createSandboxAdapter(providerName, options);
+  }
+  providerName;
+  options;
+  adapter;
+  get provider() {
+    return this.providerName;
+  }
+  get optionsSnapshot() {
+    return this.options;
+  }
+  get id() {
+    return this.adapter.id;
+  }
+  get raw() {
+    return this.adapter.raw;
+  }
+  async openPort(port) {
+    await this.adapter.openPort(port);
+    return this;
+  }
+  setSecret(name, value) {
+    this.adapter.setSecret(name, value);
+    return this;
+  }
+  setSecrets(values) {
+    this.adapter.setSecrets(values);
+    return this;
+  }
+  async gitClone(options) {
+    return this.adapter.gitClone(options);
+  }
+  async run(command, options) {
+    return this.adapter.run(command, options);
+  }
+  async runAsync(command, options) {
+    return this.adapter.runAsync(command, options);
+  }
+  async list(options) {
+    return this.adapter.list(options);
+  }
+  async snapshot() {
+    return this.adapter.snapshot();
+  }
+  async stop() {
+    return this.adapter.stop();
+  }
+  async delete() {
+    return this.adapter.delete();
+  }
+  async getPreviewLink(port) {
+    return this.adapter.getPreviewLink(port);
+  }
+  get previewHeaders() {
+    return this.adapter.previewHeaders;
+  }
+  async uploadFile(content, targetPath) {
+    return this.adapter.uploadFile(content, targetPath);
+  }
+  async downloadFile(sourcePath) {
+    return this.adapter.downloadFile(sourcePath);
+  }
+};
+
+export {
+  buildGitCloneCommand,
+  SandboxAdapter,
+  Sandbox
+};