@madarco/agentbox 0.8.0 → 0.9.0

package/dist/{chunk-FODMEHD3.js → chunk-GU5LW4B5.js}

@@ -2,32 +2,37 @@
 import {
   DEFAULT_RELAY_PORT,
   readBoxStatus
-} from "./chunk-6OZDFNBF.js";
+} from "./chunk-NCJP5MTN.js";
 
 // src/commands/_cloud-attach.ts
 import { spawn as spawn3 } from "child_process";
 
 // src/provider/registry.ts
-var KNOWN = ["docker", "daytona", "hetzner"];
+var KNOWN = ["docker", "daytona", "hetzner", "vercel"];
 function isKnownProvider(name) {
   return KNOWN.includes(name);
 }
 async function getProvider(name) {
   switch (name) {
     case "docker": {
-      const mod = await import("./dist-LOZBWMBF.js");
+      const mod = await import("./dist-32EZBYG4.js");
       return mod.dockerProvider;
     }
     case "daytona": {
-      const mod = await import("./dist-L4LCG5SJ.js");
+      const mod = await import("./dist-CX5CGVEB.js");
       await mod.ensureDaytonaCredentials();
       return mod.daytonaProvider;
     }
     case "hetzner": {
-      const mod = await import("./dist-ZODPD2I6.js");
+      const mod = await import("./dist-GDHP34ZK.js");
       await mod.ensureHetznerCredentials();
       return mod.hetznerProvider;
     }
+    case "vercel": {
+      const mod = await import("./dist-XML54CNB.js");
+      await mod.ensureVercelCredentials();
+      return mod.vercelProvider;
+    }
     default:
       throw new Error(`unknown sandbox provider: ${String(name)}`);
   }
@@ -179,6 +184,25 @@ function runQuiet(cmd, argv) {
   });
 }
 
+// src/terminal/title.ts
+var ESC = "\x1B";
+var BEL = "\x07";
+function sanitize(title) {
+  return title.replace(/[\x00-\x1f\x7f]/g, " ").trim();
+}
+function setTerminalTitle(title, stream = process.stdout) {
+  if (!stream.isTTY) return;
+  stream.write(`${ESC}]0;${sanitize(title)}${BEL}`);
+}
+function pushTerminalTitle(stream = process.stdout) {
+  if (!stream.isTTY) return;
+  stream.write(`${ESC}[22;2t`);
+}
+function popTerminalTitle(stream = process.stdout) {
+  if (!stream.isTTY) return;
+  stream.write(`${ESC}[23;2t`);
+}
+
 // src/wrapped-pty/input-router.ts
 var KEY_ENTER = 13;
 var KEY_LF = 10;
@@ -189,12 +213,58 @@ var KEY_Y_UP = 89;
 var KEY_N_LOW = 110;
 var KEY_N_UP = 78;
 var KEY_LEADER = 1;
+var KEY_CTRL_V = 22;
+var KEY_A_LOW = 97;
+function parseCsiKey(buf, i) {
+  if (buf[i] !== KEY_ESC || buf[i + 1] !== 91) return null;
+  const params = [];
+  let val = -1;
+  for (let j = i + 2; j < buf.length; j++) {
+    const b = buf[j];
+    if (b !== void 0 && b >= 48 && b <= 57) {
+      val = (val < 0 ? 0 : val) * 10 + (b - 48);
+      continue;
+    }
+    if (b === 59) {
+      params.push(val);
+      val = -1;
+      continue;
+    }
+    if (b === 58) {
+      params.push(val);
+      val = -1;
+      while (j + 1 < buf.length && buf[j + 1] !== 59 && buf[j + 1] !== 117 && buf[j + 1] !== 126) {
+        j++;
+      }
+      continue;
+    }
+    if (b === 117 || b === 126) {
+      if (val >= 0) params.push(val);
+      const len = j - i + 1;
+      const modsToCtrl = (m) => (m - 1 & 4) !== 0;
+      if (b === 117) {
+        const code2 = params[0];
+        if (code2 === void 0 || code2 < 0) return null;
+        return { len, code: code2, ctrl: modsToCtrl(params[1] ?? 1) };
+      }
+      if (params[0] !== 27) return null;
+      const code = params[2];
+      if (code === void 0 || code < 0) return null;
+      return { len, code, ctrl: modsToCtrl(params[1] ?? 1) };
+    }
+    return null;
+  }
+  return null;
+}
 var DEFAULT_LEADER_TIMEOUT_MS = 2e3;
 function createInputRouter(opts) {
   let active = null;
   let disposed = false;
   const leaderChords = opts.leaderChords ?? {};
   const leaderEnabled = Object.keys(leaderChords).length > 0;
+  const onPasteImage = opts.onPasteImage;
+  const pasteEnabled = typeof onPasteImage === "function";
+  let pasteInFlight = false;
   const leaderTimeoutMs = opts.leaderTimeoutMs ?? DEFAULT_LEADER_TIMEOUT_MS;
   const setTimer = opts.setTimer ?? ((ms, fn) => setTimeout(fn, ms));
   const clearTimer = opts.clearTimer ?? ((h) => clearTimeout(h));
@@ -272,25 +342,74 @@ function createInputRouter(opts) {
       return;
     }
   };
+  const triggerPaste = () => {
+    if (pasteInFlight) return;
+    pasteInFlight = true;
+    const done = () => {
+      pasteInFlight = false;
+      if (!disposed) opts.onForward(Buffer.from([KEY_CTRL_V]));
+    };
+    void Promise.resolve().then(() => onPasteImage?.()).then(done, done);
+  };
   const feedSteady = (buf) => {
     let chunkStart = 0;
     const flushChunk = (end) => {
       if (end > chunkStart) opts.onForward(buf.subarray(chunkStart, end));
       chunkStart = end;
     };
-    for (let i = 0; i < buf.length; i++) {
+    let i = 0;
+    while (i < buf.length) {
       const byte = buf[i];
-      if (byte === void 0) continue;
+      if (byte === void 0) {
+        i++;
+        continue;
+      }
       if (leader) {
+        const k = parseCsiKey(buf, i);
+        if (k) {
+          if (k.ctrl && k.code === KEY_A_LOW) {
+            exitLeader();
+            opts.onForward(Buffer.from([KEY_LEADER]));
+          } else {
+            const action = leaderChords[String.fromCharCode(k.code).toLowerCase()];
+            exitLeader();
+            if (action) opts.onAction?.(action);
+            else opts.onForward(buf.subarray(i, i + k.len));
+          }
+          i += k.len;
+          chunkStart = i;
+          continue;
+        }
         resolveLeaderByte(byte);
-        chunkStart = i + 1;
+        i += 1;
+        chunkStart = i;
         continue;
       }
-      if (byte === KEY_LEADER) {
+      if (leaderEnabled && byte === KEY_LEADER) {
         flushChunk(i);
-        chunkStart = i + 1;
         enterLeader();
+        i += 1;
+        chunkStart = i;
+        continue;
+      }
+      if (leaderEnabled && byte === KEY_ESC) {
+        const k = parseCsiKey(buf, i);
+        if (k && k.ctrl && k.code === KEY_A_LOW) {
+          flushChunk(i);
+          enterLeader();
+          i += k.len;
+          chunkStart = i;
+          continue;
+        }
       }
+      if (pasteEnabled && byte === KEY_CTRL_V) {
+        flushChunk(i);
+        i += 1;
+        chunkStart = i;
+        triggerPaste();
+        continue;
+      }
+      i += 1;
     }
     flushChunk(buf.length);
   };
@@ -314,7 +433,7 @@ function createInputRouter(opts) {
         }
         return;
       }
-      if (!leaderEnabled) {
+      if (!leaderEnabled && !pasteEnabled) {
         opts.onForward(buf);
         return;
       }
@@ -880,14 +999,14 @@ async function runWrappedAttach(opts) {
     }
   }
   if (!process.stdout.isTTY || !process.stdin.isTTY) {
-    return runFallback(command, opts.dockerArgv);
+    return runFallback(command, opts.dockerArgv, opts.env);
   }
   const backend = await loadPtyBackend();
   if (!backend) {
     process.stderr.write(
       "agentbox: permission prompts disabled (node-pty backend unavailable)\n"
     );
-    return runFallback(command, opts.dockerArgv);
+    return runFallback(command, opts.dockerArgv, opts.env);
   }
   const cols = process.stdout.columns ?? 80;
   const rows = process.stdout.rows ?? 24;
@@ -896,8 +1015,11 @@ async function runWrappedAttach(opts) {
     name: "xterm-256color",
     cols,
     rows: innerRows,
-    env: process.env
+    env: opts.env ? { ...process.env, ...opts.env } : process.env
   });
+  pushTerminalTitle();
+  let lastEmittedTitle = opts.boxName;
+  setTerminalTitle(lastEmittedTitle);
   const detachable = opts.detachable ?? opts.mode === "claude";
   let leaderActive = false;
   const buildIdle = (sessionTitle, claudeActivity) => ({
@@ -988,6 +1110,32 @@ async function runWrappedAttach(opts) {
     recomputeFooter();
     redrawFooter();
   };
+  const handlePasteImage = async () => {
+    if (!opts.onPasteImage) return;
+    if (flashTimer) {
+      clearTimeout(flashTimer);
+      flashTimer = null;
+    }
+    flashMessage = "Pasting image\u2026";
+    recomputeFooter();
+    redrawFooter();
+    let result = "error";
+    try {
+      result = await opts.onPasteImage();
+    } catch (e) {
+      logErr(`paste-image failed: ${e.message}`);
+    }
+    flashMessage = result === "pasted" ? "Image pasted" : result === "no-image" ? "No image in clipboard" : "Image paste failed";
+    flashTimer = setTimeout(() => {
+      flashTimer = null;
+      flashMessage = null;
+      recomputeFooter();
+      redrawFooter();
+    }, FLASH_DURATION_MS);
+    if (typeof flashTimer.unref === "function") flashTimer.unref();
+    recomputeFooter();
+    redrawFooter();
+  };
   const router = createInputRouter({
     onForward: (b) => {
       pty.write(b.toString("utf8"));
@@ -1006,7 +1154,8 @@ async function runWrappedAttach(opts) {
     },
     onAction: (name) => {
       runAction(name);
-    }
+    },
+    onPasteImage: opts.onPasteImage ? handlePasteImage : void 0
   });
   if (process.stdin.isTTY) process.stdin.setRawMode(true);
   process.stdin.resume();
@@ -1067,8 +1216,14 @@ async function runWrappedAttach(opts) {
         name: opts.boxName,
         projectIndex: opts.projectIndex
       });
-      const nextTitle = status?.claude?.sessionTitle?.trim() || void 0;
-      const nextActivity = status?.claude?.state || void 0;
+      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;
+      const desiredTitle = nextTitle ?? opts.boxName;
+      if (desiredTitle !== lastEmittedTitle) {
+        lastEmittedTitle = desiredTitle;
+        setTerminalTitle(desiredTitle);
+      }
       if (nextTitle === lastSessionTitle && nextActivity === lastActivity) return;
       lastSessionTitle = nextTitle;
       lastActivity = nextActivity;
@@ -1107,16 +1262,165 @@ async function runWrappedAttach(opts) {
   process.stdout.write(
     "\x1B[r" + cursorMoveTo(rsFinal, 1) + `\x1B[2K` + cursorMoveTo(rsFinal, csFinal)
   );
+  popTerminalTitle();
   if (exitCode === 0 && opts.detachNotice) {
     process.stdout.write("\x1B[1A\x1B[2K\r" + opts.detachNotice + "\n");
   }
   return exitCode;
 }
-function runFallback(command, argv) {
-  const child = spawnSync(command, argv, { stdio: "inherit" });
+function runFallback(command, argv, env) {
+  const child = spawnSync(command, argv, {
+    stdio: "inherit",
+    env: env ? { ...process.env, ...env } : process.env
+  });
   return child.status ?? 0;
 }
 
+// src/lib/paste-image.ts
+import { rm as rm2 } from "fs/promises";
+import { dirname } from "path";
+
+// src/lib/host-clipboard.ts
+import { mkdtemp, rm, stat, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { execa } from "execa";
+async function captureClipboardImage() {
+  if (process.platform !== "darwin" && process.platform !== "linux") return null;
+  const dir = await mkdtemp(join(tmpdir(), "agentbox-clip-"));
+  const pngPath = join(dir, "clip.png");
+  const ok = process.platform === "darwin" ? await captureDarwin(dir, pngPath) : await captureLinux(pngPath);
+  if (ok) return pngPath;
+  await rm(dir, { recursive: true, force: true }).catch(() => {
+  });
+  return null;
+}
+async function clipboardCaptureAvailable() {
+  if (process.platform === "darwin") return true;
+  if (process.platform === "linux") return await linuxClipboardTool() !== null;
+  return false;
+}
+function captureScriptArgs(pngPath, tiffPath) {
+  return [
+    "try",
+    "  set theData to (the clipboard as \xABclass PNGf\xBB)",
+    `  set fh to open for access (POSIX file ${JSON.stringify(pngPath)}) with write permission`,
+    "  set eof fh to 0",
+    "  write theData to fh",
+    "  close access fh",
+    '  return "PNG"',
+    "on error",
+    "  try",
+    "    set theData to (the clipboard as \xABclass TIFF\xBB)",
+    `    set fh to open for access (POSIX file ${JSON.stringify(tiffPath)}) with write permission`,
+    "    set eof fh to 0",
+    "    write theData to fh",
+    "    close access fh",
+    '    return "TIFF"',
+    "  on error",
+    '    return "NONE"',
+    "  end try",
+    "end try"
+  ].map((line) => ["-e", line]).flat();
+}
+async function captureDarwin(dir, pngPath) {
+  const tiffPath = join(dir, "clip.tiff");
+  const res = await execa("osascript", captureScriptArgs(pngPath, tiffPath), {
+    reject: false
+  });
+  const kind = res.stdout.trim();
+  if (kind === "PNG") return fileHasBytes(pngPath);
+  if (kind === "TIFF" && await fileHasBytes(tiffPath)) {
+    const conv = await execa(
+      "sips",
+      ["-s", "format", "png", tiffPath, "--out", pngPath],
+      { reject: false }
+    );
+    if (conv.exitCode === 0) return fileHasBytes(pngPath);
+  }
+  return false;
+}
+async function linuxClipboardTool() {
+  if (process.env["WAYLAND_DISPLAY"] && await hasCmd("wl-paste")) return "wayland";
+  if (process.env["DISPLAY"] && await hasCmd("xclip")) return "x11";
+  return null;
+}
+async function captureLinux(pngPath) {
+  const tool = await linuxClipboardTool();
+  if (!tool) return false;
+  let buf = null;
+  if (tool === "wayland") {
+    const types = await execa("wl-paste", ["--list-types"], { reject: false });
+    if (types.exitCode !== 0 || !/image\/png/i.test(types.stdout)) return false;
+    const r = await execa("wl-paste", ["--type", "image/png"], {
+      encoding: "buffer",
+      reject: false
+    });
+    if (r.exitCode === 0) buf = asBuffer(r.stdout);
+  } else {
+    const sel = ["-selection", "clipboard"];
+    const targets = await execa("xclip", [...sel, "-t", "TARGETS", "-o"], {
+      reject: false
+    });
+    if (targets.exitCode !== 0 || !/image\/png/i.test(targets.stdout)) return false;
+    const r = await execa("xclip", [...sel, "-t", "image/png", "-o"], {
+      encoding: "buffer",
+      reject: false
+    });
+    if (r.exitCode === 0) buf = asBuffer(r.stdout);
+  }
+  if (!buf || !isPng(buf)) return false;
+  await writeFile(pngPath, buf);
+  return true;
+}
+async function hasCmd(cmd) {
+  const r = await execa("sh", ["-c", `command -v ${cmd}`], { reject: false });
+  return r.exitCode === 0;
+}
+function asBuffer(out) {
+  if (Buffer.isBuffer(out)) return out;
+  if (out instanceof Uint8Array) return Buffer.from(out);
+  return null;
+}
+function isPng(buf) {
+  return buf.length >= 8 && buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71;
+}
+async function fileHasBytes(path) {
+  try {
+    const s = await stat(path);
+    return s.isFile() && s.size > 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/paste-image.ts
+function loadClipboardScript(boxPngPath) {
+  return [
+    "pgrep -x Xvnc >/dev/null 2>&1 || /usr/local/bin/agentbox-vnc-start >/dev/null 2>&1 || true",
+    "for _ in $(seq 1 30); do [ -S /tmp/.X11-unix/X1 ] && break; sleep 0.2; done",
+    `setsid sh -c 'DISPLAY=:1 xclip -selection clipboard -t image/png -i ${boxPngPath}' </dev/null >/dev/null 2>&1 &`
+  ].join("; ");
+}
+async function pasteHostClipboardImage(provider, box) {
+  if (typeof provider.uploadPath !== "function") return "error";
+  const hostPng = await captureClipboardImage();
+  if (!hostPng) return "no-image";
+  const boxPng = `/tmp/agentbox-clip-${String(Date.now())}.png`;
+  try {
+    await provider.uploadPath(box, hostPng, boxPng);
+    await provider.exec(box, ["sh", "-lc", loadClipboardScript(boxPng)], {
+      user: "vscode"
+    });
+    return "pasted";
+  } catch {
+    return "error";
+  } finally {
+    await rm2(dirname(hostPng), { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+
 // src/commands/_cloud-attach.ts
 var RELAY_HOST_URL = `http://127.0.0.1:${String(DEFAULT_RELAY_PORT)}`;
 function buildCloudAttachInnerCommand(binary, extraArgs) {
@@ -1124,7 +1428,7 @@ function buildCloudAttachInnerCommand(binary, extraArgs) {
     return `bash -lc 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 'mapfile -t A <<< "$(echo ${blob} | base64 -d)"; exec ${binary} "\${A[@]}"'`;
 }
 async function cloudAgentAttach(args) {
   const provider = await providerForBox(args.box);
@@ -1140,7 +1444,7 @@ async function cloudAgentAttach(args) {
       detached: true
     });
     try {
-      await runDetached(pre.argv);
+      await runDetached(pre.argv, pre.env);
     } finally {
       if (pre.cleanup) await pre.cleanup();
     }
@@ -1149,27 +1453,33 @@ async function cloudAgentAttach(args) {
     sessionName: args.sessionName,
     command
   });
+  const canPaste = args.mode === "claude" && await clipboardCaptureAvailable();
   try {
     const code = await runWrappedAttach({
       container: args.box.name,
       command: spec.argv[0],
       dockerArgv: spec.argv.slice(1),
+      env: spec.env,
       relayBaseUrl: RELAY_HOST_URL,
       boxId: args.box.id,
       boxName: args.box.name,
       projectIndex: args.box.projectIndex,
       mode: args.mode,
       detachable: true,
-      openIn: safeOpenIn
+      openIn: safeOpenIn,
+      onPasteImage: canPaste ? () => pasteHostClipboardImage(provider, args.box) : void 0
     });
     process.exit(code);
   } finally {
     if (spec.cleanup) await spec.cleanup();
   }
 }
-function runDetached(argv) {
+function runDetached(argv, env) {
   return new Promise((resolve) => {
-    const child = spawn3(argv[0], argv.slice(1), { stdio: "ignore" });
+    const child = spawn3(argv[0], argv.slice(1), {
+      stdio: "ignore",
+      env: env ? { ...process.env, ...env } : process.env
+    });
     child.on("error", () => resolve());
     child.on("exit", () => resolve());
   });
@@ -1182,8 +1492,12 @@ export {
   providerForCreate,
   loadPtyBackend,
   detectHostTerminal,
+  setTerminalTitle,
+  pushTerminalTitle,
+  popTerminalTitle,
   NEW_BOX_ID,
   NEW_BOX_LABEL,
+  stripTitleGlyph,
   sidebarLines,
   menuLines,
   lifecycleMenuLines,
@@ -1194,7 +1508,9 @@ export {
   subscribePrompts,
   postAnswer,
   runWrappedAttach,
+  clipboardCaptureAvailable,
+  pasteHostClipboardImage,
   buildCloudAttachInnerCommand,
   cloudAgentAttach
 };
-//# sourceMappingURL=chunk-FODMEHD3.js.map
+//# sourceMappingURL=chunk-GU5LW4B5.js.map