@madarco/agentbox 0.12.0 → 0.14.0

package/dist/{chunk-HFV6THYG.js → chunk-BYCLD6D6.js}

@@ -1,42 +1,48 @@
 #!/usr/bin/env node
 import {
   DEFAULT_RELAY_PORT,
+  loadEffectiveConfig,
   readBoxStatus
-} from "./chunk-IZXPJPPV.js";
+} from "./chunk-TCS5HXJX.js";
 
 // src/commands/_cloud-attach.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { appendFileSync } from "fs";
 import { homedir } from "os";
 import { join as join2 } from "path";
 import { spinner } from "@clack/prompts";
 
 // src/provider/registry.ts
-var KNOWN = ["docker", "daytona", "hetzner", "vercel"];
+var KNOWN = ["docker", "daytona", "hetzner", "vercel", "e2b"];
 function isKnownProvider(name) {
   return KNOWN.includes(name);
 }
 async function getProvider(name) {
   switch (name) {
     case "docker": {
-      const mod = await import("./dist-RZZSSUNB.js");
+      const mod = await import("./dist-4DPOL5A7.js");
       return mod.dockerProvider;
     }
     case "daytona": {
-      const mod = await import("./dist-47LVLYUV.js");
+      const mod = await import("./dist-3IMQNTTV.js");
       await mod.ensureDaytonaCredentials();
       return mod.daytonaProvider;
     }
     case "hetzner": {
-      const mod = await import("./dist-SWUOU34W.js");
+      const mod = await import("./dist-J2IHD5T7.js");
       await mod.ensureHetznerCredentials();
       return mod.hetznerProvider;
     }
     case "vercel": {
-      const mod = await import("./dist-24PY2ZMO.js");
+      const mod = await import("./dist-57M6ZA7H.js");
       await mod.ensureVercelCredentials();
       return mod.vercelProvider;
     }
+    case "e2b": {
+      const mod = await import("./dist-34RKQ74M.js");
+      await mod.ensureE2bCredentials();
+      return mod.e2bProvider;
+    }
     default:
       throw new Error(`unknown sandbox provider: ${String(name)}`);
   }
@@ -56,20 +62,20 @@ async function providerForCreate(choice) {
 }
 
 // src/wrapped-pty/run.ts
-import { spawn as spawn2, spawnSync } from "child_process";
+import { spawn as spawn3, spawnSync as spawnSync2 } from "child_process";
 
 // src/pty/pty-backend.ts
 async function loadPtyBackend() {
   try {
     const ptyMod = await import("@homebridge/node-pty-prebuilt-multiarch");
     const xtermMod = await import("@xterm/headless");
-    const spawn4 = ptyMod["spawn"] ?? ptyMod["default"]?.["spawn"];
+    const spawn5 = ptyMod["spawn"] ?? ptyMod["default"]?.["spawn"];
     const Terminal = xtermMod["Terminal"] ?? xtermMod["default"]?.["Terminal"];
-    if (typeof spawn4 !== "function" || typeof Terminal !== "function") {
+    if (typeof spawn5 !== "function" || typeof Terminal !== "function") {
       return null;
     }
     return {
-      ptySpawn: spawn4,
+      ptySpawn: spawn5,
       termCtor: Terminal
     };
   } catch {
@@ -82,10 +88,16 @@ import { spawn } from "child_process";
 function detectHostTerminal(env = process.env) {
   const tmux = env["TMUX"];
   if (tmux && tmux.length > 0) return "tmux";
+  const cmuxSocket = env["CMUX_SOCKET_PATH"];
+  if (cmuxSocket && cmuxSocket.length > 0) return "cmux";
   const termProgram = env["TERM_PROGRAM"];
   if (termProgram === "iTerm.app") return "iterm2";
   return "unknown";
 }
+function cmuxBinary(env = process.env) {
+  const bundled = env["CMUX_BUNDLED_CLI_PATH"];
+  return bundled && bundled.length > 0 ? bundled : "cmux";
+}
 function shellQuote(s) {
   if (s.length === 0) return "''";
   return "'" + s.replace(/'/g, "'\\''") + "'";
@@ -98,6 +110,7 @@ function shellJoin(argv) {
 }
 async function spawnInNewTerminal(args) {
   if (args.host === "tmux") return spawnInTmux(args);
+  if (args.host === "cmux") return spawnInCmux(args);
   return spawnInITerm2(args);
 }
 async function spawnInTmux(args) {
@@ -124,6 +137,63 @@ async function spawnInTmux(args) {
     note: `Attached in new ${noteKind}.`
   };
 }
+async function spawnInCmux(args) {
+  const bin = cmuxBinary();
+  if (args.mode === "window") {
+    const r = await runQuiet(bin, [
+      "new-workspace",
+      "--name",
+      args.title,
+      "--cwd",
+      args.cwd,
+      "--command",
+      shellJoin(args.argv),
+      "--focus",
+      "true"
+    ]);
+    if (r.code !== 0) {
+      return {
+        launched: false,
+        note: "",
+        error: `cmux new-workspace exited ${String(r.code)}: ${r.stderr.trim()}`
+      };
+    }
+    return { launched: true, note: "Attached in new cmux workspace." };
+  }
+  const createArgv = args.mode === "split" ? ["new-split", "right", "--focus", "true"] : ["new-surface", "--focus", "true"];
+  const noteKind = args.mode === "split" ? "cmux split" : "cmux tab";
+  const created = await runQuiet(bin, createArgv);
+  if (created.code !== 0) {
+    return {
+      launched: false,
+      note: "",
+      error: `cmux ${createArgv[0]} exited ${String(created.code)}: ${created.stderr.trim()}`
+    };
+  }
+  const surfaceRef = parseCmuxRef(created.stdout);
+  if (!surfaceRef) {
+    return {
+      launched: false,
+      note: "",
+      error: `cmux ${createArgv[0]} gave no surface ref: ${created.stdout.trim()}`
+    };
+  }
+  const cmdLine = `cd ${shellQuote(args.cwd)} && exec ${shellJoin(args.argv)}`;
+  const sent = await runQuiet(bin, ["send", "--surface", surfaceRef, `${cmdLine}
+`]);
+  if (sent.code !== 0) {
+    return {
+      launched: false,
+      note: "",
+      error: `cmux send exited ${String(sent.code)}: ${sent.stderr.trim()}`
+    };
+  }
+  return { launched: true, note: `Attached in new ${noteKind}.` };
+}
+function parseCmuxRef(stdout) {
+  const m = stdout.match(/\b(?:surface|pane):\d+\b/);
+  return m ? m[0] : void 0;
+}
 async function spawnInITerm2(args) {
   const inner = shellJoin(args.argv);
   const cmdLine = `cd ${shellQuote(args.cwd)} && exec ${inner}`;
@@ -174,20 +244,139 @@ async function spawnInITerm2(args) {
 }
 function runQuiet(cmd, argv) {
   return new Promise((resolve) => {
-    const child = spawn(cmd, argv, { stdio: ["ignore", "ignore", "pipe"] });
+    const child = spawn(cmd, argv, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
     let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
     child.stderr?.on("data", (chunk) => {
       stderr += chunk.toString("utf8");
     });
     child.on("error", (err) => {
-      resolve({ code: 127, stderr: err.message });
+      resolve({ code: 127, stdout, stderr: err.message });
     });
     child.on("exit", (code) => {
-      resolve({ code: typeof code === "number" ? code : 1, stderr });
+      resolve({ code: typeof code === "number" ? code : 1, stdout, stderr });
     });
   });
 }
 
+// src/terminal/cmux-status.ts
+import { spawn as spawn2, spawnSync } from "child_process";
+var AGENT_LABEL = {
+  claude: "claude",
+  codex: "codex",
+  opencode: "opencode"
+};
+function mapActivityToWorkspace(mode, activity) {
+  if (mode === "shell") return null;
+  const label = AGENT_LABEL[mode];
+  switch (activity) {
+    case "working":
+    case "compacting":
+      return { description: `${label} \xB7 working`, color: "Blue" };
+    case "question":
+    case "waiting":
+      return { description: `${label} \xB7 needs input`, color: "Amber" };
+    case "end-plan":
+      return { description: `${label} \xB7 plan ready`, color: "Amber" };
+    case "error":
+      return { description: `${label} \xB7 error`, color: "Red" };
+    case "idle":
+      return { description: `${label} \xB7 idle`, color: "" };
+    case "unknown":
+    case void 0:
+    default:
+      return null;
+  }
+}
+function isAttentionState(activity) {
+  return activity === "question" || activity === "waiting" || activity === "end-plan" || activity === "error";
+}
+function attentionReason(activity) {
+  switch (activity) {
+    case "end-plan":
+      return "plan ready";
+    case "error":
+      return "error";
+    case "question":
+    case "waiting":
+    default:
+      return "needs input";
+  }
+}
+function cmuxStatusActive(env = process.env) {
+  const sock = env["CMUX_SOCKET_PATH"];
+  return typeof sock === "string" && sock.length > 0;
+}
+async function cmuxStatusEnabled(env = process.env) {
+  if (!cmuxStatusActive(env)) return false;
+  try {
+    const cfg = await loadEffectiveConfig(process.cwd());
+    return cfg.effective.attach.cmuxStatus;
+  } catch {
+    return true;
+  }
+}
+function runCmux(argv) {
+  try {
+    const child = spawn2(cmuxBinary(), argv, { stdio: "ignore" });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+function captureCmuxWorkspace(env = process.env) {
+  const wsId = env["CMUX_WORKSPACE_ID"];
+  if (!wsId) return null;
+  try {
+    const r = spawnSync(cmuxBinary(), ["list-workspaces", "--json", "--id-format", "both"], {
+      encoding: "utf8"
+    });
+    if (r.status !== 0 || !r.stdout) return null;
+    const data = JSON.parse(r.stdout);
+    for (const w of data.workspaces ?? []) {
+      if (!JSON.stringify(w).includes(wsId)) continue;
+      const description = typeof w["description"] === "string" ? w["description"] : "";
+      const color = typeof w["custom_color"] === "string" ? w["custom_color"] : "";
+      return { description, color };
+    }
+  } catch {
+  }
+  return null;
+}
+function applyCmuxAgentState(mode, activity) {
+  const view = mapActivityToWorkspace(mode, activity);
+  if (!view) return;
+  runCmux(["workspace-action", "--action", "set-description", "--description", view.description]);
+  if (view.color) {
+    runCmux(["workspace-action", "--action", "set-color", "--color", view.color]);
+  } else {
+    runCmux(["workspace-action", "--action", "clear-color"]);
+  }
+}
+function markCmuxTabAttention(mode, boxName, activity, env = process.env) {
+  const label = mode === "shell" ? "shell" : AGENT_LABEL[mode];
+  const argv = ["notify", "--title", boxName, "--body", `${label} \xB7 ${attentionReason(activity)}`];
+  const surface = env["CMUX_SURFACE_ID"];
+  if (surface && surface.length > 0) argv.push("--surface", surface);
+  runCmux(argv);
+}
+function restoreCmuxWorkspace(orig) {
+  if (orig && orig.description) {
+    runCmux(["workspace-action", "--action", "set-description", "--description", orig.description]);
+  } else {
+    runCmux(["workspace-action", "--action", "clear-description"]);
+  }
+  if (orig && orig.color) {
+    runCmux(["workspace-action", "--action", "set-color", "--color", orig.color]);
+  } else {
+    runCmux(["workspace-action", "--action", "clear-color"]);
+  }
+}
+
 // src/terminal/title.ts
 var ESC = "\x1B";
 var BEL = "\x07";
@@ -665,7 +854,7 @@ var ADVANCED_HINT_GROUPS = [
   ["u", "url"],
   ["t", "stop"],
   ["p", "pause"],
-  ["d", "destroy"],
+  ["k", "destroy"],
   ["q", "quit"]
 ];
 function statusLine(box, w, stateLabel, groups = HINT_GROUPS, fallbackGroups) {
@@ -728,12 +917,16 @@ var DETACHABLE_LEADER_HINTS = [
   ["c", "code"],
   ["s", "screen"],
   ["u", "url"],
+  ["t", "shell"],
+  ["k", "destroy"],
   ["d", "detach"]
 ];
 var PLAIN_LEADER_HINTS = [
   ["c", "code"],
   ["s", "screen"],
-  ["u", "url"]
+  ["u", "url"],
+  ["t", "shell"],
+  ["k", "destroy"]
 ];
 function padTo(visible, width) {
   if (visible.length === width) return visible;
@@ -1062,7 +1255,8 @@ var CHECKPOINT_DROP_GRACE_MS = 4e3;
 var ACTION_FLASH = {
   screen: "Opening noVNC viewer\u2026",
   code: "Launching VS Code / Cursor\u2026",
-  url: "Opening box URL\u2026"
+  url: "Opening box URL\u2026",
+  shell: "Opening shell in box\u2026"
 };
 var ACTION_CMD = {
   screen: { sub: "screen", flags: [] },
@@ -1154,6 +1348,7 @@ async function runWrappedAttach(opts) {
   let reconnecting = false;
   let reconnectAbort = null;
   let userDetached = false;
+  let userKilled = false;
   let checkpointNoticeAt = 0;
   let checkpointNoticeClearedAt = 0;
   const reservedRows = () => FOOTER_ROWS + bandReservedRows;
@@ -1249,7 +1444,7 @@ async function runWrappedAttach(opts) {
     });
   };
   wireOutput();
-  const leaderChords = detachable ? { c: "code", s: "screen", u: "url", d: "detach" } : { c: "code", s: "screen", u: "url" };
+  const leaderChords = detachable ? { c: "code", s: "screen", u: "url", t: "shell", k: "kill", d: "detach" } : { c: "code", s: "screen", u: "url", t: "shell", k: "kill" };
   const runAction = (name) => {
     if (name === "detach") {
       if (!reconnecting) {
@@ -1258,20 +1453,76 @@ async function runWrappedAttach(opts) {
       }
       return;
     }
+    if (name === "kill") {
+      if (capturingPrompt) return;
+      const ev = {
+        id: "local:kill",
+        kind: "confirm",
+        message: `Destroy ${opts.boxName}? This wipes the box and all its data.`,
+        detail: "This cannot be undone.",
+        defaultAnswer: "n",
+        context: { command: "destroy box" }
+      };
+      capturingPrompt = ev;
+      applyBandChange();
+      void router.capture(ev).then((body) => {
+        if (body.answer !== "y" || body.cancelled) return;
+        userDetached = true;
+        userKilled = true;
+        flashMessage = `Destroying ${opts.boxName}\u2026`;
+        recomputeFooter();
+        redrawChrome();
+        const cli = process.argv[1];
+        if (typeof cli === "string" && cli.length > 0) {
+          try {
+            spawn3(process.execPath, [cli, "destroy", opts.boxId, "-y"], {
+              detached: true,
+              stdio: "ignore"
+            }).unref();
+          } catch (e) {
+            logErr(`leader-action kill spawn failed: ${e.message}`);
+          }
+        }
+      }).catch((e) => {
+        if (capturingPrompt === ev) {
+          capturingPrompt = null;
+          applyBandChange();
+        }
+        const msg = e instanceof Error ? e.message : String(e);
+        if (msg !== "resolved-elsewhere") logErr(`kill confirm rejected: ${msg}`);
+      });
+      return;
+    }
     const cliEntry = process.argv[1];
-    if (typeof cliEntry === "string" && cliEntry.length > 0) {
-      const cmd = ACTION_CMD[name];
-      try {
-        spawn2(
-          process.execPath,
-          [cliEntry, cmd.sub, opts.boxId, ...cmd.flags],
-          { detached: true, stdio: "ignore" }
-        ).unref();
-      } catch (e) {
-        logErr(`leader-action spawn (${name}) failed: ${e.message}`);
+    if (name === "shell") {
+      const host = detectHostTerminal();
+      if (typeof cliEntry === "string" && cliEntry.length > 0 && host !== "unknown") {
+        void spawnInNewTerminal({
+          host,
+          mode: "tab",
+          argv: [process.execPath, cliEntry, "shell", opts.boxId, "--new"],
+          cwd: process.cwd(),
+          title: `${opts.boxName} shell`
+        }).then((r) => {
+          if (!r.launched && r.error) logErr(`leader-action shell: ${r.error}`);
+        }).catch((e) => logErr(`leader-action shell failed: ${e.message}`));
+      }
+      flashMessage = host === "unknown" ? `Run: agentbox shell ${opts.boxId} --new` : ACTION_FLASH.shell;
+    } else {
+      if (typeof cliEntry === "string" && cliEntry.length > 0) {
+        const cmd = ACTION_CMD[name];
+        try {
+          spawn3(
+            process.execPath,
+            [cliEntry, cmd.sub, opts.boxId, ...cmd.flags],
+            { detached: true, stdio: "ignore" }
+          ).unref();
+        } catch (e) {
+          logErr(`leader-action spawn (${name}) failed: ${e.message}`);
+        }
       }
+      flashMessage = ACTION_FLASH[name];
     }
-    flashMessage = ACTION_FLASH[name];
     if (flashTimer) clearTimeout(flashTimer);
     flashTimer = setTimeout(() => {
       flashTimer = null;
@@ -1318,7 +1569,9 @@ async function runWrappedAttach(opts) {
       pty.write(b.toString("utf8"));
     },
     onAnswer: (body) => {
-      void postAnswer({ relayBaseUrl: opts.relayBaseUrl, body });
+      if (!body.id.startsWith("local:")) {
+        void postAnswer({ relayBaseUrl: opts.relayBaseUrl, body });
+      }
       capturingPrompt = null;
       applyBandChange();
     },
@@ -1385,6 +1638,8 @@ async function runWrappedAttach(opts) {
       }
     }
   });
+  let cmuxOn = false;
+  let cmuxOrig = null;
   const pollStatus = async () => {
     try {
       const status = await readBoxStatus({
@@ -1395,6 +1650,12 @@ async function runWrappedAttach(opts) {
       const body = opts.mode === "codex" ? status?.codex : opts.mode === "opencode" ? status?.opencode : opts.mode === "shell" ? void 0 : status?.claude;
       const nextTitle = body?.sessionTitle?.trim() || void 0;
       const nextActivity = body?.state || void 0;
+      if (cmuxOn && nextActivity !== lastActivity) {
+        applyCmuxAgentState(opts.mode, nextActivity);
+        if (isAttentionState(nextActivity) && !isAttentionState(lastActivity)) {
+          markCmuxTabAttention(opts.mode, opts.boxName, nextActivity);
+        }
+      }
       const desiredTitle = nextTitle ?? opts.boxName;
       if (desiredTitle !== lastEmittedTitle) {
         lastEmittedTitle = desiredTitle;
@@ -1417,6 +1678,10 @@ async function runWrappedAttach(opts) {
       logErr(`status poll failed: ${e.message}`);
     }
   };
+  if (opts.mode !== "shell") {
+    cmuxOn = await cmuxStatusEnabled();
+    if (cmuxOn) cmuxOrig = captureCmuxWorkspace();
+  }
   void pollStatus();
   const statusTimer = setInterval(() => {
     void pollStatus();
@@ -1505,6 +1770,7 @@ async function runWrappedAttach(opts) {
   process.stdin.off("data", onStdinData);
   process.stdout.off("resize", onResize);
   clearInterval(statusTimer);
+  if (cmuxOn) restoreCmuxWorkspace(cmuxOrig);
   stopSpinner();
   if (flashTimer) clearTimeout(flashTimer);
   if (process.stdin.isTTY) process.stdin.setRawMode(false);
@@ -1520,13 +1786,16 @@ async function runWrappedAttach(opts) {
   teardownPaint += cursorMoveTo(rsFinal, csFinal);
   process.stdout.write(teardownPaint);
   popTerminalTitle();
-  if (exitCode === 0 && opts.detachNotice) {
+  if (userKilled) {
+    process.stdout.write(`\x1B[1A\x1B[2K\rbox ${opts.boxName} destroyed
+`);
+  } else if (exitCode === 0 && opts.detachNotice) {
     process.stdout.write("\x1B[1A\x1B[2K\r" + opts.detachNotice + "\n");
   }
   return exitCode;
 }
 function runFallback(command, argv, env) {
-  const child = spawnSync(command, argv, {
+  const child = spawnSync2(command, argv, {
     stdio: "inherit",
     env: env ? { ...process.env, ...env } : process.env
   });
@@ -1698,12 +1967,15 @@ function abortableSleep(ms, signal) {
     );
   });
 }
+function agentStartBanner(binary) {
+  return `printf "  agentbox: starting ${binary} (first paint may take a few seconds)...\\r\\n"; `;
+}
 function buildCloudAttachInnerCommand(binary, extraArgs) {
   if (!extraArgs || extraArgs.length === 0) {
-    return `bash -lc exec\\ ${binary}`;
+    return `bash -lc '${agentStartBanner(binary)}exec ${binary}'`;
   }
   const blob = Buffer.from(extraArgs.join("\n"), "utf8").toString("base64");
-  return `bash -lc 'mapfile -t A <<< "$(echo ${blob} | base64 -d)"; exec ${binary} "\${A[@]}"'`;
+  return `bash -lc '${agentStartBanner(binary)}mapfile -t A <<< "$(echo ${blob} | base64 -d)"; exec ${binary} "\${A[@]}"'`;
 }
 async function cloudAgentAttach(args) {
   const provider = await providerForBox(args.box);
@@ -1817,7 +2089,7 @@ async function cloudAgentStartDetached(args) {
 }
 function runDetached(argv, env) {
   return new Promise((resolve) => {
-    const child = spawn3(argv[0], argv.slice(1), {
+    const child = spawn4(argv[0], argv.slice(1), {
       stdio: "ignore",
       env: env ? { ...process.env, ...env } : process.env
     });
@@ -1857,4 +2129,4 @@ export {
   cloudAgentAttach,
   cloudAgentStartDetached
 };
-//# sourceMappingURL=chunk-HFV6THYG.js.map
+//# sourceMappingURL=chunk-BYCLD6D6.js.map