@hasna/sandboxes 0.1.24 → 0.1.25

package/dist/mcp/index.js

@@ -842,9 +842,11 @@ var cliSecretResolver = async (key) => {
 };
 
 // src/mcp/index.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
 // node_modules/@hasna/cloud/dist/index.js
 import { createRequire } from "module";
 import { Database } from "bun:sqlite";
@@ -16111,7 +16113,7 @@ function getPackageVersion() {
   return cachedVersion;
 }
 
-// src/mcp/index.ts
+// src/mcp/server.ts
 var E2B_COST_PER_SECOND = 0.000014;
 var DAYTONA_COST_PER_SECOND = 0.00001;
 function estimateCost(providerName, startedAt) {
@@ -16173,751 +16175,851 @@ var TOOL_CATALOG = [
   { name: "watch_file", description: "Get new content from a file since a previous read (tail -f equivalent)" },
   { name: "list_images", description: "List available pre-warmed sandbox image aliases" }
 ];
-var server = new McpServer({
-  name: "sandboxes",
-  version: getPackageVersion()
-});
-server.tool("create_sandbox", "Create a new sandbox", {
-  provider: exports_external2.string().optional().describe("Provider name (e2b, daytona, modal)"),
-  image: exports_external2.string().optional().describe("Container image"),
-  timeout: exports_external2.number().optional().describe("Timeout in seconds"),
-  name: exports_external2.string().optional().describe("Sandbox name"),
-  env_vars: exports_external2.record(exports_external2.string()).optional().describe("Environment variables"),
-  template_id: exports_external2.string().optional().describe("Template ID to base this sandbox on"),
-  on_timeout: exports_external2.enum(["pause", "terminate"]).optional().describe("What to do on timeout: pause (saves state) or terminate"),
-  auto_resume: exports_external2.boolean().optional().describe("Auto-resume paused sandbox on next connect"),
-  snapshot_id: exports_external2.string().optional().describe("Snapshot ID to restore from"),
-  network: exports_external2.enum(["full", "restricted", "none"]).optional().describe("Network access policy for the sandbox"),
-  budget_limit_usd: exports_external2.number().optional().describe("Auto-terminate sandbox if compute cost exceeds this USD amount"),
-  on_budget_exceeded: exports_external2.enum(["terminate", "pause", "notify"]).optional().describe("Action when budget limit is reached (default: terminate)")
-}, async (params) => {
-  let sandboxId;
-  try {
-    const providerName = params.provider ?? getDefaultProvider();
-    const timeout = params.timeout ?? getDefaultTimeout();
-    let templateData = {};
-    if (params.template_id) {
-      const tmpl = getTemplate(params.template_id);
-      templateData = { image: tmpl.image ?? undefined, env_vars: tmpl.env_vars, setup_script: tmpl.setup_script };
-    }
-    const rawImage = params.image ?? templateData.image;
-    const resolvedImage = rawImage ? resolveImage(rawImage) : rawImage;
-    const builtinSetupScript = rawImage ? getBuiltinImageSetupScript(rawImage) : undefined;
-    const envVars = { ...templateData.env_vars, ...params.env_vars };
-    const onTimeout = params.on_timeout ?? "terminate";
-    const autoResume = params.auto_resume ?? false;
-    const sandbox = createSandbox({
-      provider: providerName,
-      image: resolvedImage,
-      timeout,
-      name: params.name,
-      env_vars: envVars,
-      on_timeout: onTimeout,
-      auto_resume: autoResume,
-      template_id: params.template_id,
-      config: { network: params.network ?? "full" },
-      budget_limit_usd: params.budget_limit_usd,
-      on_budget_exceeded: params.on_budget_exceeded
-    });
-    sandboxId = sandbox.id;
-    const provider = await getProvider(providerName);
-    if (params.snapshot_id) {
-      const snapshot = getSnapshot(params.snapshot_id);
-      await provider.resume(snapshot.provider_sandbox_id);
-      const updated2 = updateSandbox(sandbox.id, {
-        provider_sandbox_id: snapshot.provider_sandbox_id,
-        status: "running"
+var MCP_NAME = "sandboxes";
+function buildServer() {
+  const server = new McpServer({
+    name: MCP_NAME,
+    version: getPackageVersion()
+  });
+  server.tool("create_sandbox", "Create a new sandbox", {
+    provider: exports_external2.string().optional().describe("Provider name (e2b, daytona, modal)"),
+    image: exports_external2.string().optional().describe("Container image"),
+    timeout: exports_external2.number().optional().describe("Timeout in seconds"),
+    name: exports_external2.string().optional().describe("Sandbox name"),
+    env_vars: exports_external2.record(exports_external2.string()).optional().describe("Environment variables"),
+    template_id: exports_external2.string().optional().describe("Template ID to base this sandbox on"),
+    on_timeout: exports_external2.enum(["pause", "terminate"]).optional().describe("What to do on timeout: pause (saves state) or terminate"),
+    auto_resume: exports_external2.boolean().optional().describe("Auto-resume paused sandbox on next connect"),
+    snapshot_id: exports_external2.string().optional().describe("Snapshot ID to restore from"),
+    network: exports_external2.enum(["full", "restricted", "none"]).optional().describe("Network access policy for the sandbox"),
+    budget_limit_usd: exports_external2.number().optional().describe("Auto-terminate sandbox if compute cost exceeds this USD amount"),
+    on_budget_exceeded: exports_external2.enum(["terminate", "pause", "notify"]).optional().describe("Action when budget limit is reached (default: terminate)")
+  }, async (params) => {
+    let sandboxId;
+    try {
+      const providerName = params.provider ?? getDefaultProvider();
+      const timeout = params.timeout ?? getDefaultTimeout();
+      let templateData = {};
+      if (params.template_id) {
+        const tmpl = getTemplate(params.template_id);
+        templateData = { image: tmpl.image ?? undefined, env_vars: tmpl.env_vars, setup_script: tmpl.setup_script };
+      }
+      const rawImage = params.image ?? templateData.image;
+      const resolvedImage = rawImage ? resolveImage(rawImage) : rawImage;
+      const builtinSetupScript = rawImage ? getBuiltinImageSetupScript(rawImage) : undefined;
+      const envVars = { ...templateData.env_vars, ...params.env_vars };
+      const onTimeout = params.on_timeout ?? "terminate";
+      const autoResume = params.auto_resume ?? false;
+      const sandbox = createSandbox({
+        provider: providerName,
+        image: resolvedImage,
+        timeout,
+        name: params.name,
+        env_vars: envVars,
+        on_timeout: onTimeout,
+        auto_resume: autoResume,
+        template_id: params.template_id,
+        config: { network: params.network ?? "full" },
+        budget_limit_usd: params.budget_limit_usd,
+        on_budget_exceeded: params.on_budget_exceeded
       });
-      emitLifecycleEvent(sandbox.id, `Sandbox restored from snapshot ${snapshot.id}`);
-      return ok(updated2);
-    }
-    const result = await provider.create({
-      image: resolvedImage,
-      timeout,
-      envVars,
-      onTimeout,
-      autoResume
-    });
-    const updated = updateSandbox(sandbox.id, {
-      provider_sandbox_id: result.id,
-      status: "running",
-      started_at: new Date().toISOString()
-    });
-    emitLifecycleEvent(sandbox.id, "sandbox created");
-    if (templateData.setup_script && result.id) {
-      try {
-        await provider.exec(result.id, templateData.setup_script);
-      } catch {}
+      sandboxId = sandbox.id;
+      const provider = await getProvider(providerName);
+      if (params.snapshot_id) {
+        const snapshot = getSnapshot(params.snapshot_id);
+        await provider.resume(snapshot.provider_sandbox_id);
+        const updated2 = updateSandbox(sandbox.id, {
+          provider_sandbox_id: snapshot.provider_sandbox_id,
+          status: "running"
+        });
+        emitLifecycleEvent(sandbox.id, `Sandbox restored from snapshot ${snapshot.id}`);
+        return ok(updated2);
+      }
+      const result = await provider.create({
+        image: resolvedImage,
+        timeout,
+        envVars,
+        onTimeout,
+        autoResume
+      });
+      const updated = updateSandbox(sandbox.id, {
+        provider_sandbox_id: result.id,
+        status: "running",
+        started_at: new Date().toISOString()
+      });
+      emitLifecycleEvent(sandbox.id, "sandbox created");
+      if (templateData.setup_script && result.id) {
+        try {
+          await provider.exec(result.id, templateData.setup_script);
+        } catch {}
+      }
+      if (builtinSetupScript && result.id) {
+        try {
+          await provider.exec(result.id, builtinSetupScript);
+        } catch {}
+      }
+      return ok(updated);
+    } catch (e) {
+      if (sandboxId) {
+        finalizeSandboxProvisionFailure(sandboxId, e);
+      }
+      return err(e);
     }
-    if (builtinSetupScript && result.id) {
-      try {
-        await provider.exec(result.id, builtinSetupScript);
-      } catch {}
+  });
+  server.tool("get_sandbox", "Get sandbox details by ID", {
+    id: exports_external2.string().describe("Sandbox ID or partial ID")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.id);
+      const cost = estimateCost(sandbox.provider, sandbox.started_at);
+      return ok({ ...sandbox, ...cost });
+    } catch (e) {
+      return err(e);
     }
-    return ok(updated);
-  } catch (e) {
-    if (sandboxId) {
-      finalizeSandboxProvisionFailure(sandboxId, e);
+  });
+  server.tool("list_sandboxes", "List sandboxes with filters", {
+    status: exports_external2.string().optional().describe("Filter by status"),
+    provider: exports_external2.string().optional().describe("Filter by provider")
+  }, async (params) => {
+    try {
+      const sandboxes = listSandboxes({
+        status: params.status,
+        provider: params.provider
+      });
+      return ok(sandboxes.map((s) => ({ ...s, ...estimateCost(s.provider, s.started_at) })));
+    } catch (e) {
+      return err(e);
     }
-    return err(e);
-  }
-});
-server.tool("get_sandbox", "Get sandbox details by ID", {
-  id: exports_external2.string().describe("Sandbox ID or partial ID")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.id);
-    const cost = estimateCost(sandbox.provider, sandbox.started_at);
-    return ok({ ...sandbox, ...cost });
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("list_sandboxes", "List sandboxes with filters", {
-  status: exports_external2.string().optional().describe("Filter by status"),
-  provider: exports_external2.string().optional().describe("Filter by provider")
-}, async (params) => {
-  try {
-    const sandboxes = listSandboxes({
-      status: params.status,
-      provider: params.provider
-    });
-    return ok(sandboxes.map((s) => ({ ...s, ...estimateCost(s.provider, s.started_at) })));
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("delete_sandbox", "Delete a sandbox", {
-  id: exports_external2.string().describe("Sandbox ID or partial ID")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.id);
-    if (sandbox.provider_sandbox_id) {
+  });
+  server.tool("delete_sandbox", "Delete a sandbox", {
+    id: exports_external2.string().describe("Sandbox ID or partial ID")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.id);
+      if (sandbox.provider_sandbox_id) {
+        const provider = await getProvider(sandbox.provider);
+        await provider.delete(sandbox.provider_sandbox_id);
+      }
+      deleteSandbox(sandbox.id);
+      emitLifecycleEvent(sandbox.id, "sandbox deleted");
+      return ok({ deleted: sandbox.id });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("stop_sandbox", "Stop a running sandbox", {
+    id: exports_external2.string().describe("Sandbox ID or partial ID")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.id);
+      if (!sandbox.provider_sandbox_id)
+        throw new Error("Sandbox has no provider ID");
       const provider = await getProvider(sandbox.provider);
-      await provider.delete(sandbox.provider_sandbox_id);
+      await provider.stop(sandbox.provider_sandbox_id);
+      const updated = updateSandbox(sandbox.id, { status: "stopped" });
+      emitLifecycleEvent(sandbox.id, "sandbox stopped");
+      return ok(updated);
+    } catch (e) {
+      return err(e);
     }
-    deleteSandbox(sandbox.id);
-    emitLifecycleEvent(sandbox.id, "sandbox deleted");
-    return ok({ deleted: sandbox.id });
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("stop_sandbox", "Stop a running sandbox", {
-  id: exports_external2.string().describe("Sandbox ID or partial ID")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.id);
-    if (!sandbox.provider_sandbox_id)
-      throw new Error("Sandbox has no provider ID");
-    const provider = await getProvider(sandbox.provider);
-    await provider.stop(sandbox.provider_sandbox_id);
-    const updated = updateSandbox(sandbox.id, { status: "stopped" });
-    emitLifecycleEvent(sandbox.id, "sandbox stopped");
-    return ok(updated);
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("keep_alive", "Extend sandbox lifetime", {
-  sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
-  duration_seconds: exports_external2.number().optional().describe("Duration in seconds (default 300)")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.sandbox_id);
-    if (!sandbox.provider_sandbox_id)
-      throw new Error("Sandbox has no provider ID");
-    const provider = await getProvider(sandbox.provider);
-    const durationMs = (params.duration_seconds ?? 300) * 1000;
-    await provider.keepAlive(sandbox.provider_sandbox_id, durationMs);
-    return ok({ kept_alive: sandbox.id, duration_seconds: params.duration_seconds ?? 300 });
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("exec_command", "Execute a command in a sandbox", {
-  sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
-  command: exports_external2.string().describe("Command to execute"),
-  background: exports_external2.boolean().optional().describe("Run in background"),
-  env_vars: exports_external2.record(exports_external2.string()).optional().describe("Per-call environment variables (merged with sandbox env_vars, not persisted)"),
-  stdin: exports_external2.string().optional().describe("String to pipe as stdin to the command"),
-  tty: exports_external2.boolean().optional().describe("Allocate a TTY for the session (best-effort)")
-}, async (params) => {
-  let sessionId;
-  try {
-    const sandbox = getSandbox(params.sandbox_id);
-    if (!sandbox.provider_sandbox_id)
-      throw new Error("Sandbox has no provider ID");
-    const session = createSession({
-      sandbox_id: sandbox.id,
-      command: params.command
-    });
-    sessionId = session.id;
-    const collector = createStreamCollector(sandbox.id, session.id);
-    const provider = await getProvider(sandbox.provider);
-    const callEnv = { ...sandbox.env_vars, ...params.env_vars };
-    const env = Object.keys(callEnv).length > 0 ? callEnv : undefined;
-    const needsShell = /<<\s*['"]?[A-Z]+['"]?/.test(params.command);
-    const effectiveCommand = needsShell ? `bash -c ${JSON.stringify(params.command)}` : params.command;
-    if (params.background) {
-      provider.exec(sandbox.provider_sandbox_id, effectiveCommand, {
+  });
+  server.tool("keep_alive", "Extend sandbox lifetime", {
+    sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
+    duration_seconds: exports_external2.number().optional().describe("Duration in seconds (default 300)")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.sandbox_id);
+      if (!sandbox.provider_sandbox_id)
+        throw new Error("Sandbox has no provider ID");
+      const provider = await getProvider(sandbox.provider);
+      const durationMs = (params.duration_seconds ?? 300) * 1000;
+      await provider.keepAlive(sandbox.provider_sandbox_id, durationMs);
+      return ok({ kept_alive: sandbox.id, duration_seconds: params.duration_seconds ?? 300 });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("exec_command", "Execute a command in a sandbox", {
+    sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
+    command: exports_external2.string().describe("Command to execute"),
+    background: exports_external2.boolean().optional().describe("Run in background"),
+    env_vars: exports_external2.record(exports_external2.string()).optional().describe("Per-call environment variables (merged with sandbox env_vars, not persisted)"),
+    stdin: exports_external2.string().optional().describe("String to pipe as stdin to the command"),
+    tty: exports_external2.boolean().optional().describe("Allocate a TTY for the session (best-effort)")
+  }, async (params) => {
+    let sessionId;
+    try {
+      const sandbox = getSandbox(params.sandbox_id);
+      if (!sandbox.provider_sandbox_id)
+        throw new Error("Sandbox has no provider ID");
+      const session = createSession({
+        sandbox_id: sandbox.id,
+        command: params.command
+      });
+      sessionId = session.id;
+      const collector = createStreamCollector(sandbox.id, session.id);
+      const provider = await getProvider(sandbox.provider);
+      const callEnv = { ...sandbox.env_vars, ...params.env_vars };
+      const env = Object.keys(callEnv).length > 0 ? callEnv : undefined;
+      const needsShell = /<<\s*['"]?[A-Z]+['"]?/.test(params.command);
+      const effectiveCommand = needsShell ? `bash -c ${JSON.stringify(params.command)}` : params.command;
+      if (params.background) {
+        provider.exec(sandbox.provider_sandbox_id, effectiveCommand, {
+          onStdout: collector.onStdout,
+          onStderr: collector.onStderr,
+          env,
+          stdin: params.stdin,
+          tty: params.tty
+        }).then((res) => {
+          const r = res;
+          finalizeSessionExit(session.id, r.exit_code ?? 0);
+        }).catch(() => {
+          finalizeSessionFailure(session.id);
+        });
+        return ok({
+          session_id: session.id,
+          background: true,
+          message: "Command started in background. Use get_session to check completion status and exit_code. Use bg_wait_session to block until done."
+        });
+      }
+      const result = await provider.exec(sandbox.provider_sandbox_id, effectiveCommand, {
         onStdout: collector.onStdout,
         onStderr: collector.onStderr,
         env,
         stdin: params.stdin,
         tty: params.tty
-      }).then((res) => {
-        const r = res;
-        finalizeSessionExit(session.id, r.exit_code ?? 0);
-      }).catch(() => {
-        finalizeSessionFailure(session.id);
       });
+      const execResult = result;
+      finalizeSessionExit(session.id, execResult.exit_code);
       return ok({
         session_id: session.id,
-        background: true,
-        message: "Command started in background. Use get_session to check completion status and exit_code. Use bg_wait_session to block until done."
+        exit_code: execResult.exit_code,
+        stdout: execResult.stdout,
+        stderr: execResult.stderr
       });
+    } catch (e) {
+      if (sessionId) {
+        finalizeSessionFailure(sessionId, e);
+      }
+      return err(e);
     }
-    const result = await provider.exec(sandbox.provider_sandbox_id, effectiveCommand, {
-      onStdout: collector.onStdout,
-      onStderr: collector.onStderr,
-      env,
-      stdin: params.stdin,
-      tty: params.tty
-    });
-    const execResult = result;
-    finalizeSessionExit(session.id, execResult.exit_code);
-    return ok({
-      session_id: session.id,
-      exit_code: execResult.exit_code,
-      stdout: execResult.stdout,
-      stderr: execResult.stderr
-    });
-  } catch (e) {
-    if (sessionId) {
-      finalizeSessionFailure(sessionId, e);
+  });
+  server.tool("read_file", "Read a file from a sandbox", {
+    sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
+    path: exports_external2.string().describe("File path"),
+    offset: exports_external2.number().optional().describe("Line or byte offset to start reading from"),
+    limit: exports_external2.number().optional().describe("Max lines or bytes to return"),
+    encoding: exports_external2.enum(["utf8", "base64", "hex"]).optional().describe("Output encoding (default: utf8)")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.sandbox_id);
+      if (!sandbox.provider_sandbox_id)
+        throw new Error("Sandbox has no provider ID");
+      const provider = await getProvider(sandbox.provider);
+      const content = await provider.readFile(sandbox.provider_sandbox_id, params.path, {
+        encoding: params.encoding,
+        offset: params.offset,
+        limit: params.limit
+      });
+      return ok({ path: params.path, content, encoding: params.encoding ?? "utf8" });
+    } catch (e) {
+      return err(e);
     }
-    return err(e);
-  }
-});
-server.tool("read_file", "Read a file from a sandbox", {
-  sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
-  path: exports_external2.string().describe("File path"),
-  offset: exports_external2.number().optional().describe("Line or byte offset to start reading from"),
-  limit: exports_external2.number().optional().describe("Max lines or bytes to return"),
-  encoding: exports_external2.enum(["utf8", "base64", "hex"]).optional().describe("Output encoding (default: utf8)")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.sandbox_id);
-    if (!sandbox.provider_sandbox_id)
-      throw new Error("Sandbox has no provider ID");
-    const provider = await getProvider(sandbox.provider);
-    const content = await provider.readFile(sandbox.provider_sandbox_id, params.path, {
-      encoding: params.encoding,
-      offset: params.offset,
-      limit: params.limit
-    });
-    return ok({ path: params.path, content, encoding: params.encoding ?? "utf8" });
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("write_file", "Write a file to a sandbox", {
-  sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
-  path: exports_external2.string().describe("File path"),
-  content: exports_external2.string().describe("File content")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.sandbox_id);
-    if (!sandbox.provider_sandbox_id)
-      throw new Error("Sandbox has no provider ID");
-    const provider = await getProvider(sandbox.provider);
-    await provider.writeFile(sandbox.provider_sandbox_id, params.path, params.content);
-    return ok({ path: params.path, written: true });
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("list_files", "List files in a sandbox directory", {
-  sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
-  path: exports_external2.string().describe("Directory path"),
-  recursive: exports_external2.boolean().optional().describe("List files recursively"),
-  glob: exports_external2.string().optional().describe("Glob pattern to filter files")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.sandbox_id);
-    if (!sandbox.provider_sandbox_id)
-      throw new Error("Sandbox has no provider ID");
-    const provider = await getProvider(sandbox.provider);
-    const files = await provider.listFiles(sandbox.provider_sandbox_id, params.path, {
-      recursive: params.recursive,
-      glob: params.glob
-    });
-    return ok(files);
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("upload_dir", "Upload a local directory into a sandbox as a single archive (fast, no git clone)", {
-  sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
-  local_dir: exports_external2.string().describe("Local directory path on the host to upload"),
-  remote_dir: exports_external2.string().describe("Destination directory inside the sandbox"),
-  exclude: exports_external2.array(exports_external2.string()).optional().describe("Patterns to exclude (defaults to node_modules, .git, dist, \u2026)")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.sandbox_id);
-    if (!sandbox.provider_sandbox_id)
-      throw new Error("Sandbox has no provider ID");
-    const provider = await getProvider(sandbox.provider);
-    const result = await provider.uploadDir(sandbox.provider_sandbox_id, params.local_dir, params.remote_dir, params.exclude ? { exclude: params.exclude } : undefined);
-    return ok({
-      local_dir: params.local_dir,
-      remote_dir: params.remote_dir,
-      bytes: result.bytes
-    });
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("get_session", "Get session details and exit code (useful for polling background command results)", {
-  session_id: exports_external2.string().describe("Session ID")
-}, async (params) => {
-  try {
-    const session = getSession(params.session_id);
-    return ok(session);
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("bg_wait_session", "Wait (poll) for a background command session to complete. Returns exit_code, stdout, stderr when done. Use after exec_command with background:true.", {
-  session_id: exports_external2.string().describe("Session ID from exec_command background:true response"),
-  timeout_seconds: exports_external2.number().optional().describe("Max seconds to wait (default: 300)"),
-  poll_interval_ms: exports_external2.number().optional().describe("Poll interval in ms (default: 1000)")
-}, async (params) => {
-  try {
-    const timeoutMs = (params.timeout_seconds ?? 300) * 1000;
-    const pollMs = params.poll_interval_ms ?? 1000;
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
+  });
+  server.tool("write_file", "Write a file to a sandbox", {
+    sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
+    path: exports_external2.string().describe("File path"),
+    content: exports_external2.string().describe("File content")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.sandbox_id);
+      if (!sandbox.provider_sandbox_id)
+        throw new Error("Sandbox has no provider ID");
+      const provider = await getProvider(sandbox.provider);
+      await provider.writeFile(sandbox.provider_sandbox_id, params.path, params.content);
+      return ok({ path: params.path, written: true });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("list_files", "List files in a sandbox directory", {
+    sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
+    path: exports_external2.string().describe("Directory path"),
+    recursive: exports_external2.boolean().optional().describe("List files recursively"),
+    glob: exports_external2.string().optional().describe("Glob pattern to filter files")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.sandbox_id);
+      if (!sandbox.provider_sandbox_id)
+        throw new Error("Sandbox has no provider ID");
+      const provider = await getProvider(sandbox.provider);
+      const files = await provider.listFiles(sandbox.provider_sandbox_id, params.path, {
+        recursive: params.recursive,
+        glob: params.glob
+      });
+      return ok(files);
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("upload_dir", "Upload a local directory into a sandbox as a single archive (fast, no git clone)", {
+    sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
+    local_dir: exports_external2.string().describe("Local directory path on the host to upload"),
+    remote_dir: exports_external2.string().describe("Destination directory inside the sandbox"),
+    exclude: exports_external2.array(exports_external2.string()).optional().describe("Patterns to exclude (defaults to node_modules, .git, dist, \u2026)")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.sandbox_id);
+      if (!sandbox.provider_sandbox_id)
+        throw new Error("Sandbox has no provider ID");
+      const provider = await getProvider(sandbox.provider);
+      const result = await provider.uploadDir(sandbox.provider_sandbox_id, params.local_dir, params.remote_dir, params.exclude ? { exclude: params.exclude } : undefined);
+      return ok({
+        local_dir: params.local_dir,
+        remote_dir: params.remote_dir,
+        bytes: result.bytes
+      });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("get_session", "Get session details and exit code (useful for polling background command results)", {
+    session_id: exports_external2.string().describe("Session ID")
+  }, async (params) => {
+    try {
       const session = getSession(params.session_id);
-      if (session.status === "completed" || session.status === "failed" || session.status === "killed") {
-        const events = listEvents({ session_id: session.id, limit: 1e4 });
-        const stdout = events.filter((e) => e.type === "stdout").map((e) => e.data).join("");
-        const stderr = events.filter((e) => e.type === "stderr").map((e) => e.data).join("");
-        return ok({
-          session_id: session.id,
-          status: session.status,
-          exit_code: session.exit_code ?? (session.status === "failed" || session.status === "killed" ? 1 : 0),
-          stdout,
-          stderr
-        });
+      return ok(session);
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("bg_wait_session", "Wait (poll) for a background command session to complete. Returns exit_code, stdout, stderr when done. Use after exec_command with background:true.", {
+    session_id: exports_external2.string().describe("Session ID from exec_command background:true response"),
+    timeout_seconds: exports_external2.number().optional().describe("Max seconds to wait (default: 300)"),
+    poll_interval_ms: exports_external2.number().optional().describe("Poll interval in ms (default: 1000)")
+  }, async (params) => {
+    try {
+      const timeoutMs = (params.timeout_seconds ?? 300) * 1000;
+      const pollMs = params.poll_interval_ms ?? 1000;
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        const session = getSession(params.session_id);
+        if (session.status === "completed" || session.status === "failed" || session.status === "killed") {
+          const events = listEvents({ session_id: session.id, limit: 1e4 });
+          const stdout = events.filter((e) => e.type === "stdout").map((e) => e.data).join("");
+          const stderr = events.filter((e) => e.type === "stderr").map((e) => e.data).join("");
+          return ok({
+            session_id: session.id,
+            status: session.status,
+            exit_code: session.exit_code ?? (session.status === "failed" || session.status === "killed" ? 1 : 0),
+            stdout,
+            stderr
+          });
+        }
+        await new Promise((r) => setTimeout(r, pollMs));
       }
-      await new Promise((r) => setTimeout(r, pollMs));
+      return err(`Session ${params.session_id} did not complete within ${params.timeout_seconds ?? 300}s`);
+    } catch (e) {
+      return err(e);
     }
-    return err(`Session ${params.session_id} did not complete within ${params.timeout_seconds ?? 300}s`);
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("get_logs", "Get sandbox/session event logs", {
-  sandbox_id: exports_external2.string().optional().describe("Filter by sandbox ID"),
-  session_id: exports_external2.string().optional().describe("Filter by session ID"),
-  limit: exports_external2.number().optional().describe("Max events to return")
-}, async (params) => {
-  try {
-    return ok(listEvents({
-      sandbox_id: params.sandbox_id,
-      session_id: params.session_id,
-      limit: params.limit
-    }));
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("register_agent", "Register an agent", {
-  name: exports_external2.string().describe("Agent name"),
-  description: exports_external2.string().optional().describe("Agent description")
-}, async (params) => {
-  try {
-    return ok(registerAgent({ name: params.name, description: params.description }));
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("list_agents", "List all registered agents", {}, async () => {
-  try {
-    return ok(listAgents());
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("heartbeat", "Update last_seen_at to signal agent is active. Call periodically during long tasks.", { agent_id: exports_external2.string().describe("Agent ID or name") }, async (params) => {
-  try {
-    return ok(heartbeatAgent(params.agent_id));
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("set_focus", "Set active project context for this agent session.", {
-  agent_id: exports_external2.string().describe("Agent ID or name"),
-  project_id: exports_external2.string().nullable().optional().describe("Project ID to focus on, or null to clear")
-}, async (params) => {
-  try {
-    return ok(setAgentFocus(params.agent_id, params.project_id ?? null));
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("register_project", "Register a project", {
-  name: exports_external2.string().describe("Project name"),
-  path: exports_external2.string().describe("Project path"),
-  description: exports_external2.string().optional().describe("Project description")
-}, async (params) => {
-  try {
-    return ok(ensureProject(params.name, params.path, params.description));
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("list_projects", "List all projects", {}, async () => {
-  try {
-    return ok(listProjects());
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("describe_tools", "List all available tools", {}, async () => {
-  try {
-    return ok(TOOL_CATALOG);
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("search_tools", "Search tools by keyword", {
-  query: exports_external2.string().describe("Search query")
-}, async (params) => {
-  try {
-    const q = params.query.toLowerCase();
-    const matches = TOOL_CATALOG.filter((t) => t.name.includes(q) || t.description.toLowerCase().includes(q));
-    return ok(matches);
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("run_agent", "Run an AI agent inside a sandbox", {
-  sandbox_id: exports_external2.string().describe("Sandbox ID"),
-  agent_type: exports_external2.enum(["claude", "codex", "gemini", "opencode", "pi", "takumi", "custom"]).describe("Agent type"),
-  prompt: exports_external2.string().describe("Prompt for the agent"),
-  agent_name: exports_external2.string().optional().describe("Agent name"),
-  command: exports_external2.string().optional().describe("Custom command (for 'custom' type)"),
-  env_vars: exports_external2.record(exports_external2.string()).optional().describe("Per-call environment variables (merged with sandbox env_vars, not persisted)"),
-  secrets: exports_external2.array(exports_external2.string()).optional().describe("Vault secrets to inject as env vars: array of 'ENV_NAME=vault/key' (resolved from @hasna/secrets at call time, never persisted)"),
-  webhook_url: exports_external2.string().optional().describe("URL to POST result to when agent finishes"),
-  webhook_events: exports_external2.array(exports_external2.enum(["start", "complete", "error"])).optional().describe("Which events to notify on (default: all)")
-}, async (params) => {
-  try {
-    let callEnvVars = params.env_vars;
-    if (params.secrets && params.secrets.length > 0) {
-      const { resolveSecretSpecs: resolveSecretSpecs2 } = await Promise.resolve().then(() => exports_secrets);
-      const secretEnv = await resolveSecretSpecs2(params.secrets);
-      callEnvVars = { ...secretEnv, ...params.env_vars };
-    }
-    const session = await runAgent(params.sandbox_id, {
-      agentType: params.agent_type,
-      prompt: params.prompt,
-      agentName: params.agent_name,
-      command: params.command,
-      callEnvVars,
-      webhookUrl: params.webhook_url,
-      webhookEvents: params.webhook_events
-    });
-    return ok({ session_id: session.id, status: session.status });
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("stop_agent", "Stop a running agent in a sandbox", {
-  sandbox_id: exports_external2.string().describe("Sandbox ID")
-}, async (params) => {
-  try {
-    await stopAgent(params.sandbox_id);
-    return ok({ stopped: true });
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("get_agent_output", "Get output from an agent session", {
-  sandbox_id: exports_external2.string().describe("Sandbox ID"),
-  session_id: exports_external2.string().optional().describe("Session ID"),
-  limit: exports_external2.number().optional().describe("Max events"),
-  offset: exports_external2.number().optional().describe("Skip first N events (for incremental polling)")
-}, async (params) => {
-  try {
-    const events = listEvents({
-      sandbox_id: params.sandbox_id,
-      session_id: params.session_id,
-      limit: params.limit || 100,
-      offset: params.offset
-    });
-    const stdout = events.filter((e) => e.type === "stdout").map((e) => e.data).join("");
-    const stderr = events.filter((e) => e.type === "stderr").map((e) => e.data).join("");
-    return ok({ stdout, stderr, event_count: events.length, next_offset: (params.offset ?? 0) + events.length });
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("pause_sandbox", "Pause a running sandbox, saving its state for later resume", {
-  id: exports_external2.string().describe("Sandbox ID or partial ID")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.id);
-    if (!sandbox.provider_sandbox_id)
-      throw new Error("Sandbox has no provider ID");
-    const provider = await getProvider(sandbox.provider);
-    await provider.pause(sandbox.provider_sandbox_id);
-    const updated = updateSandbox(sandbox.id, { status: "paused" });
-    emitLifecycleEvent(sandbox.id, "sandbox paused");
-    return ok(updated);
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("resume_sandbox", "Resume a paused sandbox", {
-  id: exports_external2.string().describe("Sandbox ID or partial ID")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.id);
-    if (!sandbox.provider_sandbox_id)
-      throw new Error("Sandbox has no provider ID");
-    const provider = await getProvider(sandbox.provider);
-    await provider.resume(sandbox.provider_sandbox_id);
-    const updated = updateSandbox(sandbox.id, { status: "running" });
-    emitLifecycleEvent(sandbox.id, "sandbox resumed");
-    return ok(updated);
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("create_template", "Create a reusable sandbox template", {
-  name: exports_external2.string().describe("Template name"),
-  description: exports_external2.string().optional(),
-  image: exports_external2.string().optional().describe("Container image"),
-  env_vars: exports_external2.record(exports_external2.string()).optional().describe("Environment variables"),
-  setup_script: exports_external2.string().optional().describe("Shell script to run on sandbox creation"),
-  tags: exports_external2.array(exports_external2.string()).optional()
-}, async (params) => {
-  try {
-    return ok(createTemplate(params));
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("list_templates", "List all sandbox templates", {}, async () => {
-  try {
-    return ok(listTemplates());
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("get_template", "Get a sandbox template by ID", {
-  id: exports_external2.string().describe("Template ID or partial ID")
-}, async (params) => {
-  try {
-    return ok(getTemplate(params.id));
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("delete_template", "Delete a sandbox template", {
-  id: exports_external2.string().describe("Template ID or partial ID")
-}, async (params) => {
-  try {
-    deleteTemplate(params.id);
-    return ok({ deleted: params.id });
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("get_sandbox_status", "Get running processes, disk usage and uptime in a sandbox", {
-  sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.sandbox_id);
-    if (!sandbox.provider_sandbox_id)
-      throw new Error("Sandbox has no provider ID");
-    const provider = await getProvider(sandbox.provider);
-    const [psResult, dfResult, uptimeResult] = await Promise.all([
-      provider.exec(sandbox.provider_sandbox_id, "ps aux --no-headers 2>/dev/null | head -30 || ps aux 2>/dev/null | tail -n +2 | head -30"),
-      provider.exec(sandbox.provider_sandbox_id, "df -h / 2>/dev/null || df -h 2>/dev/null | head -5"),
-      provider.exec(sandbox.provider_sandbox_id, "uptime 2>/dev/null || echo unknown")
-    ]);
-    const processes = (psResult.stdout || "").trim().split(`
+  });
+  server.tool("get_logs", "Get sandbox/session event logs", {
+    sandbox_id: exports_external2.string().optional().describe("Filter by sandbox ID"),
+    session_id: exports_external2.string().optional().describe("Filter by session ID"),
+    limit: exports_external2.number().optional().describe("Max events to return")
+  }, async (params) => {
+    try {
+      return ok(listEvents({
+        sandbox_id: params.sandbox_id,
+        session_id: params.session_id,
+        limit: params.limit
+      }));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("register_agent", "Register an agent", {
+    name: exports_external2.string().describe("Agent name"),
+    description: exports_external2.string().optional().describe("Agent description")
+  }, async (params) => {
+    try {
+      return ok(registerAgent({ name: params.name, description: params.description }));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("list_agents", "List all registered agents", {}, async () => {
+    try {
+      return ok(listAgents());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("heartbeat", "Update last_seen_at to signal agent is active. Call periodically during long tasks.", { agent_id: exports_external2.string().describe("Agent ID or name") }, async (params) => {
+    try {
+      return ok(heartbeatAgent(params.agent_id));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("set_focus", "Set active project context for this agent session.", {
+    agent_id: exports_external2.string().describe("Agent ID or name"),
+    project_id: exports_external2.string().nullable().optional().describe("Project ID to focus on, or null to clear")
+  }, async (params) => {
+    try {
+      return ok(setAgentFocus(params.agent_id, params.project_id ?? null));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("register_project", "Register a project", {
+    name: exports_external2.string().describe("Project name"),
+    path: exports_external2.string().describe("Project path"),
+    description: exports_external2.string().optional().describe("Project description")
+  }, async (params) => {
+    try {
+      return ok(ensureProject(params.name, params.path, params.description));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("list_projects", "List all projects", {}, async () => {
+    try {
+      return ok(listProjects());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("describe_tools", "List all available tools", {}, async () => {
+    try {
+      return ok(TOOL_CATALOG);
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("search_tools", "Search tools by keyword", {
+    query: exports_external2.string().describe("Search query")
+  }, async (params) => {
+    try {
+      const q = params.query.toLowerCase();
+      const matches = TOOL_CATALOG.filter((t) => t.name.includes(q) || t.description.toLowerCase().includes(q));
+      return ok(matches);
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("run_agent", "Run an AI agent inside a sandbox", {
+    sandbox_id: exports_external2.string().describe("Sandbox ID"),
+    agent_type: exports_external2.enum(["claude", "codex", "gemini", "opencode", "pi", "takumi", "custom"]).describe("Agent type"),
+    prompt: exports_external2.string().describe("Prompt for the agent"),
+    agent_name: exports_external2.string().optional().describe("Agent name"),
+    command: exports_external2.string().optional().describe("Custom command (for 'custom' type)"),
+    env_vars: exports_external2.record(exports_external2.string()).optional().describe("Per-call environment variables (merged with sandbox env_vars, not persisted)"),
+    secrets: exports_external2.array(exports_external2.string()).optional().describe("Vault secrets to inject as env vars: array of 'ENV_NAME=vault/key' (resolved from @hasna/secrets at call time, never persisted)"),
+    webhook_url: exports_external2.string().optional().describe("URL to POST result to when agent finishes"),
+    webhook_events: exports_external2.array(exports_external2.enum(["start", "complete", "error"])).optional().describe("Which events to notify on (default: all)")
+  }, async (params) => {
+    try {
+      let callEnvVars = params.env_vars;
+      if (params.secrets && params.secrets.length > 0) {
+        const { resolveSecretSpecs: resolveSecretSpecs2 } = await Promise.resolve().then(() => exports_secrets);
+        const secretEnv = await resolveSecretSpecs2(params.secrets);
+        callEnvVars = { ...secretEnv, ...params.env_vars };
+      }
+      const session = await runAgent(params.sandbox_id, {
+        agentType: params.agent_type,
+        prompt: params.prompt,
+        agentName: params.agent_name,
+        command: params.command,
+        callEnvVars,
+        webhookUrl: params.webhook_url,
+        webhookEvents: params.webhook_events
+      });
+      return ok({ session_id: session.id, status: session.status });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("stop_agent", "Stop a running agent in a sandbox", {
+    sandbox_id: exports_external2.string().describe("Sandbox ID")
+  }, async (params) => {
+    try {
+      await stopAgent(params.sandbox_id);
+      return ok({ stopped: true });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("get_agent_output", "Get output from an agent session", {
+    sandbox_id: exports_external2.string().describe("Sandbox ID"),
+    session_id: exports_external2.string().optional().describe("Session ID"),
+    limit: exports_external2.number().optional().describe("Max events"),
+    offset: exports_external2.number().optional().describe("Skip first N events (for incremental polling)")
+  }, async (params) => {
+    try {
+      const events = listEvents({
+        sandbox_id: params.sandbox_id,
+        session_id: params.session_id,
+        limit: params.limit || 100,
+        offset: params.offset
+      });
+      const stdout = events.filter((e) => e.type === "stdout").map((e) => e.data).join("");
+      const stderr = events.filter((e) => e.type === "stderr").map((e) => e.data).join("");
+      return ok({ stdout, stderr, event_count: events.length, next_offset: (params.offset ?? 0) + events.length });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("pause_sandbox", "Pause a running sandbox, saving its state for later resume", {
+    id: exports_external2.string().describe("Sandbox ID or partial ID")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.id);
+      if (!sandbox.provider_sandbox_id)
+        throw new Error("Sandbox has no provider ID");
+      const provider = await getProvider(sandbox.provider);
+      await provider.pause(sandbox.provider_sandbox_id);
+      const updated = updateSandbox(sandbox.id, { status: "paused" });
+      emitLifecycleEvent(sandbox.id, "sandbox paused");
+      return ok(updated);
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("resume_sandbox", "Resume a paused sandbox", {
+    id: exports_external2.string().describe("Sandbox ID or partial ID")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.id);
+      if (!sandbox.provider_sandbox_id)
+        throw new Error("Sandbox has no provider ID");
+      const provider = await getProvider(sandbox.provider);
+      await provider.resume(sandbox.provider_sandbox_id);
+      const updated = updateSandbox(sandbox.id, { status: "running" });
+      emitLifecycleEvent(sandbox.id, "sandbox resumed");
+      return ok(updated);
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("create_template", "Create a reusable sandbox template", {
+    name: exports_external2.string().describe("Template name"),
+    description: exports_external2.string().optional(),
+    image: exports_external2.string().optional().describe("Container image"),
+    env_vars: exports_external2.record(exports_external2.string()).optional().describe("Environment variables"),
+    setup_script: exports_external2.string().optional().describe("Shell script to run on sandbox creation"),
+    tags: exports_external2.array(exports_external2.string()).optional()
+  }, async (params) => {
+    try {
+      return ok(createTemplate(params));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("list_templates", "List all sandbox templates", {}, async () => {
+    try {
+      return ok(listTemplates());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("get_template", "Get a sandbox template by ID", {
+    id: exports_external2.string().describe("Template ID or partial ID")
+  }, async (params) => {
+    try {
+      return ok(getTemplate(params.id));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("delete_template", "Delete a sandbox template", {
+    id: exports_external2.string().describe("Template ID or partial ID")
+  }, async (params) => {
+    try {
+      deleteTemplate(params.id);
+      return ok({ deleted: params.id });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("get_sandbox_status", "Get running processes, disk usage and uptime in a sandbox", {
+    sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.sandbox_id);
+      if (!sandbox.provider_sandbox_id)
+        throw new Error("Sandbox has no provider ID");
+      const provider = await getProvider(sandbox.provider);
+      const [psResult, dfResult, uptimeResult] = await Promise.all([
+        provider.exec(sandbox.provider_sandbox_id, "ps aux --no-headers 2>/dev/null | head -30 || ps aux 2>/dev/null | tail -n +2 | head -30"),
+        provider.exec(sandbox.provider_sandbox_id, "df -h / 2>/dev/null || df -h 2>/dev/null | head -5"),
+        provider.exec(sandbox.provider_sandbox_id, "uptime 2>/dev/null || echo unknown")
+      ]);
+      const processes = (psResult.stdout || "").trim().split(`
 `).filter(Boolean).map((line) => {
-      const parts = line.trim().split(/\s+/);
-      return {
-        pid: parts[1] || "",
-        cpu: parts[2] || "0",
-        mem: parts[3] || "0",
-        command: parts.slice(10).join(" ") || parts.slice(4).join(" ")
-      };
-    });
-    return ok({
-      sandbox_id: sandbox.id,
-      status: sandbox.status,
-      processes,
-      disk: (dfResult.stdout || "").trim(),
-      uptime: (uptimeResult.stdout || "").trim()
-    });
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("snapshot_sandbox", "Capture sandbox filesystem state as a snapshot", {
-  id: exports_external2.string().describe("Sandbox ID or partial ID"),
-  name: exports_external2.string().optional().describe("Snapshot name")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.id);
-    if (!sandbox.provider_sandbox_id)
-      throw new Error("Sandbox has no provider ID");
-    const provider = await getProvider(sandbox.provider);
-    await provider.pause(sandbox.provider_sandbox_id);
-    updateSandbox(sandbox.id, { status: "paused" });
-    const snapshot = createSnapshot({
-      sandbox_id: sandbox.id,
-      provider_sandbox_id: sandbox.provider_sandbox_id,
-      provider: sandbox.provider,
-      name: params.name
-    });
-    emitLifecycleEvent(sandbox.id, `Snapshot created: ${snapshot.id}`);
-    return ok(snapshot);
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("list_snapshots", "List filesystem snapshots", {
-  sandbox_id: exports_external2.string().optional().describe("Filter by sandbox ID")
-}, async (params) => {
-  try {
-    return ok(listSnapshots(params.sandbox_id));
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("delete_snapshot", "Delete a snapshot", {
-  id: exports_external2.string().describe("Snapshot ID or partial ID")
-}, async (params) => {
-  try {
-    deleteSnapshot(params.id);
-    return ok({ deleted: params.id });
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("expose_port", "Forward a sandbox port and get a public URL", {
-  sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
-  port: exports_external2.number().describe("Port number to expose"),
-  protocol: exports_external2.string().optional().describe("Protocol: http or ws (default: http)")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.sandbox_id);
-    if (!sandbox.provider_sandbox_id)
-      throw new Error("Sandbox has no provider ID");
-    const provider = await getProvider(sandbox.provider);
-    const url = await provider.getPublicUrl(sandbox.provider_sandbox_id, params.port, params.protocol);
-    if (!exposedPorts.has(sandbox.id))
-      exposedPorts.set(sandbox.id, new Map);
-    exposedPorts.get(sandbox.id).set(params.port, url);
-    return ok({ sandbox_id: sandbox.id, port: params.port, url });
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("list_exposed_ports", "List all forwarded ports for a sandbox", {
-  sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.sandbox_id);
-    const ports = exposedPorts.get(sandbox.id) ?? new Map;
-    const result = Array.from(ports.entries()).map(([port, url]) => ({ port, url }));
-    return ok(result);
-  } catch (e) {
-    return err(e);
-  }
-});
-server.tool("close_port", "Stop forwarding a sandbox port", {
-  sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
-  port: exports_external2.number().describe("Port number to close")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.sandbox_id);
-    exposedPorts.get(sandbox.id)?.delete(params.port);
-    return ok({ sandbox_id: sandbox.id, port: params.port, closed: true });
-  } catch (e) {
-    return err(e);
+        const parts = line.trim().split(/\s+/);
+        return {
+          pid: parts[1] || "",
+          cpu: parts[2] || "0",
+          mem: parts[3] || "0",
+          command: parts.slice(10).join(" ") || parts.slice(4).join(" ")
+        };
+      });
+      return ok({
+        sandbox_id: sandbox.id,
+        status: sandbox.status,
+        processes,
+        disk: (dfResult.stdout || "").trim(),
+        uptime: (uptimeResult.stdout || "").trim()
+      });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("snapshot_sandbox", "Capture sandbox filesystem state as a snapshot", {
+    id: exports_external2.string().describe("Sandbox ID or partial ID"),
+    name: exports_external2.string().optional().describe("Snapshot name")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.id);
+      if (!sandbox.provider_sandbox_id)
+        throw new Error("Sandbox has no provider ID");
+      const provider = await getProvider(sandbox.provider);
+      await provider.pause(sandbox.provider_sandbox_id);
+      updateSandbox(sandbox.id, { status: "paused" });
+      const snapshot = createSnapshot({
+        sandbox_id: sandbox.id,
+        provider_sandbox_id: sandbox.provider_sandbox_id,
+        provider: sandbox.provider,
+        name: params.name
+      });
+      emitLifecycleEvent(sandbox.id, `Snapshot created: ${snapshot.id}`);
+      return ok(snapshot);
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("list_snapshots", "List filesystem snapshots", {
+    sandbox_id: exports_external2.string().optional().describe("Filter by sandbox ID")
+  }, async (params) => {
+    try {
+      return ok(listSnapshots(params.sandbox_id));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("delete_snapshot", "Delete a snapshot", {
+    id: exports_external2.string().describe("Snapshot ID or partial ID")
+  }, async (params) => {
+    try {
+      deleteSnapshot(params.id);
+      return ok({ deleted: params.id });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("expose_port", "Forward a sandbox port and get a public URL", {
+    sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
+    port: exports_external2.number().describe("Port number to expose"),
+    protocol: exports_external2.string().optional().describe("Protocol: http or ws (default: http)")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.sandbox_id);
+      if (!sandbox.provider_sandbox_id)
+        throw new Error("Sandbox has no provider ID");
+      const provider = await getProvider(sandbox.provider);
+      const url = await provider.getPublicUrl(sandbox.provider_sandbox_id, params.port, params.protocol);
+      if (!exposedPorts.has(sandbox.id))
+        exposedPorts.set(sandbox.id, new Map);
+      exposedPorts.get(sandbox.id).set(params.port, url);
+      return ok({ sandbox_id: sandbox.id, port: params.port, url });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("list_exposed_ports", "List all forwarded ports for a sandbox", {
+    sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.sandbox_id);
+      const ports = exposedPorts.get(sandbox.id) ?? new Map;
+      const result = Array.from(ports.entries()).map(([port, url]) => ({ port, url }));
+      return ok(result);
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("close_port", "Stop forwarding a sandbox port", {
+    sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
+    port: exports_external2.number().describe("Port number to close")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.sandbox_id);
+      exposedPorts.get(sandbox.id)?.delete(params.port);
+      return ok({ sandbox_id: sandbox.id, port: params.port, closed: true });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("get_network_log", "Get outbound network connections from a sandbox", {
+    sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.sandbox_id);
+      if (!sandbox.provider_sandbox_id)
+        throw new Error("Sandbox has no provider ID");
+      const provider = await getProvider(sandbox.provider);
+      const result = await provider.exec(sandbox.provider_sandbox_id, "ss -tnp 2>/dev/null || netstat -tnp 2>/dev/null || echo 'Network log not available'");
+      return ok({ sandbox_id: sandbox.id, connections: (result.stdout || "").trim() });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("watch_file", "Get new content from a file since a previous read (tail -f equivalent)", {
+    sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
+    path: exports_external2.string().describe("File path to watch"),
+    offset: exports_external2.number().optional().describe("Line offset to read from (use next_offset from previous call)"),
+    limit: exports_external2.number().optional().describe("Max lines to return (default: 100)")
+  }, async (params) => {
+    try {
+      const sandbox = getSandbox(params.sandbox_id);
+      if (!sandbox.provider_sandbox_id)
+        throw new Error("Sandbox has no provider ID");
+      const provider = await getProvider(sandbox.provider);
+      const content = await provider.readFile(sandbox.provider_sandbox_id, params.path, {
+        offset: params.offset,
+        limit: params.limit ?? 100
+      });
+      const lines = content.split(`
+`);
+      return ok({
+        path: params.path,
+        content,
+        lines_read: lines.length,
+        next_offset: (params.offset ?? 0) + lines.length
+      });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("list_images", "List available pre-warmed sandbox image aliases", {}, async () => {
+    try {
+      return ok(Object.entries(BUILTIN_IMAGES).map(([name, info]) => ({
+        name,
+        description: info.description,
+        has_setup_script: !!info.setup_script
+      })));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("send_feedback", "Send feedback about this service", { message: exports_external2.string(), email: exports_external2.string().optional(), category: exports_external2.enum(["bug", "feature", "general"]).optional() }, async (params) => {
+    try {
+      const db2 = getDatabase();
+      db2.run("INSERT INTO feedback (message, email, category, version) VALUES (?, ?, ?, ?)", [params.message, params.email || null, params.category || "general", "0.1.17"]);
+      return ok("Feedback saved. Thank you!");
+    } catch (e) {
+      return err(e);
+    }
+  });
+  registerCloudTools(server, "sandboxes");
+  return server;
+}
+
+// src/mcp/http.ts
+import { createServer } from "http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+var DEFAULT_MCP_HTTP_PORT = 8831;
+function isHttpMode(argv) {
+  return argv.includes("--http") || process.env["MCP_HTTP"] === "1";
+}
+function resolveMcpHttpPort(argv) {
+  const portIdx = argv.indexOf("--port");
+  if (portIdx >= 0 && argv[portIdx + 1]) {
+    return parseInt(argv[portIdx + 1], 10);
   }
-});
-server.tool("get_network_log", "Get outbound network connections from a sandbox", {
-  sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.sandbox_id);
-    if (!sandbox.provider_sandbox_id)
-      throw new Error("Sandbox has no provider ID");
-    const provider = await getProvider(sandbox.provider);
-    const result = await provider.exec(sandbox.provider_sandbox_id, "ss -tnp 2>/dev/null || netstat -tnp 2>/dev/null || echo 'Network log not available'");
-    return ok({ sandbox_id: sandbox.id, connections: (result.stdout || "").trim() });
-  } catch (e) {
-    return err(e);
+  if (process.env["MCP_HTTP_PORT"]) {
+    return parseInt(process.env["MCP_HTTP_PORT"], 10);
   }
-});
-server.tool("watch_file", "Get new content from a file since a previous read (tail -f equivalent)", {
-  sandbox_id: exports_external2.string().describe("Sandbox ID or partial ID"),
-  path: exports_external2.string().describe("File path to watch"),
-  offset: exports_external2.number().optional().describe("Line offset to read from (use next_offset from previous call)"),
-  limit: exports_external2.number().optional().describe("Max lines to return (default: 100)")
-}, async (params) => {
-  try {
-    const sandbox = getSandbox(params.sandbox_id);
-    if (!sandbox.provider_sandbox_id)
-      throw new Error("Sandbox has no provider ID");
-    const provider = await getProvider(sandbox.provider);
-    const content = await provider.readFile(sandbox.provider_sandbox_id, params.path, {
-      offset: params.offset,
-      limit: params.limit ?? 100
-    });
-    const lines = content.split(`
-`);
-    return ok({
-      path: params.path,
-      content,
-      lines_read: lines.length,
-      next_offset: (params.offset ?? 0) + lines.length
-    });
-  } catch (e) {
-    return err(e);
+  return DEFAULT_MCP_HTTP_PORT;
+}
+function healthPayload(name = MCP_NAME) {
+  return { status: "ok", name };
+}
+function startMcpHttpServer(options = {}) {
+  const hostname2 = options.hostname ?? "127.0.0.1";
+  const requestedPort = options.port ?? DEFAULT_MCP_HTTP_PORT;
+  const httpServer = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? `${hostname2}:${requestedPort}`}`);
+    if (req.method === "GET" && url.pathname === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(healthPayload()));
+      return;
+    }
+    if (url.pathname === "/mcp") {
+      const server = buildServer();
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined
+      });
+      try {
+        await server.connect(transport);
+        await transport.handleRequest(req, res);
+      } finally {
+        res.on("close", () => {
+          transport.close();
+          server.close();
+        });
+      }
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+  });
+  httpServer.listen(requestedPort, hostname2, () => {
+    const address = httpServer.address();
+    const port = typeof address === "object" && address ? address.port : requestedPort;
+    options.onListening?.(port);
+    console.error(`[${MCP_NAME}-mcp] HTTP listening on http://${hostname2}:${port}/mcp`);
+  });
+  return httpServer;
+}
+
+// src/mcp/index.ts
+function handleCliFlags(argv) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log("Usage: sandboxes-mcp [options]");
+    console.log("");
+    console.log("MCP server for @hasna/sandboxes (stdio default, optional Streamable HTTP)");
+    console.log("");
+    console.log("Options:");
+    console.log("  --http         Start Streamable HTTP transport on 127.0.0.1");
+    console.log("  --port <n>     HTTP port (default 8831, or MCP_HTTP_PORT env)");
+    console.log("  -h, --help     display help");
+    console.log("  -V, --version  display version");
+    console.log("");
+    console.log("Environment:");
+    console.log("  MCP_HTTP=1         Enable HTTP mode");
+    console.log("  MCP_HTTP_PORT      Override default HTTP port");
+    return true;
   }
-});
-server.tool("list_images", "List available pre-warmed sandbox image aliases", {}, async () => {
-  try {
-    return ok(Object.entries(BUILTIN_IMAGES).map(([name, info]) => ({
-      name,
-      description: info.description,
-      has_setup_script: !!info.setup_script
-    })));
-  } catch (e) {
-    return err(e);
+  if (argv.includes("--version") || argv.includes("-V")) {
+    console.log(getPackageVersion());
+    return true;
   }
-});
-server.tool("send_feedback", "Send feedback about this service", { message: exports_external2.string(), email: exports_external2.string().optional(), category: exports_external2.enum(["bug", "feature", "general"]).optional() }, async (params) => {
-  try {
-    const db2 = getDatabase();
-    db2.run("INSERT INTO feedback (message, email, category, version) VALUES (?, ?, ?, ?)", [params.message, params.email || null, params.category || "general", "0.1.17"]);
-    return ok("Feedback saved. Thank you!");
-  } catch (e) {
-    return err(e);
+  return false;
+}
+var argv = process.argv.slice(2);
+if (handleCliFlags(argv)) {
+  process.exit(0);
+}
+async function main() {
+  if (isHttpMode(argv)) {
+    startMcpHttpServer({ port: resolveMcpHttpPort(argv) });
+    return;
   }
-});
-var transport = new StdioServerTransport;
-registerCloudTools(server, "sandboxes");
-await server.connect(transport);
+  const server = buildServer();
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+}
+main().catch(console.error);