@madarco/agentbox 0.4.1 → 0.6.0

package/runtime/relay/bin.cjs

@@ -10381,6 +10381,171 @@ var RELAY_EVENT_RING_SIZE = 1e3;
 var import_node_child_process = require("child_process");
 var import_node_http = require("http");
 
+// src/notices.ts
+var import_node_crypto = require("crypto");
+var DEFAULT_NOTICE_TTL_MS = 66e4;
+var BoxNotices = class {
+  constructor(subscribers) {
+    this.subscribers = subscribers;
+  }
+  subscribers;
+  /** keyed by notice id. */
+  entries = /* @__PURE__ */ new Map();
+  /**
+   * Register a notice for `boxId` and broadcast `notice-set`. At most one
+   * notice per (box, kind) is kept — a fresh `set` for the same kind
+   * replaces the previous one (and cancels its TTL timer so a stale timer
+   * can't later fire a `notice-clear` racing the replacement). Returns the
+   * generated notice id.
+   */
+  set(boxId, kind, message, ttlMs) {
+    for (const [id, entry] of this.entries) {
+      if (entry.boxId === boxId && entry.ev.kind === kind) {
+        clearTimeout(entry.timer);
+        this.entries.delete(id);
+      }
+    }
+    const ev = { id: (0, import_node_crypto.randomUUID)(), kind, message };
+    const ttl = typeof ttlMs === "number" && ttlMs > 0 ? ttlMs : DEFAULT_NOTICE_TTL_MS;
+    const timer = setTimeout(() => {
+      if (this.entries.delete(ev.id)) {
+        this.subscribers.broadcast(boxId, "notice-clear", { id: ev.id });
+      }
+    }, ttl);
+    if (typeof timer.unref === "function") timer.unref();
+    this.entries.set(ev.id, { ev, boxId, timer });
+    this.subscribers.broadcast(boxId, "notice-set", ev);
+    return ev.id;
+  }
+  /**
+   * Clear a notice by id. Idempotent: returns false when no such notice
+   * exists (already cleared / expired). Broadcasts `notice-clear` on a hit.
+   */
+  clear(id) {
+    const entry = this.entries.get(id);
+    if (!entry) return false;
+    clearTimeout(entry.timer);
+    this.entries.delete(id);
+    this.subscribers.broadcast(entry.boxId, "notice-clear", { id });
+    return true;
+  }
+  /** Snapshot of active notices for a box; replayed to a new SSE subscriber. */
+  forBox(boxId) {
+    const out = [];
+    for (const entry of this.entries.values()) {
+      if (entry.boxId === boxId) out.push(entry.ev);
+    }
+    return out;
+  }
+  size() {
+    return this.entries.size;
+  }
+};
+
+// src/prompts.ts
+var import_node_crypto2 = require("crypto");
+var PendingPrompts = class {
+  entries = /* @__PURE__ */ new Map();
+  add(boxId, ev) {
+    return new Promise((resolve2) => {
+      this.entries.set(ev.id, {
+        ev,
+        boxId,
+        resolve: resolve2,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+  }
+  /**
+   * Idempotent: returns true if a pending entry was found + resolved, false
+   * otherwise. The /admin/prompts/answer handler uses the bool to decide
+   * 204 vs 404 — the wrapper treats both as "we're done."
+   */
+  resolve(id, answer, cancelled) {
+    const entry = this.entries.get(id);
+    if (!entry) return false;
+    this.entries.delete(id);
+    entry.resolve({ answer, cancelled });
+    return true;
+  }
+  /**
+   * Snapshot of all pending prompts for a given box; used to flush the
+   * backlog to a newly-attached SSE subscriber.
+   */
+  forBox(boxId) {
+    const out = [];
+    for (const entry of this.entries.values()) {
+      if (entry.boxId === boxId) out.push(entry.ev);
+    }
+    return out;
+  }
+  /** boxId that owns a pending prompt id, or null when unknown. */
+  boxFor(id) {
+    const entry = this.entries.get(id);
+    return entry ? entry.boxId : null;
+  }
+  size() {
+    return this.entries.size;
+  }
+};
+var PromptSubscribers = class {
+  byBox = /* @__PURE__ */ new Map();
+  add(boxId, res) {
+    let set = this.byBox.get(boxId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.byBox.set(boxId, set);
+    }
+    set.add(res);
+  }
+  remove(boxId, res) {
+    const set = this.byBox.get(boxId);
+    if (!set) return;
+    set.delete(res);
+    if (set.size === 0) this.byBox.delete(boxId);
+  }
+  forBox(boxId) {
+    const set = this.byBox.get(boxId);
+    return set ? Array.from(set) : [];
+  }
+  /**
+   * Fire-and-forget broadcast. SSE writes that fail (closed socket) are
+   * swallowed — the `res.on('close')` handler in the server route already
+   * deregisters the dead subscriber.
+   */
+  broadcast(boxId, event, data) {
+    const set = this.byBox.get(boxId);
+    if (!set) return;
+    const payload = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+    for (const res of set) {
+      try {
+        res.write(payload);
+      } catch {
+      }
+    }
+  }
+};
+async function askPrompt(prompts, subscribers, boxId, params) {
+  if (process.env.AGENTBOX_PROMPT === "off") {
+    return { answer: "y" };
+  }
+  const ev = { id: (0, import_node_crypto2.randomUUID)(), ...params };
+  const promise = prompts.add(boxId, ev);
+  subscribers.broadcast(boxId, "prompt-ask", ev);
+  return promise;
+}
+function isPromptAnswerBody(v) {
+  if (!v || typeof v !== "object") return false;
+  const o = v;
+  if (typeof o.id !== "string" || o.id.length === 0) return false;
+  if (o.answer !== "y" && o.answer !== "n") return false;
+  if (o.cancelled !== void 0 && typeof o.cancelled !== "boolean") return false;
+  return true;
+}
+
 // src/registry.ts
 var BoxRegistry = class {
   map = /* @__PURE__ */ new Map();
@@ -10447,8 +10612,16 @@ var EventBuffer = class {
 var import_promises = require("fs/promises");
 var import_node_os = require("os");
 var import_node_path = require("path");
-function boxStatusPathFor(boxId) {
-  return (0, import_node_path.join)((0, import_node_os.homedir)(), ".agentbox", "boxes", boxId, "status.json");
+function sanitizeMnemonic(raw) {
+  return raw.toLowerCase().replace(/-/g, "_").replace(/[^a-z0-9_]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").slice(0, 32) || "unnamed";
+}
+function boxRunDirFor(boxId, name, projectIndex) {
+  const mnemonic = sanitizeMnemonic(name);
+  const segment = typeof projectIndex === "number" && Number.isFinite(projectIndex) && projectIndex > 0 ? `${boxId}-${String(projectIndex)}-${mnemonic}` : `${boxId}-${mnemonic}`;
+  return (0, import_node_path.join)((0, import_node_os.homedir)(), ".agentbox", "boxes", segment);
+}
+function boxStatusPathFor(boxId, name, projectIndex) {
+  return (0, import_node_path.join)(boxRunDirFor(boxId, name, projectIndex), "status.json");
 }
 function isValidBoxStatus(payload) {
   if (typeof payload !== "object" || payload === null) return false;
@@ -10460,13 +10633,19 @@ var BoxStatusStore = class {
   get(boxId) {
     return this.map.get(boxId);
   }
-  /** Update the in-memory entry and best-effort persist it to disk. */
-  async set(boxId, status) {
+  /**
+   * Update the in-memory entry and best-effort persist it to disk. `name` is
+   * the box's user-facing name (from the registry); `projectIndex` is the
+   * 1-based per-project `N`. Together they form the on-disk dir
+   * `~/.agentbox/boxes/<id>-<n>-<mnemonic>/status.json` (or
+   * `<id>-<mnemonic>/` if N is absent — legacy boxes).
+   */
+  async set(boxId, name, projectIndex, status) {
     this.map.set(boxId, status);
-    const target = boxStatusPathFor(boxId);
+    const target = boxStatusPathFor(boxId, name, projectIndex);
     const tmp = `${target}.${String(process.pid)}.tmp`;
     try {
-      await (0, import_promises.mkdir)((0, import_node_path.join)((0, import_node_os.homedir)(), ".agentbox", "boxes", boxId), { recursive: true });
+      await (0, import_promises.mkdir)(boxRunDirFor(boxId, name, projectIndex), { recursive: true });
       await (0, import_promises.writeFile)(tmp, JSON.stringify(status), "utf8");
       await (0, import_promises.rename)(tmp, target);
     } catch {
@@ -10485,6 +10664,10 @@ var BOX_STATUS_EVENT = "box-status";
 var MAX_BODY_BYTES = 1024 * 1024;
 var GIT_RPC_TIMEOUT_MS = 12e4;
 var CHECKPOINT_RPC_TIMEOUT_MS = 6e5;
+var DOWNLOAD_RPC_TIMEOUT_MS = 6e5;
+var CP_RPC_TIMEOUT_MS = 3e5;
+var BROWSER_OPEN_RPC_TIMEOUT_MS = 15e3;
+var SSE_HEARTBEAT_MS = 15e3;
 function send(res, status, body, contentType = "application/json") {
   const text = body == null ? "" : typeof body === "string" ? body : JSON.stringify(body);
   res.statusCode = status;
@@ -10540,6 +10723,9 @@ function createRelayServer(opts) {
   const registry = new BoxRegistry();
   const events = new EventBuffer();
   const statusStore = new BoxStatusStore();
+  const prompts = new PendingPrompts();
+  const subscribers = new PromptSubscribers();
+  const notices = new BoxNotices(subscribers);
   const host = opts.host ?? "0.0.0.0";
   const server = (0, import_node_http.createServer)((req, res) => {
     handle(req, res).catch((err) => {
@@ -10575,7 +10761,7 @@ function createRelayServer(opts) {
           send(res, 400, { error: "invalid box-status payload" });
           return;
         }
-        await statusStore.set(reg.boxId, body.payload);
+        await statusStore.set(reg.boxId, reg.name, reg.projectIndex, body.payload);
         log(`box-status box=${reg.boxId}`);
         send(res, 202, { ok: true });
         return;
@@ -10599,12 +10785,78 @@ function createRelayServer(opts) {
         return;
       }
       log(`rpc box=${reg.boxId} method=${body.method}`);
-      if (body.method === "git.pull" || body.method === "git.push") {
+      if (body.method === "git.push" || body.method === "git.fetch") {
+        if (body.method === "git.push") {
+          const params = body.params;
+          const verdict = await askPrompt(prompts, subscribers, reg.boxId, {
+            kind: "confirm",
+            message: `Allow git push from box ${reg.name}?`,
+            detail: `${params?.remote ?? "origin"} ${(params?.args ?? []).join(" ")}`.trim(),
+            defaultAnswer: "n",
+            context: {
+              command: "git push",
+              cwd: params?.path,
+              argv: params?.args
+            }
+          });
+          if (verdict.answer !== "y") {
+            send(res, 500, { exitCode: 10, stdout: "", stderr: "denied by user\n" });
+            return;
+          }
+        }
         const result = await handleGitRpc(reg, body.method, body.params);
         const status = result.exitCode === 0 ? 200 : 500;
         send(res, status, result);
         return;
       }
+      if (body.method === "cp.toHost" || body.method === "cp.fromHost") {
+        const params = body.params;
+        if (!params || typeof params.boxPath !== "string" || typeof params.hostPath !== "string") {
+          send(res, 400, { error: "cp.* requires {boxPath, hostPath} strings" });
+          return;
+        }
+        const direction = body.method === "cp.toHost" ? "box -> host" : "host -> box";
+        const verdict = await askPrompt(prompts, subscribers, reg.boxId, {
+          kind: "confirm",
+          message: `Allow cp (${direction}) on ${reg.name}?`,
+          detail: body.method === "cp.toHost" ? `${params.boxPath} -> ${params.hostPath}` : `${params.hostPath} -> ${params.boxPath}`,
+          defaultAnswer: "n",
+          context: {
+            command: body.method,
+            argv: [params.boxPath, params.hostPath]
+          }
+        });
+        if (verdict.answer !== "y") {
+          send(res, 500, { exitCode: 10, stdout: "", stderr: "denied by user\n" });
+          return;
+        }
+        const result = await handleCpRpc(reg, body.method, params);
+        const status = result.exitCode === 0 ? 200 : 500;
+        send(res, status, result);
+        return;
+      }
+      if (body.method === "download.workspace" || body.method === "download.env" || body.method === "download.config" || body.method === "download.claude") {
+        const params = body.params;
+        const kind = body.method.split(".")[1] ?? "workspace";
+        const verdict = await askPrompt(prompts, subscribers, reg.boxId, {
+          kind: "confirm",
+          message: `Allow download (${kind}) from ${reg.name}?`,
+          detail: params?.hostPath ?? "(default host location)",
+          defaultAnswer: "n",
+          context: {
+            command: body.method,
+            argv: params?.hostPath ? [params.hostPath] : []
+          }
+        });
+        if (verdict.answer !== "y") {
+          send(res, 500, { exitCode: 10, stdout: "", stderr: "denied by user\n" });
+          return;
+        }
+        const result = await handleDownloadRpc(reg, kind);
+        const status = result.exitCode === 0 ? 200 : 500;
+        send(res, status, result);
+        return;
+      }
       if (body.method === "checkpoint.create") {
         const result = await handleCheckpointRpc(
           reg,
@@ -10614,6 +10866,23 @@ function createRelayServer(opts) {
         send(res, status, result);
         return;
       }
+      if (body.method === "browser.open") {
+        const params = body.params;
+        const url2 = typeof params?.url === "string" ? params.url.trim() : "";
+        if (!isOpenableUrl(url2)) {
+          send(res, 400, {
+            exitCode: 64,
+            stdout: "",
+            stderr: "browser.open: only http/https URLs are allowed\n"
+          });
+          return;
+        }
+        events.append({ boxId: reg.boxId, type: "browser-open", payload: { url: url2 } });
+        const result = await runHostCommand(["open", url2], BROWSER_OPEN_RPC_TIMEOUT_MS);
+        const status = result.exitCode === 0 ? 200 : 500;
+        send(res, status, result);
+        return;
+      }
       events.append({
         boxId: reg.boxId,
         type: "rpc-unknown",
@@ -10629,6 +10898,7 @@ function createRelayServer(opts) {
         return;
       }
       const worktrees = sanitizeWorktrees(body.worktrees);
+      const projectIndex = typeof body.projectIndex === "number" && Number.isFinite(body.projectIndex) && body.projectIndex > 0 ? Math.trunc(body.projectIndex) : void 0;
       const reg = {
         boxId: body.boxId,
         token: body.token,
@@ -10636,6 +10906,7 @@ function createRelayServer(opts) {
         registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
         containerName: typeof body.containerName === "string" && body.containerName.length > 0 ? body.containerName : void 0,
         createdAt: typeof body.createdAt === "string" && body.createdAt.length > 0 ? body.createdAt : void 0,
+        projectIndex,
         worktrees
       };
       registry.register(reg);
@@ -10681,11 +10952,95 @@ function createRelayServer(opts) {
         registeredAt: r.registeredAt,
         containerName: r.containerName,
         createdAt: r.createdAt,
+        projectIndex: r.projectIndex,
         worktrees: r.worktrees ?? []
       }));
       send(res, 200, { boxes: redacted });
       return;
     }
+    if (route === "GET /admin/prompts/stream") {
+      const boxId = url.searchParams.get("boxId") ?? "";
+      if (boxId.length === 0) {
+        send(res, 400, { error: "missing boxId query param" });
+        return;
+      }
+      res.statusCode = 200;
+      res.setHeader("Content-Type", "text/event-stream");
+      res.setHeader("Cache-Control", "no-cache");
+      res.setHeader("Connection", "keep-alive");
+      res.setHeader("X-Accel-Buffering", "no");
+      if (typeof res.flushHeaders === "function") res.flushHeaders();
+      res.write(": connected\n\n");
+      subscribers.add(boxId, res);
+      for (const ev of prompts.forBox(boxId)) {
+        res.write(`event: prompt-ask
+data: ${JSON.stringify(ev)}
+
+`);
+      }
+      for (const ev of notices.forBox(boxId)) {
+        res.write(`event: notice-set
+data: ${JSON.stringify(ev)}
+
+`);
+      }
+      const heartbeat = setInterval(() => {
+        try {
+          res.write(`event: ping
+data: {"ts":"${(/* @__PURE__ */ new Date()).toISOString()}"}
+
+`);
+        } catch {
+        }
+      }, SSE_HEARTBEAT_MS);
+      if (typeof heartbeat.unref === "function") heartbeat.unref();
+      res.on("close", () => {
+        clearInterval(heartbeat);
+        subscribers.remove(boxId, res);
+      });
+      return;
+    }
+    if (route === "POST /admin/prompts/answer") {
+      const body = await readJsonBody(req);
+      if (!isPromptAnswerBody(body)) {
+        send(res, 400, { error: 'expected {id, answer:"y"|"n", cancelled?}' });
+        return;
+      }
+      const targetBox = prompts.boxFor(body.id);
+      const hit = prompts.resolve(body.id, body.answer, body.cancelled);
+      if (!hit) {
+        send(res, 404, { error: "no pending prompt with that id" });
+        return;
+      }
+      if (targetBox) {
+        subscribers.broadcast(targetBox, "prompt-resolved", { id: body.id });
+      }
+      send(res, 204, null);
+      return;
+    }
+    if (route === "POST /admin/notices/set") {
+      const body = await readJsonBody(req);
+      if (!body || typeof body.boxId !== "string" || body.boxId.length === 0 || typeof body.kind !== "string" || body.kind.length === 0 || typeof body.message !== "string" || body.message.length === 0) {
+        send(res, 400, { error: "expected {boxId, kind, message}" });
+        return;
+      }
+      const ttlMs = typeof body.ttlMs === "number" && Number.isFinite(body.ttlMs) && body.ttlMs > 0 ? body.ttlMs : void 0;
+      const id = notices.set(body.boxId, body.kind, body.message, ttlMs);
+      log(`notice-set box=${body.boxId} kind=${body.kind} id=${id}`);
+      send(res, 200, { id });
+      return;
+    }
+    if (route === "POST /admin/notices/clear") {
+      const body = await readJsonBody(req);
+      if (!body || typeof body.id !== "string" || body.id.length === 0) {
+        send(res, 400, { error: "expected {boxId, id}" });
+        return;
+      }
+      notices.clear(body.id);
+      log(`notice-clear id=${body.id}`);
+      send(res, 204, null);
+      return;
+    }
     send(res, 404, { error: "not found", route });
   }
   function authBox(req, res, reg) {
@@ -10706,6 +11061,9 @@ function createRelayServer(opts) {
     registry,
     events,
     statusStore,
+    prompts,
+    subscribers,
+    notices,
     url: `http://${host}:${String(opts.port)}`,
     close: () => new Promise((resolve2, reject) => {
       server.close((err) => {
@@ -10719,10 +11077,10 @@ function sanitizeWorktrees(input) {
   if (!Array.isArray(input)) return void 0;
   const out = [];
   for (const w of input) {
-    if (w && typeof w.containerPath === "string" && typeof w.hostWorktreeDir === "string" && typeof w.branch === "string") {
+    if (w && typeof w.containerPath === "string" && typeof w.hostMainRepo === "string" && typeof w.branch === "string") {
       out.push({
         containerPath: w.containerPath,
-        hostWorktreeDir: w.hostWorktreeDir,
+        hostMainRepo: w.hostMainRepo,
         branch: w.branch
       });
     }
@@ -10747,9 +11105,9 @@ async function handleGitRpc(reg, method, params) {
       stderr: `no worktree registered for box ${reg.boxId} matching ${containerPath}`
     };
   }
-  const op = method === "git.pull" ? "pull" : "push";
+  const op = method === "git.push" ? "push" : "fetch";
   const remote = params?.remote ?? "origin";
-  const argv = ["git", "-C", worktree.hostWorktreeDir, op, remote];
+  const argv = ["git", "-C", worktree.hostMainRepo, op, remote, worktree.branch];
   if (Array.isArray(params?.args)) {
     for (const a of params.args) {
       if (typeof a === "string") argv.push(a);
@@ -10757,6 +11115,33 @@ async function handleGitRpc(reg, method, params) {
   }
   return runHostCommand(argv);
 }
+async function handleCpRpc(reg, method, params) {
+  const entry = process.env.AGENTBOX_CLI_ENTRY;
+  if (!entry) {
+    return {
+      exitCode: 64,
+      stdout: "",
+      stderr: "relay: AGENTBOX_CLI_ENTRY not set; cannot run cp host-side"
+    };
+  }
+  const boxRef = `${reg.name}:${params.boxPath}`;
+  const argv = method === "cp.toHost" ? [process.execPath, entry, "cp", boxRef, params.hostPath] : [process.execPath, entry, "cp", params.hostPath, boxRef];
+  return runHostCommand(argv, CP_RPC_TIMEOUT_MS);
+}
+async function handleDownloadRpc(reg, kind) {
+  const entry = process.env.AGENTBOX_CLI_ENTRY;
+  if (!entry) {
+    return {
+      exitCode: 64,
+      stdout: "",
+      stderr: "relay: AGENTBOX_CLI_ENTRY not set; cannot run download host-side"
+    };
+  }
+  const argv = [process.execPath, entry, "download"];
+  if (kind !== "workspace") argv.push(kind);
+  argv.push(reg.name, "-y");
+  return runHostCommand(argv, DOWNLOAD_RPC_TIMEOUT_MS);
+}
 async function handleCheckpointRpc(reg, params) {
   const entry = process.env.AGENTBOX_CLI_ENTRY;
   if (!entry) {
@@ -10770,8 +11155,18 @@ async function handleCheckpointRpc(reg, params) {
   if (params?.name) argv.push("--name", params.name);
   if (params?.merged === true) argv.push("--merged");
   if (params?.setDefault === true) argv.push("--set-default");
+  if (params?.replace === true) argv.push("--replace");
   return runHostCommand(argv, CHECKPOINT_RPC_TIMEOUT_MS);
 }
+function isOpenableUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return false;
+  }
+  return url.protocol === "http:" || url.protocol === "https:";
+}
 function runHostCommand(argv, timeoutMs = GIT_RPC_TIMEOUT_MS) {
   return new Promise((resolve2) => {
     const [cmd, ...rest] = argv;