@madarco/agentbox 0.8.0 → 0.10.0

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

@@ -2,32 +2,41 @@
 import {
   DEFAULT_RELAY_PORT,
   readBoxStatus
-} from "./chunk-6OZDFNBF.js";
+} from "./chunk-7UIAO7PC.js";
 
 // src/commands/_cloud-attach.ts
 import { spawn as spawn3 } 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"];
+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-BQNX7RQE.js");
       return mod.dockerProvider;
     }
     case "daytona": {
-      const mod = await import("./dist-L4LCG5SJ.js");
+      const mod = await import("./dist-TMHSUVTP.js");
       await mod.ensureDaytonaCredentials();
       return mod.daytonaProvider;
     }
     case "hetzner": {
-      const mod = await import("./dist-ZODPD2I6.js");
+      const mod = await import("./dist-5FQGYRW5.js");
       await mod.ensureHetznerCredentials();
       return mod.hetznerProvider;
     }
+    case "vercel": {
+      const mod = await import("./dist-PZW3GWWU.js");
+      await mod.ensureVercelCredentials();
+      return mod.vercelProvider;
+    }
     default:
       throw new Error(`unknown sandbox provider: ${String(name)}`);
   }
@@ -179,6 +188,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 +217,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 +346,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 +437,7 @@ function createInputRouter(opts) {
         }
         return;
       }
-      if (!leaderEnabled) {
+      if (!leaderEnabled && !pasteEnabled) {
         opts.onForward(buf);
         return;
       }
@@ -569,9 +692,13 @@ function statusLine(box, w, stateLabel, groups = HINT_GROUPS, fallbackGroups) {
 // src/wrapped-pty/footer.ts
 var SPINNER_FRAMES = ["\u25D0", "\u25D3", "\u25D1", "\u25D2"];
 var URGENT = "\x1B[38;5;220m\x1B[1m";
+var TITLE = "\x1B[1m\x1B[38;5;253m";
 var TXT = "\x1B[38;5;250m";
 var SUBTLE = "\x1B[38;5;245m";
 var RESET = "\x1B[0m";
+var UNDERLINE = "\x1B[4m";
+var NO_UNDERLINE = "\x1B[24m";
+var QUESTION_ACCENT = "\x1B[38;5;51m\x1B[1m";
 var NOTICE_BG = "\x1B[48;5;220m";
 var NOTICE_FG = "\x1B[38;5;16m\x1B[1m";
 var FLASH_FG = "\x1B[38;5;150m\x1B[1m";
@@ -604,6 +731,17 @@ function padTo(visible, width) {
   }
   return visible + " ".repeat(width - visible.length);
 }
+function answerChip(defaultAnswer) {
+  const yesKey = "y Yes";
+  const noKey = "n No";
+  const sep = " \xB7 ";
+  const yesIsDefault = defaultAnswer === "y";
+  const yes = yesIsDefault ? `${UNDERLINE}${yesKey}${NO_UNDERLINE}` : yesKey;
+  const no = yesIsDefault ? noKey : `${UNDERLINE}${noKey}${NO_UNDERLINE}`;
+  const ansi = `${NOTICE_BG}${NOTICE_FG} ${yes}${sep}${no} ${RESET}`;
+  const width = ` ${yesKey}${sep}${noKey} `.length;
+  return { ansi, width };
+}
 function renderFooter(state, cols) {
   if (cols <= 0) return "";
   if (state.kind === "idle") {
@@ -634,18 +772,16 @@ function renderFooter(state, cols) {
     return `${BAR_BG}${FLASH_FG}${prefix}${TXT}${message2}${RESET}`;
   }
   if (state.kind === "notice") {
-    const spinner = SPINNER_FRAMES[state.frame % SPINNER_FRAMES.length];
-    const prefix = ` ${spinner} `;
+    const spinner2 = SPINNER_FRAMES[state.frame % SPINNER_FRAMES.length];
+    const prefix = ` ${spinner2} `;
     const inner2 = Math.max(0, cols - prefix.length);
     const message2 = padTo(state.message, inner2);
     return `${NOTICE_BG}${NOTICE_FG}${prefix}${message2}${RESET}`;
   }
-  const def = state.prompt.defaultAnswer ?? "n";
-  const yn = def === "y" ? "[Y/n]" : "[y/N]";
+  const chip = answerChip(state.prompt.defaultAnswer);
   const tag = " [!] ";
   const sep = "  ";
-  const hintW = ` ${yn} `.length;
-  const inner = Math.max(0, cols - tag.length - hintW);
+  const inner = Math.max(0, cols - tag.length - chip.width);
   const detailRaw = state.prompt.detail ?? "";
   let message = state.prompt.message;
   let detail = detailRaw;
@@ -660,7 +796,7 @@ function renderFooter(state, cols) {
   }
   const middlePlain = detail.length > 0 ? `${message}${sep}${detail}` : message;
   const padded = padTo(middlePlain, inner);
-  return `${BAR_BG}${URGENT}${tag}${TXT}${padded}${SUBTLE} ${yn} ${RESET}`;
+  return `${BAR_BG}${URGENT}${tag}${TXT}${padded}${RESET}${chip.ansi}`;
 }
 function cursorMoveTo(row, col) {
   return `\x1B[${String(row)};${String(col)}H`;
@@ -669,6 +805,73 @@ var CURSOR_SAVE = "\x1B7";
 var CURSOR_RESTORE = "\x1B8";
 var SYNC_BEGIN = "\x1B[?2026h";
 var SYNC_END = "\x1B[?2026l";
+var ALERT_BAND_ROWS = 3;
+function blankBar(cols, bg) {
+  return `${bg}${" ".repeat(Math.max(0, cols))}${RESET}`;
+}
+function renderPromptBand(prompt, cols, rows) {
+  const tag = " [!] ";
+  const indent = " ".repeat(tag.length);
+  const contW = Math.max(0, cols - indent.length);
+  const chip = answerChip(prompt.defaultAnswer);
+  const title = (prompt.context?.command ?? "confirm").toUpperCase();
+  const titleW = Math.max(0, cols - tag.length - chip.width);
+  const titlePadded = padTo(title, titleW);
+  const line1 = `${BAR_BG}${URGENT}${tag}${TITLE}${titlePadded}${RESET}${chip.ansi}`;
+  const line2 = `${BAR_BG}${TXT}${indent}${padTo(prompt.message, contW)}${RESET}`;
+  const line3 = `${BAR_BG}${SUBTLE}${indent}${padTo(prompt.detail ?? "", contW)}${RESET}`;
+  return [line1, line2, line3].slice(0, rows);
+}
+function renderNoticeBand(message, frame, cols, rows) {
+  const spinner2 = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+  const prefix = ` ${spinner2} `;
+  const indent = " ".repeat(prefix.length);
+  const firstW = Math.max(0, cols - prefix.length);
+  const contW = Math.max(0, cols - indent.length);
+  const out = [];
+  let i = 0;
+  for (let r = 0; r < rows; r++) {
+    const isLast = r === rows - 1;
+    const w = r === 0 ? firstW : contW;
+    let cell;
+    if (i >= message.length) {
+      cell = " ".repeat(w);
+    } else if (isLast) {
+      cell = padTo(message.slice(i), w);
+      i = message.length;
+    } else {
+      cell = message.slice(i, i + w).padEnd(w);
+      i += w;
+    }
+    const lead = r === 0 ? prefix : indent;
+    out.push(`${NOTICE_BG}${NOTICE_FG}${lead}${cell}${RESET}`);
+  }
+  return out;
+}
+function renderQuestionBand(payload, cols, rows) {
+  const q = payload.questions[0];
+  if (!q) return Array.from({ length: rows }, () => blankBar(cols, BAR_BG));
+  const tag = " [?] ";
+  const indent = " ".repeat(tag.length);
+  const innerW = Math.max(0, cols - tag.length);
+  const contW = Math.max(0, cols - indent.length);
+  const header = q.header && q.header.trim().length > 0 ? q.header : "Question";
+  const headerPadded = padTo(header, innerW);
+  const line1 = `${BAR_BG}${QUESTION_ACCENT}${tag}${TXT}${headerPadded}${RESET}`;
+  const questionText = padTo(q.question, contW);
+  const line2 = `${BAR_BG}${TXT}${indent}${questionText}${RESET}`;
+  const optLabels = q.options.map((o) => o.label).join(" \xB7 ");
+  const optsLine = optLabels.length > 0 ? `options: ${optLabels}` : "";
+  const optsPadded = padTo(optsLine, contW);
+  const line3 = `${BAR_BG}${SUBTLE}${indent}${optsPadded}${RESET}`;
+  return [line1, line2, line3].slice(0, rows);
+}
+function renderAlertBand(state, cols, rows = ALERT_BAND_ROWS) {
+  if (cols <= 0 || rows <= 0) return Array.from({ length: Math.max(0, rows) }, () => "");
+  if (state.kind === "prompt") return renderPromptBand(state.prompt, cols, rows);
+  if (state.kind === "notice") return renderNoticeBand(state.message, state.frame, cols, rows);
+  return renderQuestionBand(state.question, cols, rows);
+}
 
 // src/wrapped-pty/prompt-client.ts
 import { request as httpRequest } from "http";
@@ -837,9 +1040,13 @@ function postAnswer(opts) {
 
 // src/wrapped-pty/run.ts
 var FOOTER_ROWS = 1;
+var MIN_INNER_ROWS = 5;
 var STATUS_POLL_INTERVAL_MS = 3e3;
 var SPINNER_INTERVAL_MS = 120;
 var FLASH_DURATION_MS = 2e3;
+var RAPID_RECONNECT_MS = 8e3;
+var MAX_RAPID_RECONNECTS = 3;
+var CHECKPOINT_DROP_GRACE_MS = 4e3;
 var ACTION_FLASH = {
   screen: "Opening noVNC viewer\u2026",
   code: "Launching VS Code / Cursor\u2026",
@@ -880,24 +1087,34 @@ 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;
   const innerRows = Math.max(1, rows - FOOTER_ROWS);
-  const pty = backend.ptySpawn(command, opts.dockerArgv, {
+  let pty = backend.ptySpawn(command, opts.dockerArgv, {
     name: "xterm-256color",
     cols,
     rows: innerRows,
-    env: process.env
+    env: opts.env ? { ...process.env, ...opts.env } : process.env
   });
+  let lastSpawnAt = Date.now();
+  const resizePty = (c, r) => {
+    try {
+      pty.resize(c, r);
+    } catch {
+    }
+  };
+  pushTerminalTitle();
+  let lastEmittedTitle = opts.boxName;
+  setTerminalTitle(lastEmittedTitle);
   const detachable = opts.detachable ?? opts.mode === "claude";
   let leaderActive = false;
   const buildIdle = (sessionTitle, claudeActivity) => ({
@@ -914,21 +1131,46 @@ async function runWrappedAttach(opts) {
   let lastActivity;
   let capturingPrompt = null;
   let activeNotice = null;
+  let reconnectBanner = null;
   let noticeFrame = 0;
+  let questionPayload = null;
+  let bandState = null;
+  let bandReservedRows = 0;
   let spinnerTimer = null;
   let flashMessage = null;
   let flashTimer = null;
-  const redrawFooter = () => {
+  let reconnecting = false;
+  let reconnectAbort = null;
+  let userDetached = false;
+  let checkpointNoticeAt = 0;
+  let checkpointNoticeClearedAt = 0;
+  const reservedRows = () => FOOTER_ROWS + bandReservedRows;
+  const bandFits = () => {
+    const rs = process.stdout.rows ?? rows;
+    return rs - FOOTER_ROWS - ALERT_BAND_ROWS >= MIN_INNER_ROWS;
+  };
+  const redrawChrome = () => {
     const cs = process.stdout.columns ?? cols;
     const rs = process.stdout.rows ?? rows;
-    const line = renderFooter(footerState, cs);
-    const payload = SYNC_BEGIN + CURSOR_SAVE + cursorMoveTo(rs, 1) + line + CURSOR_RESTORE + SYNC_END;
+    const footerLine = renderFooter(footerState, cs);
+    let payload = SYNC_BEGIN + CURSOR_SAVE;
+    if (bandReservedRows > 0 && bandState) {
+      const bandLines = renderAlertBand(bandState, cs, bandReservedRows);
+      for (let i = 0; i < bandLines.length; i++) {
+        const row = rs - FOOTER_ROWS - (bandLines.length - i);
+        payload += cursorMoveTo(row + 1, 1) + bandLines[i];
+      }
+    }
+    payload += cursorMoveTo(rs, 1) + footerLine + CURSOR_RESTORE + SYNC_END;
     process.stdout.write(payload);
   };
   const recomputeFooter = () => {
-    if (capturingPrompt) {
+    const collapsed = bandState !== null && bandReservedRows === 0;
+    if (collapsed && reconnectBanner) {
+      footerState = { kind: "notice", message: reconnectBanner, frame: noticeFrame };
+    } else if (collapsed && capturingPrompt) {
       footerState = { kind: "prompt", prompt: capturingPrompt };
-    } else if (activeNotice) {
+    } else if (collapsed && activeNotice) {
       footerState = { kind: "notice", message: activeNotice.message, frame: noticeFrame };
     } else if (flashMessage) {
       footerState = { kind: "flash", message: flashMessage };
@@ -936,13 +1178,48 @@ async function runWrappedAttach(opts) {
       footerState = buildIdle(lastSessionTitle, lastActivity);
     }
   };
+  const recomputeBand = () => {
+    if (reconnectBanner) {
+      bandState = { kind: "notice", message: reconnectBanner, frame: noticeFrame };
+    } else if (capturingPrompt) {
+      bandState = { kind: "prompt", prompt: capturingPrompt };
+    } else if (activeNotice) {
+      bandState = { kind: "notice", message: activeNotice.message, frame: noticeFrame };
+    } else if (questionPayload) {
+      bandState = { kind: "question", question: questionPayload };
+    } else {
+      bandState = null;
+    }
+  };
+  const relayoutForBand = () => {
+    const cs = process.stdout.columns ?? cols;
+    const rs = process.stdout.rows ?? rows;
+    const inner = Math.max(1, rs - reservedRows());
+    resizePty(cs, inner);
+    process.stdout.write(`\x1B[1;${String(inner)}r`);
+    let clear = SYNC_BEGIN + CURSOR_SAVE;
+    for (let r = inner + 1; r <= rs; r++) clear += cursorMoveTo(r, 1) + "\x1B[2K";
+    clear += CURSOR_RESTORE + SYNC_END;
+    process.stdout.write(clear);
+  };
+  const applyBandChange = () => {
+    recomputeBand();
+    const wantRows = bandState && bandFits() ? ALERT_BAND_ROWS : 0;
+    if (wantRows !== bandReservedRows) {
+      bandReservedRows = wantRows;
+      relayoutForBand();
+    }
+    recomputeFooter();
+    redrawChrome();
+  };
   const startSpinner = () => {
     if (spinnerTimer) return;
     spinnerTimer = setInterval(() => {
       noticeFrame++;
-      if (footerState.kind === "notice") {
-        recomputeFooter();
-        redrawFooter();
+      if (bandState?.kind === "notice") {
+        bandState = { kind: "notice", message: bandState.message, frame: noticeFrame };
+        if (bandReservedRows === 0) recomputeFooter();
+        redrawChrome();
       }
     }, SPINNER_INTERVAL_MS);
     if (typeof spinnerTimer.unref === "function") spinnerTimer.unref();
@@ -953,14 +1230,20 @@ async function runWrappedAttach(opts) {
       spinnerTimer = null;
     }
   };
-  pty.onData((d) => {
-    process.stdout.write(d);
-    redrawFooter();
-  });
+  const wireOutput = () => {
+    pty.onData((d) => {
+      process.stdout.write(d);
+      redrawChrome();
+    });
+  };
+  wireOutput();
   const leaderChords = detachable ? { c: "code", s: "screen", u: "url", d: "detach" } : { c: "code", s: "screen", u: "url" };
   const runAction = (name) => {
     if (name === "detach") {
-      pty.write("d");
+      if (!reconnecting) {
+        userDetached = true;
+        pty.write("d");
+      }
       return;
     }
     const cliEntry = process.argv[1];
@@ -982,31 +1265,61 @@ async function runWrappedAttach(opts) {
       flashTimer = null;
       flashMessage = null;
       recomputeFooter();
-      redrawFooter();
+      redrawChrome();
     }, FLASH_DURATION_MS);
     if (typeof flashTimer.unref === "function") flashTimer.unref();
     recomputeFooter();
-    redrawFooter();
+    redrawChrome();
+  };
+  const handlePasteImage = async () => {
+    if (!opts.onPasteImage) return;
+    if (flashTimer) {
+      clearTimeout(flashTimer);
+      flashTimer = null;
+    }
+    flashMessage = "Pasting image\u2026";
+    recomputeFooter();
+    redrawChrome();
+    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();
+      redrawChrome();
+    }, FLASH_DURATION_MS);
+    if (typeof flashTimer.unref === "function") flashTimer.unref();
+    recomputeFooter();
+    redrawChrome();
   };
   const router = createInputRouter({
     onForward: (b) => {
+      if (reconnecting) {
+        if (b.length === 1 && b[0] === 3) reconnectAbort?.abort();
+        return;
+      }
       pty.write(b.toString("utf8"));
     },
     onAnswer: (body) => {
       void postAnswer({ relayBaseUrl: opts.relayBaseUrl, body });
       capturingPrompt = null;
-      recomputeFooter();
-      redrawFooter();
+      applyBandChange();
     },
     leaderChords,
     onLeaderChange: (open) => {
       leaderActive = open;
       recomputeFooter();
-      redrawFooter();
+      redrawChrome();
     },
     onAction: (name) => {
       runAction(name);
-    }
+    },
+    onPasteImage: opts.onPasteImage ? handlePasteImage : void 0
   });
   if (process.stdin.isTTY) process.stdin.setRawMode(true);
   process.stdin.resume();
@@ -1017,10 +1330,12 @@ async function runWrappedAttach(opts) {
   const onResize = () => {
     const cs = process.stdout.columns ?? cols;
     const rs = process.stdout.rows ?? rows;
-    const inner = Math.max(1, rs - FOOTER_ROWS);
-    pty.resize(cs, inner);
+    bandReservedRows = bandState && bandFits() ? ALERT_BAND_ROWS : 0;
+    const inner = Math.max(1, rs - reservedRows());
+    resizePty(cs, inner);
     process.stdout.write(`\x1B[1;${String(inner)}r`);
-    redrawFooter();
+    recomputeFooter();
+    redrawChrome();
   };
   process.stdout.on("resize", onResize);
   const stream = subscribePrompts({
@@ -1028,8 +1343,7 @@ async function runWrappedAttach(opts) {
     boxId: opts.boxId,
     onPrompt: (ev) => {
       capturingPrompt = ev;
-      recomputeFooter();
-      redrawFooter();
+      applyBandChange();
       router.capture(ev).catch((e) => {
         const msg = e instanceof Error ? e.message : String(e);
         if (msg !== "resolved-elsewhere") {
@@ -1041,22 +1355,21 @@ async function runWrappedAttach(opts) {
       if (capturingPrompt && capturingPrompt.id === id) {
         capturingPrompt = null;
         router.abort("resolved-elsewhere");
-        recomputeFooter();
-        redrawFooter();
+        applyBandChange();
       }
     },
     onNotice: (ev) => {
+      if (ev.kind === "checkpoint") checkpointNoticeAt = Date.now();
       activeNotice = ev;
       startSpinner();
-      recomputeFooter();
-      redrawFooter();
+      applyBandChange();
     },
     onNoticeCleared: (id) => {
       if (activeNotice && activeNotice.id === id) {
+        if (activeNotice.kind === "checkpoint") checkpointNoticeClearedAt = Date.now();
         activeNotice = null;
         stopSpinner();
-        recomputeFooter();
-        redrawFooter();
+        applyBandChange();
       }
     }
   });
@@ -1067,14 +1380,26 @@ 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);
+      }
+      const nextQuestion = opts.mode === "claude" && status?.claude.state === "question" ? status.claude.question ?? null : null;
+      const questionChanged = (nextQuestion?.capturedAt ?? null) !== (questionPayload?.capturedAt ?? null);
+      if (questionChanged) {
+        questionPayload = nextQuestion;
+        applyBandChange();
+      }
       if (nextTitle === lastSessionTitle && nextActivity === lastActivity) return;
       lastSessionTitle = nextTitle;
       lastActivity = nextActivity;
       if (footerState.kind === "idle") {
         recomputeFooter();
-        redrawFooter();
+        redrawChrome();
       }
     } catch (e) {
       logErr(`status poll failed: ${e.message}`);
@@ -1089,10 +1414,82 @@ async function runWrappedAttach(opts) {
   if (opts.mode === "shell" && !detachable) {
     process.stdout.write("\x1B[H\x1B[2J");
   }
-  redrawFooter();
-  const exitCode = await new Promise((resolve) => {
-    pty.onExit(({ exitCode: exitCode2 }) => resolve(exitCode2));
-  });
+  redrawChrome();
+  const reconnectFlow = async (code) => {
+    const controller = new AbortController();
+    reconnecting = true;
+    reconnectAbort = controller;
+    reconnectBanner = "box rebooting \u2014 reconnecting\u2026";
+    startSpinner();
+    applyBandChange();
+    let spec = null;
+    try {
+      spec = await opts.reconnect?.(controller.signal, code) ?? null;
+    } catch (e) {
+      logErr(`reconnect failed: ${e.message}`);
+    } finally {
+      reconnecting = false;
+      reconnectAbort = null;
+      reconnectBanner = null;
+      if (!activeNotice) stopSpinner();
+      applyBandChange();
+    }
+    if (spec) {
+      flashMessage = "reconnected";
+      if (flashTimer) clearTimeout(flashTimer);
+      flashTimer = setTimeout(() => {
+        flashTimer = null;
+        flashMessage = null;
+        recomputeFooter();
+        redrawChrome();
+      }, FLASH_DURATION_MS);
+      if (typeof flashTimer.unref === "function") flashTimer.unref();
+      recomputeFooter();
+      redrawChrome();
+    }
+    return spec;
+  };
+  let exitCode = 0;
+  let rapidFails = 0;
+  for (; ; ) {
+    const code = await new Promise((resolve) => {
+      pty.onExit(({ exitCode: exitCode2 }) => resolve(exitCode2));
+    });
+    if (userDetached || !opts.reconnect) {
+      exitCode = code;
+      break;
+    }
+    const checkpointing = checkpointNoticeAt > checkpointNoticeClearedAt || Date.now() - checkpointNoticeClearedAt < CHECKPOINT_DROP_GRACE_MS;
+    if (!checkpointing && code === 0) {
+      exitCode = code;
+      break;
+    }
+    rapidFails = Date.now() - lastSpawnAt < RAPID_RECONNECT_MS ? rapidFails + 1 : 0;
+    if (rapidFails >= MAX_RAPID_RECONNECTS) {
+      logErr("giving up reconnect after repeated rapid failures");
+      exitCode = code;
+      break;
+    }
+    const next = await reconnectFlow(code);
+    if (!next) {
+      exitCode = code;
+      break;
+    }
+    const rsNow = process.stdout.rows ?? rows;
+    const innerNow = Math.max(1, rsNow - reservedRows());
+    pty = backend.ptySpawn(next.command, next.argv, {
+      name: "xterm-256color",
+      cols: process.stdout.columns ?? cols,
+      rows: innerNow,
+      env: next.env ? { ...process.env, ...next.env } : process.env
+    });
+    wireOutput();
+    lastSpawnAt = Date.now();
+    checkpointNoticeAt = 0;
+    checkpointNoticeClearedAt = 0;
+    process.stdout.write(`\x1B[1;${String(innerNow)}r`);
+    redrawChrome();
+  }
   process.stdin.off("data", onStdinData);
   process.stdout.off("resize", onResize);
   clearInterval(statusTimer);
@@ -1104,72 +1501,295 @@ async function runWrappedAttach(opts) {
   router.dispose();
   const rsFinal = process.stdout.rows ?? rows;
   const csFinal = process.stdout.columns ?? cols;
-  process.stdout.write(
-    "\x1B[r" + cursorMoveTo(rsFinal, 1) + `\x1B[2K` + cursorMoveTo(rsFinal, csFinal)
-  );
+  let teardownPaint = "\x1B[r";
+  for (let r = rsFinal - bandReservedRows; r <= rsFinal; r++) {
+    if (r >= 1) teardownPaint += cursorMoveTo(r, 1) + "\x1B[2K";
+  }
+  teardownPaint += cursorMoveTo(rsFinal, csFinal);
+  process.stdout.write(teardownPaint);
+  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)}`;
+var RECONNECT_TIMEOUT_MS = 5 * 6e4;
+function abortableSleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    const t = setTimeout(resolve, ms);
+    signal.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(t);
+        resolve();
+      },
+      { once: true }
+    );
+  });
+}
 function buildCloudAttachInnerCommand(binary, extraArgs) {
   if (!extraArgs || extraArgs.length === 0) {
     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);
   if (!provider.buildAttach) {
     throw new Error(`provider '${provider.name}' does not support interactive attach`);
   }
+  const buildAttach = provider.buildAttach.bind(provider);
+  let box = args.box;
+  const state = await provider.probeState(box);
+  if (state === "missing") {
+    throw new Error(`cloud sandbox for ${box.name} is missing; was it destroyed?`);
+  }
+  if (state !== "running") {
+    const s = spinner();
+    s.start(state === "paused" ? "resuming box" : "starting box");
+    box = await provider.start(box);
+    s.stop("box running");
+  }
   const command = buildCloudAttachInnerCommand(args.binary, args.extraArgs);
-  const safeOpenIn = args.box.provider === "daytona" ? "same" : args.openIn;
+  const safeOpenIn = box.provider === "daytona" ? "same" : args.openIn;
   if (safeOpenIn && safeOpenIn !== "same" && args.extraArgs && args.extraArgs.length > 0) {
-    const pre = await provider.buildAttach(args.box, "agent", {
+    const pre = await provider.buildAttach(box, "agent", {
       sessionName: args.sessionName,
       command,
       detached: true
     });
     try {
-      await runDetached(pre.argv);
+      await runDetached(pre.argv, pre.env);
     } finally {
       if (pre.cleanup) await pre.cleanup();
     }
   }
-  const spec = await provider.buildAttach(args.box, "agent", {
+  let spec = await provider.buildAttach(box, "agent", {
     sessionName: args.sessionName,
     command
   });
+  const canPaste = args.mode === "claude" && await clipboardCaptureAvailable();
+  const reconnect = async (signal) => {
+    const deadline = Date.now() + RECONNECT_TIMEOUT_MS;
+    let backoff = 500;
+    for (; ; ) {
+      if (signal.aborted || Date.now() > deadline) return null;
+      try {
+        box = await provider.start(box);
+        break;
+      } catch {
+        await abortableSleep(backoff, signal);
+        backoff = Math.min(backoff * 2, 5e3);
+      }
+    }
+    if (signal.aborted) return null;
+    const prev = spec;
+    spec = await buildAttach(box, "agent", { sessionName: args.sessionName, command });
+    if (prev.cleanup) {
+      try {
+        await prev.cleanup();
+      } catch {
+      }
+    }
+    return { command: spec.argv[0], argv: spec.argv.slice(1), env: spec.env };
+  };
   try {
     const code = await runWrappedAttach({
-      container: args.box.name,
+      container: 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,
+      boxId: box.id,
+      boxName: box.name,
+      projectIndex: box.projectIndex,
       mode: args.mode,
       detachable: true,
-      openIn: safeOpenIn
+      openIn: safeOpenIn,
+      reconnect,
+      onError: (msg) => {
+        try {
+          appendFileSync(
+            join2(homedir(), ".agentbox", "logs", "attach.log"),
+            `${(/* @__PURE__ */ new Date()).toISOString()} [${box.name}] ${msg}
+`
+          );
+        } catch {
+        }
+      },
+      onPasteImage: canPaste ? () => pasteHostClipboardImage(provider, 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 +1802,12 @@ export {
   providerForCreate,
   loadPtyBackend,
   detectHostTerminal,
+  setTerminalTitle,
+  pushTerminalTitle,
+  popTerminalTitle,
   NEW_BOX_ID,
   NEW_BOX_LABEL,
+  stripTitleGlyph,
   sidebarLines,
   menuLines,
   lifecycleMenuLines,
@@ -1191,10 +1815,14 @@ export {
   ADVANCED_HINT_GROUPS,
   statusLine,
   renderFooter,
+  ALERT_BAND_ROWS,
+  renderAlertBand,
   subscribePrompts,
   postAnswer,
   runWrappedAttach,
+  clipboardCaptureAvailable,
+  pasteHostClipboardImage,
   buildCloudAttachInnerCommand,
   cloudAgentAttach
 };
-//# sourceMappingURL=chunk-FODMEHD3.js.map
+//# sourceMappingURL=chunk-R4O5WPHW.js.map