coderemote 0.3.7 → 0.3.9

package/dist/coderemote.js

@@ -1,27 +1,28 @@
 #!/usr/bin/env node
 
 // bin/coderemote.js
-import { execFile as execFile8, execFileSync, spawn as spawn3 } from "node:child_process";
-import { randomBytes as randomBytes3 } from "node:crypto";
-import fs14 from "node:fs";
-import net2 from "node:net";
-import os6 from "node:os";
-import path12 from "node:path";
+import { execFile as execFile11, execFileSync, spawn as spawn5 } from "node:child_process";
+import { randomBytes as randomBytes4 } from "node:crypto";
+import fs19 from "node:fs";
+import net3 from "node:net";
+import os7 from "node:os";
+import path16 from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify as promisify4 } from "node:util";
 import qrcode from "qrcode-terminal";
 
 // ../../packages/agent-core/src/server.js
-import { createReadStream, createWriteStream as createWriteStream2 } from "node:fs";
-import fs8 from "node:fs/promises";
-import http2 from "node:http";
-import os5 from "node:os";
-import path6 from "node:path";
-import { pipeline as pipeline2 } from "node:stream/promises";
-import { randomUUID as randomUUID4, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { createReadStream as createReadStream2, createWriteStream as createWriteStream2 } from "node:fs";
+import fs13 from "node:fs/promises";
+import http3 from "node:http";
+import os6 from "node:os";
+import path10 from "node:path";
+import { pipeline as pipeline3 } from "node:stream/promises";
+import { randomUUID as randomUUID5, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 
 // ../../packages/protocol/index.js
 var PROTOCOL_VERSION = 4;
+var MIN_CLIENT_PROTOCOL = 4;
 var PAIRING_SCHEME = "vsremote";
 var Routes = Object.freeze({
   info: "GET /api/info",
@@ -32,6 +33,8 @@ var Routes = Object.freeze({
   fsMkdir: "POST /api/fs/mkdir",
   fsRename: "POST /api/fs/rename",
   fsDelete: "DELETE /api/fs",
+  // Added within v4: older agents answer 404.
+  fsSearch: "GET /api/fs/search",
   termList: "GET /api/term",
   termKill: "DELETE /api/term",
   gitRepos: "GET /api/git/repos",
@@ -57,12 +60,21 @@ var Routes = Object.freeze({
   previewRequestsClear: "DELETE /api/preview/requests",
   tunnelToken: "POST /api/tunnel/token",
   tunnelStatus: "GET /api/tunnel",
+  // Added within v4: older agents answer 404.
+  tunnelDelete: "DELETE /api/tunnel",
   agentsHook: "POST /api/agents/hook",
   agentsSessions: "GET /api/agents/sessions",
   agentsTimeline: "GET /api/agents/timeline",
   agentsAnswer: "POST /api/agents/answer",
   agentsLaunch: "POST /api/agents/sessions",
   agentsSetup: "GET /api/agents/setup",
+  agentsCommands: "GET /api/agents/commands",
+  agentsHistory: "GET /api/agents/history",
+  buildsSchemes: "GET /api/builds/schemes",
+  buildsStart: "POST /api/builds",
+  buildsCurrent: "GET /api/builds/current",
+  buildsCancel: "POST /api/builds/cancel",
+  buildsInstall: "POST /api/builds/install",
   agentsPrompt: "POST /api/agents/prompt",
   agentsKeys: "POST /api/agents/keys",
   agentsStop: "POST /api/agents/stop",
@@ -192,9 +204,12 @@ var RolloutTail = class {
   #partial = "";
   #timer = null;
   #onItem;
-  constructor(file, onItem) {
+  #onTurnEnd;
+  constructor(file, onItem, onTurnEnd = () => {
+  }) {
     this.#file = file;
     this.#onItem = onItem;
+    this.#onTurnEnd = onTurnEnd;
     this.#timer = setInterval(() => this.poll().catch(() => {
     }), POLL);
     this.#timer.unref?.();
@@ -220,7 +235,12 @@ var RolloutTail = class {
         } catch {
           continue;
         }
-        if (record?.type === "event_msg" && record.payload?.type === "item_completed") this.#onItem(record.payload.item);
+        if (record?.type !== "event_msg") continue;
+        if (record.payload?.type === "item_completed") this.#onItem(record.payload.item);
+        else if (record.payload?.type === "task_complete") {
+          const message = record.payload.error?.message;
+          this.#onTurnEnd(typeof message === "string" && message.trim() ? message.trim() : null);
+        }
       }
     } finally {
       await handle.close();
@@ -284,15 +304,15 @@ async function readTranscript(file, limit = 500) {
   } catch {
     return [];
   }
-  const entries = [];
+  const entries2 = [];
   for (const line of text.split("\n")) {
     if (!line.trim()) continue;
     try {
-      entries.push(...entriesOf(JSON.parse(line)));
+      entries2.push(...entriesOf(JSON.parse(line)));
     } catch {
     }
   }
-  return entries.slice(-limit);
+  return entries2.slice(-limit);
 }
 
 // ../../packages/agent-core/src/agents.js
@@ -302,6 +322,7 @@ var MAX_TITLE = 80;
 var ENDED_TTL = 24 * 60 * 60 * 1e3;
 var REQUEST_TTL = 60 * 60 * 1e3;
 var START_TIMEOUT = 15 * 1e3;
+var STOP_GRACE = 3 * 1e3;
 var SEQUENTIAL_REQUEST_TTL = 10 * 60 * 1e3;
 var ADAPTERS = {
   claude: {
@@ -360,6 +381,7 @@ var AgentSession = class {
     this.titled = false;
     this.state = "idle";
     this.terminal = terminal;
+    this.app = null;
     this.startedAt = now;
     this.lastActivityAt = now;
     this.endedAt = null;
@@ -411,7 +433,7 @@ var AgentHub = class extends EventEmitter {
     transcript = readTranscript,
     startTimeout = START_TIMEOUT,
     present = async () => false,
-    rolloutTail = (file, onItem) => new RolloutTail(file, onItem)
+    rolloutTail = (file, onItem, onTurnEnd) => new RolloutTail(file, onItem, onTurnEnd)
   } = {}) {
     super();
     this.#now = now;
@@ -433,6 +455,17 @@ var AgentHub = class extends EventEmitter {
     s.prompts.push({ id, text: comparable(text, paths), at: this.#now() });
     s.prompts = s.prompts.filter((p) => this.#now() - p.at < 6e4).slice(-20);
   }
+  /**
+   * A client pressed Esc in a running session. Claude Code reports no hook for an interrupted
+   * turn (only an idle notification a minute later), so the turn ends here; a hook that shows
+   * it still going starts a turn again.
+   */
+  interrupted(sessionId) {
+    const s = this.#sessions.get(sessionId);
+    if (!s || s.state !== "running" || s.starting) return;
+    this.#endTurn(s, this.#now());
+    this.#emitSession(s);
+  }
   /** Whether `resume` may reopen a session: only one no process runs any more. */
   canResume(id) {
     const s = this.#sessions.get(id);
@@ -477,18 +510,23 @@ var AgentHub = class extends EventEmitter {
   session(id) {
     return this.#sessions.get(id)?.toJSON() ?? null;
   }
+  /** Where a session runs: one of the agent's terminals, or an app on the computer (or neither known). */
+  host(id) {
+    const s = this.#sessions.get(id);
+    return s ? { terminal: s.terminal, app: s.app } : null;
+  }
   timeline(id, after = 0) {
     const s = this.#sessions.get(id);
     if (!s) throw new HttpError(404, "no such session");
-    const entries = s.entries.filter((e) => e.seq > after);
-    return { entries, next: s.seq, requests: [...s.requests.values()].map((r) => r.request) };
+    const entries2 = s.entries.filter((e) => e.seq > after);
+    return { entries: entries2, next: s.seq, requests: [...s.requests.values()].map((r) => r.request) };
   }
   /**
    * Takes one hook event. Resolves with the hook's output: for `PermissionRequest` once the
    * request is answered (null when the computer should decide), `{}` for everything else.
    * Aborting `signal` (the hook was killed because the computer answered) withdraws the request.
    */
-  async handle(raw, { agent = "claude", terminal = null, signal } = {}) {
+  async handle(raw, { agent = "claude", terminal = null, app = null, signal } = {}) {
     if (!raw || typeof raw.session_id !== "string" || !raw.session_id) {
       throw new HttpError(400, "hook event without session_id");
     }
@@ -497,8 +535,9 @@ var AgentHub = class extends EventEmitter {
     const now = this.#now();
     let replaced = null;
     if (!this.#sessions.has(event.session_id)) {
+      const cleared = event.hook_event_name === "SessionStart" && event.source === "clear" && terminal;
       const candidates = [...this.#sessions.values()].filter(
-        (p) => p.starting && (terminal ? p.terminal === terminal : p.agent === agent && p.cwd === event.cwd)
+        (p) => cleared ? p.terminal === terminal && p.agent === agent : p.starting && (terminal ? p.terminal === terminal : p.agent === agent && p.cwd === event.cwd)
       );
       if (candidates.length === 1) {
         replaced = candidates[0];
@@ -515,7 +554,7 @@ var AgentHub = class extends EventEmitter {
     }
     await s.ready;
     if (s.agent === "codex" && !s.tail && typeof event.transcript_path === "string") {
-      s.tail = this.#rolloutTail(event.transcript_path, (item) => this.#fromRollout(s, item));
+      s.tail = this.#rolloutTail(event.transcript_path, (item) => this.#fromRollout(s, item), (error) => this.#rolloutTurnEnd(s, error));
       s.tail.poll?.().catch(() => {
       });
     }
@@ -524,6 +563,7 @@ var AgentHub = class extends EventEmitter {
       this.emit("message", { type: "session_removed", session: replaced.id, replacedBy: s.id });
     }
     if (terminal && !s.terminal) s.terminal = terminal;
+    if (app) s.app = app;
     s.starting = false;
     s.lastActivityAt = now;
     if (s.state === "ended" && event.hook_event_name !== "SessionEnd") {
@@ -532,6 +572,7 @@ var AgentHub = class extends EventEmitter {
     }
     switch (event.hook_event_name) {
       case "SessionStart":
+        if (s.state === "running" && s.turnStartedAt == null) s.state = "idle";
         break;
       case "UserPromptSubmit": {
         const text = typeof event.prompt === "string" ? event.prompt : "";
@@ -600,11 +641,8 @@ var AgentHub = class extends EventEmitter {
         if (last && !turnEntries.some((e) => e.kind === "assistant" && e.text.trim() === last)) {
           this.#entry(s, { kind: "assistant", text: last });
         }
-        s.streaming.clear();
-        const duration = s.turnStartedAt ? now - s.turnStartedAt : 0;
-        s.turnStartedAt = null;
-        s.state = s.requests.size ? "waiting" : "idle";
-        this.#entry(s, { kind: "turn_end", duration });
+        if (s.turnStartedAt == null && s.entries.at(-1)?.kind === "turn_end") break;
+        this.#endTurn(s, now);
         break;
       }
       case "Interrupt":
@@ -737,13 +775,13 @@ var AgentHub = class extends EventEmitter {
     pending.resolve(output);
   }
   async #backfill(s, file) {
-    let entries = [];
+    let entries2 = [];
     try {
-      entries = await this.#transcript(file, MAX_ENTRIES);
+      entries2 = await this.#transcript(file, MAX_ENTRIES);
     } catch {
     }
     const tools = /* @__PURE__ */ new Map();
-    for (const e of entries) {
+    for (const e of entries2) {
       if (e.kind === "tool") {
         tools.set(e.toolUseId, e.name);
         e.input = clipInput(e.input);
@@ -759,6 +797,30 @@ var AgentHub = class extends EventEmitter {
     if (s.entries.length > MAX_ENTRIES) s.entries.splice(0, s.entries.length - MAX_ENTRIES);
   }
   /** Something Codex said or a tool's result, from its rollout, unless the hooks told it already. */
+  #endTurn(s, now, error = null) {
+    s.streaming.clear();
+    const duration = s.turnStartedAt ? now - s.turnStartedAt : 0;
+    s.turnStartedAt = null;
+    s.state = s.requests.size ? "waiting" : "idle";
+    this.#entry(s, { kind: "turn_end", duration, ...error ? { error: true, text: error } : {} });
+  }
+  /**
+   * Codex's rollout says a turn ended. Stop doesn't run when it failed (an unsupported model, a
+   * lost connection), so a failed turn ends here, with its error. One that ended normally is
+   * left to Stop, which carries the last reply, unless Stop never comes (its hook failed).
+   */
+  #rolloutTurnEnd(s, error) {
+    if (s.turnStartedAt == null) return;
+    const started = s.turnStartedAt;
+    const end = () => {
+      if (s.turnStartedAt !== started) return;
+      this.#endTurn(s, this.#now(), error);
+      s.lastActivityAt = this.#now();
+      this.#emitSession(s);
+    };
+    if (error) end();
+    else setTimeout(end, STOP_GRACE).unref?.();
+  }
   #fromRollout(s, item) {
     const fields = codexItem(item);
     if (!fields) return;
@@ -789,26 +851,856 @@ var AgentHub = class extends EventEmitter {
     s.turnStartedAt = null;
   }
   #entry(s, fields) {
-    const entry2 = { seq: ++s.seq, time: this.#now(), ...fields };
-    s.entries.push(entry2);
+    const entry3 = { seq: ++s.seq, time: this.#now(), ...fields };
+    s.entries.push(entry3);
     if (s.entries.length > MAX_ENTRIES) s.entries.shift();
-    this.emit("message", { type: "entry", session: s.id, entry: entry2 });
+    this.emit("message", { type: "entry", session: s.id, entry: entry3 });
   }
   #emitSession(s) {
     this.emit("message", { type: "session", session: s.toJSON() });
   }
 };
 
-// ../../packages/agent-core/src/git.js
-import { execFile } from "node:child_process";
+// ../../packages/agent-core/src/commands.js
 import fs4 from "node:fs/promises";
 import path3 from "node:path";
+var HEAD_BYTES = 4096;
+var MAX_DESCRIPTION = 300;
+var MAX_DEPTH = 3;
+var CLAUDE = [
+  ["/add-dir", "Add a working directory", false, "<path>"],
+  ["/agents", "Manage agent configurations", true],
+  ["/batch", "Run a task across many files in parallel", false, "<task>"],
+  ["/claude-api", "Build with the Claude API and Anthropic SDK", false],
+  ["/clear", "Start a new session with empty context", false],
+  ["/code-review", "Review the current diff for bugs", false, "[level] [target]"],
+  ["/color", "Set the prompt bar color for this session", true],
+  ["/compact", "Clear history but keep a summary in context", false, "[instructions]"],
+  ["/config", "Open settings", true],
+  ["/context", "Show context usage", false],
+  ["/debug", "Debug this session", false, "[issue]"],
+  ["/doctor", "Check the installation and settings", true],
+  ["/effort", "Set the reasoning effort", true, "[level]"],
+  ["/exit", "Exit Claude Code", false],
+  ["/export", "Export the conversation", true],
+  ["/fast", "Toggle fast mode", false],
+  ["/feedback", "Send feedback about Claude Code", true],
+  ["/fewer-permission-prompts", "Allowlist common read-only commands", false],
+  ["/goal", "Set or view the goal for this session", false, "[goal]"],
+  ["/help", "Show help and available commands", true],
+  ["/hooks", "Manage hook configurations", true],
+  ["/ide", "Manage IDE integrations", true],
+  ["/init", "Create a CLAUDE.md with codebase documentation", false],
+  ["/insights", "Report on your Claude Code sessions", false],
+  ["/login", "Sign in to your Anthropic account", true],
+  ["/logout", "Sign out of your Anthropic account", false],
+  ["/loop", "Run a prompt on a recurring interval", false, "[interval] <prompt>"],
+  ["/mcp", "Manage MCP servers", true],
+  ["/memory", "Edit memory files", true],
+  ["/model", "Set the model", true, "[model]"],
+  ["/output-style", "Set the output style", true],
+  ["/permissions", "Manage tool permission rules", true],
+  ["/plugin", "Manage plugins", true],
+  ["/recap", "Summarize this session so far", false],
+  ["/release-notes", "Show release notes", false],
+  ["/reload-plugins", "Reload plugins", false],
+  ["/reload-skills", "Reload skills", false],
+  ["/rename", "Rename this session", false, "<name>"],
+  ["/resume", "Resume a conversation", true],
+  ["/rewind", "Restore code or conversation to an earlier point", true],
+  ["/schedule", "Create or manage scheduled cloud agents", false, "[task]"],
+  ["/security-review", "Security review of the pending changes", false],
+  ["/simplify", "Review changed code for cleanups and apply them", false],
+  ["/status", "Show version, model and account status", true],
+  ["/statusline", "Set up the status line", false],
+  ["/terminal-setup", "Set up terminal key bindings", false],
+  ["/theme", "Change the color theme", true],
+  ["/ultrareview", "Deep multi-agent review in the cloud", false],
+  ["/update-config", "Configure Claude Code settings", false, "<change>"],
+  ["/usage", "Show plan usage limits", true]
+];
+var CODEX = [
+  ["/agents", "open the agent command center", true],
+  ["/app", "continue this session in the Desktop app", false],
+  ["/approve", "approve one retry of a recent auto-review denial", false],
+  ["/archive", "archive this session", false],
+  ["/cd", "change the current working directory", false, "<path>"],
+  ["/clear", "clear the terminal and start a new chat", false],
+  ["/compact", "summarize conversation to prevent hitting the context limit", false],
+  ["/config", "configure Codex preferences", true],
+  ["/copy", "copy the last response or part of it", true],
+  ["/debug-config", "show config layers and requirement sources for debugging", false],
+  ["/delete", "permanently delete this session", true],
+  ["/diff", "show git diff (including untracked files)", false],
+  ["/exit", "exit Codex", false],
+  ["/experimental", "toggle experimental features", true],
+  ["/feedback", "send logs to maintainers", true],
+  ["/fork", "fork the current chat", false],
+  ["/goal", "set or view the goal for a long-running task", false, "[goal]"],
+  ["/hooks", "view and manage lifecycle hooks", true],
+  ["/ide", "include current selection, open files, and other context from your IDE", false],
+  ["/import", "import setup, this project, and recent chats from Claude Code", true],
+  ["/init", "create an AGENTS.md file with instructions for Codex", false],
+  ["/keymap", "remap TUI shortcuts", true],
+  ["/logout", "log out of Codex", false],
+  ["/mcp", "list MCP tools; use /mcp verbose or /mcp login <name>", false, "[verbose | login <name>]"],
+  ["/mention", "mention a file", true],
+  ["/model", "choose what model and reasoning effort to use", true],
+  ["/new", "start a new chat during a conversation", false],
+  ["/permissions", "choose what Codex is allowed to do", true],
+  ["/pets", "choose or hide the terminal pet", true],
+  ["/plan", "switch to Plan mode", false],
+  ["/plugins", "browse plugins", true],
+  ["/presets", "run or save reusable prompts and slash commands", true],
+  ["/ps", "list background terminals", false],
+  ["/pwd", "show the current working directory", false],
+  ["/raw", "toggle raw scrollback mode for copy-friendly terminal selection", false],
+  ["/recap", "summarize the current conversation now", false],
+  ["/rename", "rename the current thread", false, "<name>"],
+  ["/resume", "resume a saved chat", true],
+  ["/review", "review my current changes and find issues", true],
+  ["/side", "start a side conversation in an ephemeral fork", false],
+  ["/skills", "use skills to improve how Codex performs specific tasks", true],
+  ["/status", "show current session configuration and token usage", false],
+  ["/statusline", "configure which items appear in the status line", true],
+  ["/stop", "stop all background terminals", false],
+  ["/subagents", "switch between this session's subagents", true],
+  ["/theme", "choose a syntax highlighting theme", true],
+  ["/title", "configure which items appear in the terminal title", true],
+  ["/tui", "choose the TUI mode for the next launch", true],
+  ["/usage", "view account usage or use a usage limit reset", true],
+  ["/vim", "toggle Vim mode for the composer", false],
+  ["/voice", "start or stop voice; use /voice settings to choose a voice", false],
+  ["/warnings", "view retained warnings and diagnostic details", true],
+  ["/worktree", "start or continue a conversation in a new worktree", true]
+];
+var BUILTINS = { claude: CLAUDE, codex: CODEX };
+function builtin([name, description, interactive, argumentHint = ""]) {
+  return { name, kind: "command", description, argumentHint, source: "builtin", interactive };
+}
+function unquote(v) {
+  const t = v.trim();
+  if (/^".*"$/.test(t)) return t.slice(1, -1).replace(/\\(["\\])/g, "$1");
+  if (/^'.*'$/.test(t)) return t.slice(1, -1).replace(/''/g, "'");
+  return t;
+}
+function frontmatter(text) {
+  const lines = text.replace(/^/, "").split(/\r?\n/);
+  if (lines[0].trim() !== "---") return null;
+  const end = lines.indexOf("---", 1);
+  if (end < 0) return null;
+  const out = {};
+  let block = null;
+  for (const line of lines.slice(1, end)) {
+    const m = /^([A-Za-z][\w-]*):\s*(.*)$/.exec(line);
+    if (m) {
+      block = [">", "|", ">-", "|-", ""].includes(m[2].trim()) ? m[1] : null;
+      out[m[1]] = block ? "" : unquote(m[2]);
+    } else if (block && /^\s+\S/.test(line)) {
+      out[block] = `${out[block]} ${line.trim()}`.trim();
+    }
+  }
+  return out;
+}
+async function readHead(file) {
+  let handle;
+  try {
+    handle = await fs4.open(file, "r");
+    const { buffer, bytesRead } = await handle.read(Buffer.alloc(HEAD_BYTES), 0, HEAD_BYTES, 0);
+    return frontmatter(buffer.subarray(0, bytesRead).toString("utf8")) ?? {};
+  } catch {
+    return {};
+  } finally {
+    await handle?.close();
+  }
+}
+async function entries(dir) {
+  try {
+    return await fs4.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+async function readJson(file) {
+  try {
+    return JSON.parse(await fs4.readFile(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function entry(name, kind, head, source) {
+  return {
+    name,
+    kind,
+    description: String(head.description ?? "").slice(0, MAX_DESCRIPTION),
+    argumentHint: kind === "command" ? String(head["argument-hint"] ?? "") : "",
+    source,
+    interactive: false
+  };
+}
+async function commandFiles(dir, prefix, source, depth = 0, parts = []) {
+  const out = [];
+  for (const e of await entries(dir)) {
+    if (e.name.startsWith(".")) continue;
+    const file = path3.join(dir, e.name);
+    if (e.isDirectory() && depth < MAX_DEPTH) {
+      out.push(...await commandFiles(file, prefix, source, depth + 1, [...parts, e.name]));
+    } else if (e.isFile() && e.name.endsWith(".md")) {
+      const name = `/${prefix}${[...parts, e.name.slice(0, -3)].join(":")}`;
+      out.push(entry(name, "command", await readHead(file), source));
+    }
+  }
+  return out;
+}
+async function skillFiles(dir, { sigil = "/", prefix = "", source, kind = "command" }) {
+  const out = [];
+  for (const e of await entries(dir)) {
+    if (!e.isDirectory() || e.name.startsWith(".")) continue;
+    const file = path3.join(dir, e.name, "SKILL.md");
+    try {
+      await fs4.access(file);
+    } catch {
+      continue;
+    }
+    const head = await readHead(file);
+    if (String(head["user-invocable"]).toLowerCase() === "false") continue;
+    const name = /^[\w.:-]+$/.test(head.name ?? "") ? head.name : e.name;
+    out.push(entry(`${sigil}${prefix}${name}`, kind, head, source));
+  }
+  return out;
+}
+async function claudePlugins(home, cwd) {
+  const installed = (await readJson(path3.join(home, ".claude", "plugins", "installed_plugins.json")))?.plugins ?? {};
+  const enabled = {};
+  for (const file of [
+    path3.join(home, ".claude", "settings.json"),
+    path3.join(cwd, ".claude", "settings.json"),
+    path3.join(cwd, ".claude", "settings.local.json")
+  ]) {
+    Object.assign(enabled, (await readJson(file))?.enabledPlugins ?? {});
+  }
+  const out = [];
+  for (const [key, installs] of Object.entries(installed)) {
+    if (enabled[key] !== true || !Array.isArray(installs)) continue;
+    const install = installs.find((i) => !i.projectPath || path3.resolve(i.projectPath) === path3.resolve(cwd));
+    if (install?.installPath) out.push({ name: key.split("@")[0], root: install.installPath });
+  }
+  return out;
+}
+async function claudeCommands(home, cwd) {
+  const user = path3.join(home, ".claude");
+  const project = path3.join(cwd, ".claude");
+  const found = [
+    ...await commandFiles(path3.join(user, "commands"), "", "user"),
+    ...await skillFiles(path3.join(user, "skills"), { source: "user" })
+  ];
+  for (const e of await entries(path3.join(user, "skills", "synced"))) {
+    if (e.isDirectory() && !e.name.startsWith(".")) {
+      found.push(...await skillFiles(path3.join(user, "skills", "synced", e.name), { prefix: "anthropic-skills:", source: "user" }));
+    }
+  }
+  if (path3.resolve(project) !== path3.resolve(user)) {
+    found.push(
+      ...await commandFiles(path3.join(project, "commands"), "", "project"),
+      ...await skillFiles(path3.join(project, "skills"), { source: "project" })
+    );
+  }
+  for (const plugin of await claudePlugins(home, cwd)) {
+    found.push(
+      ...await commandFiles(path3.join(plugin.root, "commands"), `${plugin.name}:`, "plugin"),
+      ...await skillFiles(path3.join(plugin.root, "skills"), { prefix: `${plugin.name}:`, source: "plugin" })
+    );
+  }
+  return found;
+}
+async function codexDisabled(codexHome) {
+  const off = /* @__PURE__ */ new Set();
+  let text = "";
+  try {
+    text = await fs4.readFile(path3.join(codexHome, "config.toml"), "utf8");
+  } catch {
+  }
+  let section = null;
+  for (const line of text.split(/\r?\n/)) {
+    const header = /^\s*\[plugins\."([^"]+)"\]\s*$/.exec(line);
+    if (header) section = header[1];
+    else if (/^\s*\[/.test(line)) section = null;
+    else if (section && /^\s*enabled\s*=\s*false\b/.test(line)) off.add(section);
+  }
+  return off;
+}
+async function latestVersion(dir) {
+  let best = null;
+  for (const e of await entries(dir)) {
+    if (!e.isDirectory() || e.name.startsWith(".")) continue;
+    const { mtimeMs } = await fs4.stat(path3.join(dir, e.name));
+    if (!best || mtimeMs > best.mtimeMs) best = { dir: path3.join(dir, e.name), mtimeMs };
+  }
+  return best?.dir ?? null;
+}
+async function projectDirs(cwd, home) {
+  const dirs = [];
+  for (let dir = path3.resolve(cwd); dir !== path3.resolve(home) && dir !== path3.dirname(dir); dir = path3.dirname(dir)) {
+    dirs.push(dir);
+    try {
+      await fs4.access(path3.join(dir, ".git"));
+      break;
+    } catch {
+    }
+  }
+  return dirs;
+}
+async function codexMentions(home, codexHome, cwd) {
+  const mention = { sigil: "$", kind: "mention" };
+  const skills = path3.join(codexHome, "skills");
+  const found = [
+    ...await skillFiles(skills, { ...mention, source: "user" }),
+    ...await skillFiles(path3.join(skills, ".system"), { ...mention, source: "user" })
+  ];
+  for (const dir of await projectDirs(cwd, home)) {
+    found.push(...await skillFiles(path3.join(dir, ".agents", "skills"), { ...mention, source: "project" }));
+  }
+  const off = await codexDisabled(codexHome);
+  const cache = path3.join(codexHome, "plugins", "cache");
+  for (const market of await entries(cache)) {
+    if (!market.isDirectory()) continue;
+    for (const plugin of await entries(path3.join(cache, market.name))) {
+      if (!plugin.isDirectory() || off.has(`${plugin.name}@${market.name}`)) continue;
+      const root2 = await latestVersion(path3.join(cache, market.name, plugin.name));
+      if (root2) found.push(...await skillFiles(path3.join(root2, "skills"), { ...mention, prefix: `${plugin.name}:`, source: "plugin" }));
+    }
+  }
+  return found;
+}
+async function listCommands({ agent, cwd, home, codexHome = path3.join(home, ".codex") }) {
+  const builtins = (BUILTINS[agent] ?? BUILTINS.claude).map(builtin);
+  const found = agent === "codex" ? await codexMentions(home, codexHome, cwd) : await claudeCommands(home, cwd);
+  const byName = new Map(builtins.map((c) => [c.name, c]));
+  for (const c of found) byName.set(c.name, c);
+  const rest2 = [...byName.values()].filter((c) => c.source !== "builtin").sort((a, b) => a.name.localeCompare(b.name));
+  return [...byName.values()].filter((c) => c.source === "builtin").concat(rest2);
+}
+
+// ../../packages/agent-core/src/builds.js
+import { execFile, spawn } from "node:child_process";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { EventEmitter as EventEmitter2 } from "node:events";
+import fs5 from "node:fs/promises";
+import os from "node:os";
+import path4 from "node:path";
+var MAX_LINES = 5e3;
+var MAX_LINE = 2048;
+var MAX_ERRORS = 20;
+var TAIL_LINES = 15;
+var KILL_AFTER = 5e3;
+var SIGNING_HINTS = [
+  [/requires a development team/i, "Set a team in Xcode: select the app target, then Signing & Capabilities \u203A Team."],
+  [/No Account for Team|No accounts? (?:with|for|in)/i, "Sign in to Xcode with an Apple Account of the project's team (Xcode \u203A Settings \u203A Accounts)."],
+  [
+    /No profiles for|requires a provisioning profile|doesn't include (?:the )?(?:currently selected )?device|not registered|no devices/i,
+    "Run the app on this iPhone from Xcode once, so it is registered for development builds."
+  ]
+];
+async function findContainer(folder) {
+  let names;
+  try {
+    names = await fs5.readdir(folder);
+  } catch {
+    return null;
+  }
+  for (const [ext, kind] of [[".xcworkspace", "workspace"], [".xcodeproj", "project"]]) {
+    const name = names.filter((n) => n.endsWith(ext)).sort()[0];
+    if (name) return { container: path4.join(folder, name), kind };
+  }
+  return null;
+}
+function run(command, args, { cwd, timeout = 12e4 } = {}) {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, { cwd, timeout, maxBuffer: 16 * 1024 * 1024 }, (error, stdout, stderr) => {
+      if (error) reject(Object.assign(new HttpError(409, (stderr || error.message).trim().split("\n").slice(-3).join("\n")), { code: "EXCODE" }));
+      else resolve(stdout);
+    });
+  });
+}
+async function listSchemes(folder, { xcodebuild = "xcodebuild" } = {}) {
+  const found = await findContainer(folder);
+  if (!found) throw new HttpError(404, "no Xcode project or workspace in this folder");
+  const out = JSON.parse(await run(xcodebuild, ["-list", "-json", `-${found.kind}`, found.container], { cwd: folder }));
+  const schemes = out[found.kind]?.schemes ?? [];
+  return { container: path4.basename(found.container), kind: found.kind, schemes };
+}
+function failureOf(lines) {
+  const compile = [...new Set(lines.filter((l) => /^\S.*?:\d+:(?:\d+:)? error: /.test(l)))];
+  if (compile.length) return compile.slice(0, MAX_ERRORS).join("\n");
+  const errors = [...new Set(lines.filter((l) => /^(?:xcodebuild: )?error: /.test(l.trim())).map((l) => l.trim()))];
+  const text = (errors.length ? errors.slice(0, MAX_ERRORS) : lines.slice(-TAIL_LINES)).join("\n");
+  const hint = SIGNING_HINTS.find(([re]) => re.test(text))?.[1];
+  return hint ? `${hint}
+
+${text}` : text;
+}
+function exportOptions() {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+	<key>method</key><string>debugging</string>
+	<key>signingStyle</key><string>automatic</string>
+	<key>compileBitcode</key><false/>
+	<key>thinning</key><string>&lt;none&gt;</string>
+</dict></plist>
+`;
+}
+async function readInfo(appPath) {
+  const info = JSON.parse(await run("plutil", ["-convert", "json", "-o", "-", path4.join(appPath, "Info.plist")]));
+  return {
+    bundleId: info.CFBundleIdentifier,
+    version: info.CFBundleShortVersionString ?? info.CFBundleVersion ?? "1.0",
+    name: info.CFBundleDisplayName ?? info.CFBundleName ?? path4.basename(appPath, ".app")
+  };
+}
+var BuildRunner = class extends EventEmitter2 {
+  #xcodebuild;
+  #readInfo;
+  #dir;
+  #now;
+  #killAfter;
+  #build = null;
+  #lines = [];
+  #child = null;
+  constructor({ xcodebuild = "xcodebuild", readInfo: info = readInfo, dir = path4.join(os.homedir(), ".coderemote", "builds"), now = Date.now, killAfter = KILL_AFTER } = {}) {
+    super();
+    this.#xcodebuild = xcodebuild;
+    this.#readInfo = info;
+    this.#dir = dir;
+    this.#now = now;
+    this.#killAfter = killAfter;
+  }
+  get running() {
+    return this.#build?.state === "running";
+  }
+  /** The latest build with its log lines after `after` (a line count), or null before any. */
+  current(after = 0) {
+    if (!this.#build) return null;
+    const { first } = this.#build;
+    const from = Math.max(after, first);
+    return { ...this.#public(), log: this.#lines.slice(from - first), next: first + this.#lines.length };
+  }
+  /** The `.ipa` and app fields of the latest build, once it succeeded. */
+  artifact() {
+    return this.#build?.state === "succeeded" ? this.#build.artifact : null;
+  }
+  /** Starts building `scheme` of the project in `folder`; answers the build. */
+  async start({ folder, scheme, configuration = "Debug" }) {
+    if (this.running) throw new HttpError(409, "a build is already running");
+    if (typeof scheme !== "string" || !scheme) throw new HttpError(400, "scheme is required");
+    if (!/^[\w .-]+$/.test(configuration)) throw new HttpError(400, "invalid configuration");
+    const found = await findContainer(folder);
+    if (!found) throw new HttpError(404, "no Xcode project or workspace in this folder");
+    const id = randomUUID2();
+    const out = path4.join(this.#dir, id);
+    await fs5.rm(this.#dir, { recursive: true, force: true });
+    await fs5.mkdir(out, { recursive: true });
+    this.#lines = [];
+    this.#build = { id, path: folder, scheme, configuration, state: "running", step: "archiving", startedAt: this.#now(), endedAt: null, error: null, first: 0, artifact: null };
+    const build = this.#build;
+    this.#run(build, found, out).catch(() => {
+    });
+    return this.#public();
+  }
+  /** Stops the running build. */
+  cancel() {
+    if (!this.running) throw new HttpError(409, "no build is running");
+    this.#build.cancelled = true;
+    this.#stop();
+  }
+  #public() {
+    const { id, path: folder, scheme, configuration, state, step, startedAt, endedAt, error, artifact } = this.#build;
+    return { id, path: folder, scheme, configuration, state, step, startedAt, endedAt, error, app: artifact?.app ?? null };
+  }
+  #log(text) {
+    for (const raw of text.split(/\r?\n/)) {
+      if (!raw) continue;
+      this.#lines.push(raw.length > MAX_LINE ? `${raw.slice(0, MAX_LINE)}\u2026` : raw);
+    }
+    const extra = this.#lines.length - MAX_LINES;
+    if (extra > 0) {
+      this.#lines.splice(0, extra);
+      this.#build.first += extra;
+    }
+  }
+  async #run(build, { container, kind }, out) {
+    const archive = path4.join(out, "App.xcarchive");
+    const exported = path4.join(out, "export");
+    try {
+      await this.#xcode(build, [
+        `-${kind}`,
+        container,
+        "-scheme",
+        build.scheme,
+        "-configuration",
+        build.configuration,
+        "-destination",
+        "generic/platform=iOS",
+        "-archivePath",
+        archive,
+        "-allowProvisioningUpdates",
+        "-skipPackagePluginValidation",
+        "archive"
+      ], build.path);
+      build.step = "exporting";
+      const options = path4.join(out, "ExportOptions.plist");
+      await fs5.writeFile(options, exportOptions());
+      await this.#xcode(build, [
+        "-exportArchive",
+        "-archivePath",
+        archive,
+        "-exportPath",
+        exported,
+        "-exportOptionsPlist",
+        options,
+        "-allowProvisioningUpdates"
+      ], build.path);
+      const ipaName = (await fs5.readdir(exported)).find((n) => n.endsWith(".ipa"));
+      if (!ipaName) throw new Error("the export made no .ipa");
+      const apps = path4.join(archive, "Products", "Applications");
+      const appName = (await fs5.readdir(apps)).find((n) => n.endsWith(".app"));
+      if (!appName) throw new Error("the archive holds no app");
+      const ipa = path4.join(exported, ipaName);
+      const { size } = await fs5.stat(ipa);
+      build.artifact = { ipa, app: { ...await this.#readInfo(path4.join(apps, appName)), size } };
+      build.state = "succeeded";
+    } catch (e) {
+      if (build.cancelled) {
+        build.state = "cancelled";
+      } else {
+        build.state = "failed";
+        build.error = e.xcodeFailed ? failureOf(this.#lines) : e.message;
+      }
+    } finally {
+      build.endedAt = this.#now();
+      this.#child = null;
+      if (build === this.#build) this.emit("ended", this.#public());
+    }
+  }
+  #xcode(build, args, cwd) {
+    return new Promise((resolve, reject) => {
+      if (build.cancelled) return reject(new Error("cancelled"));
+      this.#log(`$ xcodebuild ${args.join(" ")}`);
+      const child = spawn(this.#xcodebuild, args, { cwd, detached: true, stdio: ["ignore", "pipe", "pipe"] });
+      this.#child = child;
+      let partial = "";
+      const take = (chunk) => {
+        const text = partial + chunk.toString("utf8");
+        const cut = text.lastIndexOf("\n");
+        partial = cut < 0 ? text : text.slice(cut + 1);
+        if (cut >= 0) this.#log(text.slice(0, cut));
+      };
+      child.stdout.on("data", take);
+      child.stderr.on("data", take);
+      child.on("error", (e) => reject(e.code === "ENOENT" ? new Error("xcodebuild was not found: install Xcode on the computer") : e));
+      child.on("close", (code) => {
+        if (partial) this.#log(partial);
+        if (code === 0) resolve();
+        else reject(Object.assign(new Error(`xcodebuild exited with ${code}`), { xcodeFailed: true }));
+      });
+    });
+  }
+  #stop() {
+    const child = this.#child;
+    if (!child?.pid) return;
+    const signal = (s) => {
+      try {
+        process.kill(-child.pid, s);
+      } catch {
+      }
+    };
+    signal("SIGTERM");
+    setTimeout(() => {
+      if (child.exitCode === null && child.signalCode === null) signal("SIGKILL");
+    }, this.#killAfter).unref?.();
+  }
+};
+
+// ../../packages/agent-core/src/history.js
+import fs6 from "node:fs/promises";
+import path5 from "node:path";
+var LIMIT = 50;
+var HEAD_BYTES2 = 128 * 1024;
+var TAIL_BYTES2 = 64 * 1024;
+var MAX_TITLE2 = 80;
+async function slice(file, position, length) {
+  let handle;
+  try {
+    handle = await fs6.open(file, "r");
+    const { size } = await handle.stat();
+    const start2 = position < 0 ? Math.max(0, size + position) : position;
+    const { buffer, bytesRead } = await handle.read(Buffer.alloc(Math.min(length, size)), 0, Math.min(length, size), start2);
+    return buffer.subarray(0, bytesRead).toString("utf8");
+  } catch {
+    return "";
+  } finally {
+    await handle?.close();
+  }
+}
+function records(text) {
+  const out = [];
+  for (const line of text.split("\n")) {
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return out;
+}
+function titleOf2(text) {
+  const line = String(text).trim().split("\n")[0].trim();
+  return line.length > MAX_TITLE2 ? `${line.slice(0, MAX_TITLE2 - 1)}\u2026` : line;
+}
+function typedPrompt(record) {
+  if (record.type !== "user" || record.isMeta || record.isSidechain) return null;
+  const content = record.message?.content;
+  const text = typeof content === "string" ? content : Array.isArray(content) ? content.find((c) => c?.type === "text")?.text : null;
+  if (typeof text !== "string") return null;
+  const t = text.trim();
+  return t && !t.startsWith("<") && !t.startsWith("[Request interrupted") ? t : null;
+}
+async function claudeHistory(home, cwd) {
+  const dir = path5.join(home, ".claude", "projects", path5.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-"));
+  let names = [];
+  try {
+    names = (await fs6.readdir(dir)).filter((n) => n.endsWith(".jsonl"));
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const name of names) {
+    try {
+      const { mtimeMs, size } = await fs6.stat(path5.join(dir, name));
+      files.push({ id: name.slice(0, -6), file: path5.join(dir, name), mtimeMs, size });
+    } catch {
+    }
+  }
+  files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const out = [];
+  for (const f of files) {
+    if (out.length >= LIMIT) break;
+    const tail = records(await slice(f.file, -TAIL_BYTES2, TAIL_BYTES2));
+    const named = tail.findLast((r) => r.type === "custom-title" && r.customTitle)?.customTitle ?? tail.findLast((r) => r.type === "ai-title" && r.aiTitle)?.aiTitle;
+    const head = named ? [] : records(await slice(f.file, 0, HEAD_BYTES2));
+    const prompt = named ? null : head.map(typedPrompt).find(Boolean);
+    if (!named && !prompt) continue;
+    out.push({
+      id: f.id,
+      title: titleOf2(named ?? prompt),
+      updatedAt: Math.round(f.mtimeMs),
+      branch: tail.findLast((r) => typeof r.gitBranch === "string")?.gitBranch ?? null,
+      size: f.size
+    });
+  }
+  return out;
+}
+async function codexHistory(codexHome, cwd) {
+  const names = /* @__PURE__ */ new Map();
+  try {
+    for (const r of records(await fs6.readFile(path5.join(codexHome, "session_index.jsonl"), "utf8"))) {
+      if (typeof r.id === "string" && typeof r.thread_name === "string") names.set(r.id, r.thread_name);
+    }
+  } catch {
+  }
+  const files = [];
+  const walk = async (dir, depth) => {
+    let entries2 = [];
+    try {
+      entries2 = await fs6.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries2) {
+      const p = path5.join(dir, e.name);
+      if (e.isDirectory() && depth < 3) await walk(p, depth + 1);
+      else if (e.isFile() && /^rollout-.*\.jsonl$/.test(e.name)) {
+        try {
+          const { mtimeMs, size } = await fs6.stat(p);
+          files.push({ file: p, mtimeMs, size });
+        } catch {
+        }
+      }
+    }
+  };
+  await walk(path5.join(codexHome, "sessions"), 0);
+  files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const want = path5.resolve(cwd);
+  const out = [];
+  for (const f of files) {
+    if (out.length >= LIMIT) break;
+    const head = await slice(f.file, 0, HEAD_BYTES2);
+    const meta = records(head.split("\n")[0])[0]?.payload;
+    if (!meta || typeof meta.id !== "string" || typeof meta.cwd !== "string" || path5.resolve(meta.cwd) !== want) continue;
+    const prompt = records(head).filter((r) => r.type === "response_item" && r.payload?.type === "message" && r.payload.role === "user").flatMap((r) => Array.isArray(r.payload.content) ? r.payload.content : []).map((c) => c?.type === "input_text" && typeof c.text === "string" ? c.text.trim() : "").find((t) => t && !t.startsWith("<") && !t.startsWith("# AGENTS.md"));
+    const title = names.get(meta.id) ?? prompt;
+    if (!title) continue;
+    out.push({
+      id: meta.id,
+      title: titleOf2(title),
+      updatedAt: Math.round(f.mtimeMs),
+      branch: typeof meta.git?.branch === "string" ? meta.git.branch : null,
+      size: f.size
+    });
+  }
+  return out;
+}
+async function listHistory({ agent, cwd, home, codexHome = path5.join(home, ".codex") }) {
+  return agent === "codex" ? codexHistory(codexHome, cwd) : claudeHistory(home, cwd);
+}
+
+// ../../packages/agent-core/src/install-links.js
+import { randomBytes } from "node:crypto";
+import { createReadStream } from "node:fs";
+import fs7 from "node:fs/promises";
+import http from "node:http";
+import { pipeline } from "node:stream/promises";
+var TTL = 10 * 60 * 1e3;
+var SHARE_HOURS = 1;
+var xml = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function manifest({ ipaUrl, bundleId, version, title }) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+	<key>items</key><array><dict>
+		<key>assets</key><array><dict>
+			<key>kind</key><string>software-package</string>
+			<key>url</key><string>${xml(ipaUrl)}</string>
+		</dict></array>
+		<key>metadata</key><dict>
+			<key>bundle-identifier</key><string>${xml(bundleId)}</string>
+			<key>bundle-version</key><string>${xml(version)}</string>
+			<key>kind</key><string>software</string>
+			<key>title</key><string>${xml(title)}</string>
+		</dict>
+	</dict></array>
+</dict></plist>
+`;
+}
+var InstallLinks = class {
+  #preview;
+  #now;
+  #ttl;
+  #setTimer;
+  #server = null;
+  #port = null;
+  #base = null;
+  #tokens = /* @__PURE__ */ new Map();
+  #serial = Promise.resolve();
+  constructor({ preview: preview2, now = Date.now, ttl = TTL, setTimer = (fn, ms) => setTimeout(fn, ms).unref?.() } = {}) {
+    this.#preview = preview2;
+    this.#now = now;
+    this.#ttl = ttl;
+    this.#setTimer = setTimer;
+  }
+  /** A link installing `ipa` (an app `{ bundleId, version, name }`): `{ url, expiresAt }`. */
+  create({ ipa, app }) {
+    return this.#queue(async () => {
+      await this.#listen();
+      if (!this.#base) {
+        const { url } = await this.#preview.forward(this.#port);
+        await this.#preview.share(this.#port, SHARE_HOURS);
+        this.#base = url.replace(/\/+$/, "");
+      }
+      const token = randomBytes(24).toString("hex");
+      const expiresAt = this.#now() + this.#ttl;
+      const manifestUrl = `${this.#base}/${token}/manifest.plist`;
+      this.#tokens.set(token, {
+        ipa,
+        manifest: manifest({ ipaUrl: `${this.#base}/${token}/app.ipa`, bundleId: app.bundleId, version: app.version, title: app.name })
+      });
+      this.#setTimer(() => this.#expire(token), this.#ttl);
+      return { url: `itms-services://?action=download-manifest&url=${encodeURIComponent(manifestUrl)}`, expiresAt };
+    });
+  }
+  /** Whether links are being served through the preview tunnel right now. */
+  get sharing() {
+    return this.#base !== null;
+  }
+  /** Ends every link now and closes the public window (the Ports tab's Stop). */
+  stop() {
+    const tokens = [...this.#tokens.keys()];
+    if (!tokens.length) return this.#queue(async () => {
+    });
+    for (const token of tokens.slice(0, -1)) this.#tokens.delete(token);
+    this.#expire(tokens.at(-1));
+    return this.#queue(async () => {
+    });
+  }
+  /** Live tokens, for tests. */
+  get size() {
+    return this.#tokens.size;
+  }
+  /** The local port the files are served on (null until first used). */
+  get port() {
+    return this.#port;
+  }
+  close() {
+    this.#tokens.clear();
+    this.#server?.close();
+  }
+  #queue(fn) {
+    const next = this.#serial.then(fn, fn);
+    this.#serial = next.catch(() => {
+    });
+    return next;
+  }
+  #expire(token) {
+    if (!this.#tokens.delete(token) || this.#tokens.size) return;
+    this.#queue(async () => {
+      if (this.#tokens.size || !this.#base) return;
+      this.#base = null;
+      try {
+        await this.#preview.unshare(this.#port);
+        await this.#preview.unforward(this.#port);
+      } catch {
+      }
+    });
+  }
+  async #listen() {
+    if (this.#server) return;
+    this.#server = http.createServer((req, res) => this.#serve(req, res).catch(() => res.destroy()));
+    await new Promise((resolve, reject) => {
+      this.#server.once("error", reject);
+      this.#server.listen(0, "127.0.0.1", resolve);
+    });
+    this.#port = this.#server.address().port;
+  }
+  async #serve(req, res) {
+    const m = /^\/([0-9a-f]{48})\/(manifest\.plist|app\.ipa)$/.exec(req.url.split("?")[0]);
+    const link = m && this.#tokens.get(m[1]);
+    if (!link || req.method !== "GET" && req.method !== "HEAD") {
+      res.writeHead(404).end();
+      return;
+    }
+    if (m[2] === "manifest.plist") {
+      const body = Buffer.from(link.manifest);
+      res.writeHead(200, { "content-type": "text/xml", "content-length": body.length, "cache-control": "no-store" });
+      res.end(req.method === "HEAD" ? void 0 : body);
+      return;
+    }
+    const { size } = await fs7.stat(link.ipa);
+    res.writeHead(200, { "content-type": "application/octet-stream", "content-length": size, "cache-control": "no-store" });
+    if (req.method === "HEAD") return res.end();
+    await pipeline(createReadStream(link.ipa), res);
+    this.#expire(m[1]);
+  }
+};
+
+// ../../packages/agent-core/src/git.js
+import { execFile as execFile2 } from "node:child_process";
+import fs8 from "node:fs/promises";
+import path6 from "node:path";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".build", "build", "dist", "DerivedData", "Pods", "vendor", ".venv", "target"]);
 var MAX_SCAN_DEPTH = 4;
 var MAX_DIFF_BYTES = 2 * 1024 * 1024;
 function git(cwd, args, { timeout = 3e4, okCodes = [0], maxBuffer = 16 * 1024 * 1024 } = {}) {
   return new Promise((resolve, reject) => {
-    execFile(
+    execFile2(
       "git",
       args,
       {
@@ -829,30 +1721,36 @@ function git(cwd, args, { timeout = 3e4, okCodes = [0], maxBuffer = 16 * 1024 *
 async function findRepos(root2) {
   const repos = [];
   async function walk(dir, depth) {
-    let entries;
+    let entries2;
     try {
-      entries = await fs4.readdir(dir, { withFileTypes: true });
+      entries2 = await fs8.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
-    if (entries.some((e) => e.name === ".git")) {
-      repos.push(dir);
-      return;
-    }
+    if (entries2.some((e) => e.name === ".git")) repos.push(dir);
     if (depth >= MAX_SCAN_DEPTH) return;
-    const subdirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && !SKIP_DIRS.has(e.name));
-    await Promise.all(subdirs.map((e) => walk(path3.join(dir, e.name), depth + 1)));
+    const subdirs = entries2.filter((e) => e.isDirectory() && !e.name.startsWith(".") && !SKIP_DIRS.has(e.name));
+    await Promise.all(subdirs.map((e) => walk(path6.join(dir, e.name), depth + 1)));
   }
   await walk(root2, 0);
-  repos.sort((a, b) => a.split(path3.sep).length - b.split(path3.sep).length || a.localeCompare(b));
+  repos.sort((a, b) => a.split(path6.sep).length - b.split(path6.sep).length || a.localeCompare(b));
   return Promise.all(
     repos.map(async (repo) => ({
       path: repo,
-      name: repo === root2 ? path3.basename(root2) : path3.relative(root2, repo),
-      branch: await currentBranch(repo)
+      name: repo === root2 ? path6.basename(root2) : path6.relative(root2, repo),
+      branch: await currentBranch(repo),
+      ...await summary(repo)
     }))
   );
 }
+async function summary(repo) {
+  try {
+    const { files, ahead, behind } = await status(repo);
+    return { changes: files.length, ahead, behind };
+  } catch {
+    return { changes: null, ahead: null, behind: null };
+  }
+}
 async function currentBranch(repo) {
   try {
     const { stdout } = await git(repo, ["symbolic-ref", "--short", "-q", "HEAD"], { okCodes: [0, 1] });
@@ -866,9 +1764,9 @@ async function currentBranch(repo) {
 async function status(repo) {
   const { stdout } = await git(repo, ["status", "--porcelain=v2", "--branch", "--untracked-files=all", "-z"]);
   const result = { branch: null, upstream: null, ahead: 0, behind: 0, files: [] };
-  const records = stdout.split("\0");
-  for (let i = 0; i < records.length; i++) {
-    const r = records[i];
+  const records2 = stdout.split("\0");
+  for (let i = 0; i < records2.length; i++) {
+    const r = records2[i];
     if (!r) continue;
     if (r.startsWith("# branch.head ")) {
       const head = r.slice(14);
@@ -881,20 +1779,20 @@ async function status(repo) {
       result.behind = Math.abs(parseInt(b, 10));
     } else if (r.startsWith("1 ")) {
       const parts = r.split(" ");
-      result.files.push(entry(parts[1], parts.slice(8).join(" ")));
+      result.files.push(entry2(parts[1], parts.slice(8).join(" ")));
     } else if (r.startsWith("2 ")) {
       const parts = r.split(" ");
-      result.files.push({ ...entry(parts[1], parts.slice(9).join(" ")), origPath: records[++i] });
+      result.files.push({ ...entry2(parts[1], parts.slice(9).join(" ")), origPath: records2[++i] });
     } else if (r.startsWith("u ")) {
       const parts = r.split(" ");
-      result.files.push({ ...entry(parts[1], parts.slice(10).join(" ")), conflicted: true });
+      result.files.push({ ...entry2(parts[1], parts.slice(10).join(" ")), conflicted: true });
     } else if (r.startsWith("? ")) {
       result.files.push({ path: r.slice(2), index: ".", worktree: "?" });
     }
   }
   return result;
 }
-function entry(xy, filePath) {
+function entry2(xy, filePath) {
   return { path: filePath, index: xy[0], worktree: xy[1] };
 }
 async function diff(repo, file, { staged = false, untracked = false } = {}) {
@@ -1051,32 +1949,33 @@ var LANDING_HTML = `<!doctype html>
 `;
 
 // ../../packages/agent-core/src/ports.js
-import { execFile as execFile3 } from "node:child_process";
-import fs6 from "node:fs/promises";
-import os from "node:os";
+import { execFile as execFile4 } from "node:child_process";
+import fs10 from "node:fs/promises";
+import net from "node:net";
+import os2 from "node:os";
 
 // ../../packages/agent-core/src/platform.js
-import { execFile as execFile2, spawn } from "node:child_process";
-import fs5 from "node:fs";
-import path4 from "node:path";
+import { execFile as execFile3, spawn as spawn2 } from "node:child_process";
+import fs9 from "node:fs";
+import path7 from "node:path";
 var isWindows = process.platform === "win32";
 function shellQuote(arg) {
   return `'${String(arg).replace(/'/g, `'\\''`)}'`;
 }
 function runnable(file) {
   try {
-    if (!isWindows) fs5.accessSync(file, fs5.constants.X_OK);
-    return fs5.statSync(file).isFile();
+    if (!isWindows) fs9.accessSync(file, fs9.constants.X_OK);
+    return fs9.statSync(file).isFile();
   } catch {
     return false;
   }
 }
 function findExecutable(name, env = process.env) {
-  const exts = isWindows && !path4.extname(name) ? (env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
+  const exts = isWindows && !path7.extname(name) ? (env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
   const match = (base2) => exts.map((e) => base2 + e).find(runnable) ?? null;
-  if (name.includes("/") || name.includes(path4.sep)) return match(path4.resolve(name));
-  for (const dir of (env.PATH ?? env.Path ?? "").split(path4.delimiter)) {
-    const found = dir && match(path4.join(dir.replace(/^"(.*)"$/, "$1"), name));
+  if (name.includes("/") || name.includes(path7.sep)) return match(path7.resolve(name));
+  for (const dir of (env.PATH ?? env.Path ?? "").split(path7.delimiter)) {
+    const found = dir && match(path7.join(dir.replace(/^"(.*)"$/, "$1"), name));
     if (found) return found;
   }
   return null;
@@ -1105,12 +2004,12 @@ function terminalCommand(argv2) {
 }
 function spawnCommand(argv2, options = {}) {
   const { file, args, verbatim } = resolveCommand(argv2);
-  return spawn(file, args, { ...options, windowsVerbatimArguments: verbatim });
+  return spawn2(file, args, { ...options, windowsVerbatimArguments: verbatim });
 }
 function execCommand(argv2, options = {}) {
   return new Promise((resolve, reject) => {
     const { file, args, verbatim } = resolveCommand(argv2);
-    execFile2(
+    execFile3(
       file,
       args,
       { ...options, windowsVerbatimArguments: verbatim },
@@ -1120,7 +2019,7 @@ function execCommand(argv2, options = {}) {
 }
 function loginShell(script, timeout) {
   return new Promise((resolve) => {
-    execFile2(
+    execFile3(
       interactiveShell().file,
       ["-l", "-c", script],
       { timeout, maxBuffer: 16 * 1024 * 1024 },
@@ -1142,9 +2041,9 @@ async function commandExists(command) {
 }
 
 // ../../packages/agent-core/src/ports.js
-function run(cmd2, args) {
+function run2(cmd2, args) {
   return new Promise((resolve, reject) => {
-    execFile3(cmd2, args, { maxBuffer: 8 * 1024 * 1024 }, (err, stdout) => {
+    execFile4(cmd2, args, { maxBuffer: 8 * 1024 * 1024 }, (err, stdout) => {
       if (err?.code === "ENOENT") reject(err);
       else resolve(stdout || "");
     });
@@ -1158,7 +2057,7 @@ function splitHostPort(name) {
 }
 async function listeningSockets() {
   try {
-    const out2 = await run("lsof", ["-nP", "-a", "-u", String(os.userInfo().uid), "-iTCP", "-sTCP:LISTEN", "-F", "pcn"]);
+    const out2 = await run2("lsof", ["-nP", "-a", "-u", String(os2.userInfo().uid), "-iTCP", "-sTCP:LISTEN", "-F", "pcn"]);
     const sockets2 = [];
     let pid;
     let name;
@@ -1173,9 +2072,9 @@ async function listeningSockets() {
     }
     return sockets2;
   } catch (e) {
-    if (e.code !== "ENOENT" || os.platform() !== "linux") throw e;
+    if (e.code !== "ENOENT" || os2.platform() !== "linux") throw e;
   }
-  const out = await run("ss", ["-Hltnp"]);
+  const out = await run2("ss", ["-Hltnp"]);
   const sockets = [];
   for (const line of out.split("\n")) {
     const cols = line.trim().split(/\s+/);
@@ -1186,7 +2085,7 @@ async function listeningSockets() {
   return sockets;
 }
 async function processTable() {
-  const out = await run("ps", ["-A", "-ww", "-o", "pid=,ppid=,tty=,command="]);
+  const out = await run2("ps", ["-A", "-ww", "-o", "pid=,ppid=,tty=,command="]);
   const table = /* @__PURE__ */ new Map();
   for (const line of out.split("\n")) {
     const m = line.match(/^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/);
@@ -1197,11 +2096,11 @@ async function processTable() {
 async function workingDirs(pids) {
   const dirs = /* @__PURE__ */ new Map();
   if (!pids.length || isWindows) return dirs;
-  if (os.platform() === "linux") {
-    await Promise.all(pids.map(async (pid2) => dirs.set(pid2, await fs6.readlink(`/proc/${pid2}/cwd`).catch(() => null))));
+  if (os2.platform() === "linux") {
+    await Promise.all(pids.map(async (pid2) => dirs.set(pid2, await fs10.readlink(`/proc/${pid2}/cwd`).catch(() => null))));
     return dirs;
   }
-  const out = await run("lsof", ["-a", "-p", pids.join(","), "-d", "cwd", "-F", "pn"]).catch(() => "");
+  const out = await run2("lsof", ["-a", "-p", pids.join(","), "-d", "cwd", "-F", "pn"]).catch(() => "");
   let pid;
   for (const line of out.split("\n")) {
     if (line[0] === "p") pid = parseInt(line.slice(1), 10);
@@ -1213,9 +2112,9 @@ var WINDOWS_SHELLS = /* @__PURE__ */ new Set(["cmd.exe", "powershell.exe", "pwsh
 async function windowsListeners() {
   const query = "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name,CommandLine | ConvertTo-Json -Compress";
   const [v4, v6, json] = await Promise.all([
-    run("netstat", ["-ano", "-p", "TCP"]),
-    run("netstat", ["-ano", "-p", "TCPv6"]),
-    run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", query])
+    run2("netstat", ["-ano", "-p", "TCP"]),
+    run2("netstat", ["-ano", "-p", "TCPv6"]),
+    run2("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", query])
   ]);
   const table = /* @__PURE__ */ new Map();
   for (const p of [JSON.parse(json || "[]")].flat()) {
@@ -1245,9 +2144,9 @@ async function listPorts(shells = /* @__PURE__ */ new Map()) {
   const byKey = /* @__PURE__ */ new Map();
   for (const s of sockets) {
     const key = `${s.pid}:${s.port}`;
-    const entry2 = byKey.get(key);
-    if (entry2) {
-      if (!entry2.addresses.includes(s.address)) entry2.addresses.push(s.address);
+    const entry3 = byKey.get(key);
+    if (entry3) {
+      if (!entry3.addresses.includes(s.address)) entry3.addresses.push(s.address);
       continue;
     }
     byKey.set(key, {
@@ -1264,10 +2163,10 @@ async function listPorts(shells = /* @__PURE__ */ new Map()) {
       agent: s.pid === process.pid || AGENT_COMMAND.test(table.get(s.pid)?.command ?? "")
     });
   }
-  const entries = [...byKey.values()];
-  const dirs = await workingDirs([...new Set(entries.map((e) => e.pid))]);
-  for (const e of entries) e.cwd = dirs.get(e.pid) ?? null;
-  return entries.sort((a, b) => a.port - b.port || a.pid - b.pid);
+  const entries2 = [...byKey.values()];
+  const dirs = await workingDirs([...new Set(entries2.map((e) => e.pid))]);
+  for (const e of entries2) e.cwd = dirs.get(e.pid) ?? null;
+  return entries2.sort((a, b) => a.port - b.port || a.pid - b.pid);
 }
 function sessionOf(pid, table, shells) {
   for (let p = pid, depth = 0; p > 1 && depth < 64; p = table.get(p)?.ppid, depth++) {
@@ -1278,28 +2177,42 @@ function sessionOf(pid, table, shells) {
 async function killListener(pid, { force = false, shells } = {}) {
   if (!Number.isInteger(pid) || pid <= 1) throw new HttpError(400, "pid must be a process id");
   if (pid === process.pid) throw new HttpError(403, "the agent cannot stop itself");
-  const ports = await listPorts(shells);
-  if (!ports.some((p) => p.pid === pid)) throw new HttpError(404, "no listening process with that pid");
+  const ports = (await listPorts(shells)).filter((p) => p.pid === pid).map((p) => p.port);
+  if (!ports.length) throw new HttpError(404, "no listening process with that pid");
   try {
     process.kill(pid, force ? "SIGKILL" : "SIGTERM");
   } catch (e) {
     if (e.code === "ESRCH") throw new HttpError(404, "no listening process with that pid");
     throw e;
   }
+  return ports;
+}
+function isListening(port2, timeout = 2e3) {
+  return new Promise((resolve) => {
+    const socket = net.connect({ host: "localhost", port: port2, timeout });
+    const done = (up) => {
+      socket.destroy();
+      resolve(up);
+    };
+    socket.once("connect", () => done(true));
+    socket.once("timeout", () => done(true));
+    socket.once("error", () => done(false));
+  });
 }
 
 // ../../packages/agent-core/src/push.js
-import { execFile as execFile4 } from "node:child_process";
-import { createCipheriv, randomBytes } from "node:crypto";
-import os2 from "node:os";
+import { execFile as execFile5 } from "node:child_process";
+import { createCipheriv, randomBytes as randomBytes2 } from "node:crypto";
+import os3 from "node:os";
 import { promisify } from "node:util";
-var run2 = promisify(execFile4);
+var run3 = promisify(execFile5);
 var FINISHED_AFTER = 60 * 1e3;
 var ACTIVE_WITHIN = 2 * 60;
+var AT_SESSION_WITHIN = 30;
 async function macIdleSeconds() {
-  if (os2.platform() !== "darwin") return null;
+  if (os3.platform() !== "darwin") return null;
   try {
-    const { stdout } = await run2("ioreg", ["-c", "IOHIDSystem", "-d", "4", "-k", "HIDIdleTime"], { timeout: 2e3 });
+    const { stdout } = await run3("ioreg", ["-c", "IOHIDSystem", "-d", "4", "-k", "HIDIdleTime"], { timeout: 2e3 });
     const ns = stdout.match(/"HIDIdleTime"\s*=\s*(\d+)/)?.[1];
     return ns ? Number(BigInt(ns) / 1000000000n) : null;
   } catch {
@@ -1310,8 +2223,25 @@ async function userActiveHere() {
   const idle = await macIdleSeconds();
   return idle !== null && idle < ACTIVE_WITHIN;
 }
+async function frontAppHere() {
+  if (os3.platform() !== "darwin") return null;
+  try {
+    const { stdout: asn } = await run3("lsappinfo", ["front"], { timeout: 2e3 });
+    if (!asn.trim()) return null;
+    const { stdout } = await run3("lsappinfo", ["info", asn.trim()], { timeout: 2e3 });
+    return stdout.match(/bundle path="([^"]+)"/)?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+async function atSessionHere(session, { idle = macIdleSeconds, front = frontAppHere } = {}) {
+  if (!session || session.terminal) return false;
+  const seconds = await idle();
+  if (seconds === null || seconds >= AT_SESSION_WITHIN) return false;
+  return !session.app || await front() === session.app;
+}
 function seal(key, data) {
-  const nonce = randomBytes(12);
+  const nonce = randomBytes2(12);
   const cipher = createCipheriv("aes-256-gcm", key, nonce);
   const body = Buffer.concat([cipher.update(JSON.stringify(data), "utf8"), cipher.final()]);
   return Buffer.concat([nonce, body, cipher.getAuthTag()]).toString("base64");
@@ -1361,8 +2291,8 @@ var PushSender = class {
   #devices;
   #store;
   #hub;
-  #foreground;
-  #userActive;
+  #shows;
+  #atSession;
   #fetch;
   // Requests a notification went out for, so their resolution can replace it.
   #notified = /* @__PURE__ */ new Set();
@@ -1370,15 +2300,17 @@ var PushSender = class {
    * @param {object} opts
    * @param {import('./agents.js').AgentHub} opts.hub
    * @param {{ load: () => object[], save: (devices: object[]) => void }} [opts.store]
-   * @param {() => boolean} [opts.foreground]  whether a client shows this machine right now
-   * @param {() => Promise<boolean>} [opts.userActive]  whether someone is using the computer
+   * @param {(what: { session?: string, builds?: boolean }) => boolean} [opts.shows]  whether a
+   *        client shows that session (or the builds) right now
+   * @param {(host: { terminal: string | null, app: string | null } | null) => Promise<boolean>} [opts.atSession]
+   *        whether someone at the computer is working in the session running there
    */
-  constructor({ hub, store = null, foreground = () => false, userActive = null, fetch: fetch2 = globalThis.fetch }) {
+  constructor({ hub, store = null, shows = () => false, atSession = atSessionHere, fetch: fetch2 = globalThis.fetch }) {
     this.#hub = hub;
     this.#store = store;
     this.#devices = store?.load() ?? [];
-    this.#foreground = foreground;
-    this.#userActive = userActive ?? userActiveHere;
+    this.#shows = shows;
+    this.#atSession = atSession;
     this.#fetch = fetch2;
     hub.on("message", (msg) => this.#follow(msg).catch(() => {
     }));
@@ -1411,10 +2343,12 @@ var PushSender = class {
   #save() {
     this.#store?.save(this.#devices);
   }
-  async #quiet() {
-    if (this.#foreground()) return true;
+  /** No push about a session someone is looking at, on a client or at the computer. */
+  async #quiet(what) {
+    if (this.#shows(what)) return true;
+    if (!what.session) return false;
     try {
-      return await this.#userActive();
+      return await this.#atSession(this.#hub.host(what.session));
     } catch {
       return false;
     }
@@ -1423,7 +2357,7 @@ var PushSender = class {
     if (!this.#devices.length) return;
     if (msg.type === "request") {
       const { request } = msg;
-      if (await this.#quiet()) return;
+      if (await this.#quiet({ session: request.session })) return;
       if (!this.#hub.requests().some((r) => r.id === request.id)) return;
       this.#notified.add(request.id);
       const question = request.kind === "question";
@@ -1455,7 +2389,7 @@ var PushSender = class {
         fallback: "Answered on your computer"
       });
     } else if (msg.type === "entry" && msg.entry.kind === "turn_end" && msg.entry.duration >= FINISHED_AFTER) {
-      if (await this.#quiet()) return;
+      if (await this.#quiet({ session: msg.session })) return;
       const session = this.#hub.session(msg.session);
       await this.#broadcast("finished", {
         kind: "finished",
@@ -1467,11 +2401,27 @@ var PushSender = class {
       });
     }
   }
+  /** A build ended (see builds.js): ready to install, or failed. Cancelled builds say nothing. */
+  async buildEnded(build) {
+    if (!this.#devices.length || build.state === "cancelled") return;
+    if (await this.#quiet({ builds: true })) return;
+    const ok = build.state === "succeeded";
+    const firstError = String(build.error ?? "").split("\n").find((l) => l.trim()) ?? "";
+    await this.#broadcast("finished", {
+      kind: "build",
+      title: ok ? "Build ready to install" : "Build failed",
+      body: ok ? `${build.app?.name ?? build.scheme} ${build.app?.version ?? ""}`.trim() : `${build.scheme}: ${firstError}`,
+      build: build.id,
+      category: "BUILD",
+      collapseId: `build-${build.id}`,
+      fallback: ok ? "A build is ready to install" : "A build failed"
+    });
+  }
   async #broadcast(kind, note) {
     await Promise.all(this.#devices.filter((d) => d.kinds[kind]).map((d) => this.#send(d, note)));
   }
-  async #send(device, { kind, title, body, session, request, question, options, category, collapseId, priority, silent, fallback }) {
-    const secret = { kind, title, body, session, request, question, options };
+  async #send(device, { kind, title, body, session, request, build, question, options, category, collapseId, priority, silent, fallback }) {
+    const secret = { kind, title, body, session, request, build, question, options };
     const aps = { alert: { title: "Code Remote", body: fallback }, "mutable-content": 1 };
     if (category) aps.category = category;
     if (session) aps["thread-id"] = session;
@@ -1506,8 +2456,8 @@ var PushSender = class {
 };
 
 // ../../packages/agent-core/src/inspector.js
-import http from "node:http";
-import net from "node:net";
+import http2 from "node:http";
+import net2 from "node:net";
 import zlib from "node:zlib";
 var MAX_ENTRIES2 = 200;
 var MAX_BODY = 64 * 1024;
@@ -1549,7 +2499,7 @@ var InspectingProxy = class {
   /** @param {number} target  the dev server's port on this machine */
   constructor(target) {
     this.target = target;
-    this.server = http.createServer((req, res) => this.#forward(req, res));
+    this.server = http2.createServer((req, res) => this.#forward(req, res));
     this.server.on("upgrade", (req, socket, head) => this.#tunnelUpgrade(req, socket, head));
   }
   /** Listens on a free loopback port; resolves to it. */
@@ -1567,7 +2517,7 @@ var InspectingProxy = class {
   }
   /** Summaries, oldest first; `after` skips ids up to and including it. */
   list(after = 0) {
-    return this.#entries.filter((e) => e.id > after).map(summary);
+    return this.#entries.filter((e) => e.id > after).map(summary2);
   }
   get(id) {
     return this.#entries.find((e) => e.id === id);
@@ -1576,7 +2526,7 @@ var InspectingProxy = class {
     this.#entries = [];
   }
   #record(req) {
-    const entry2 = {
+    const entry3 = {
       id: nextId++,
       time: Date.now(),
       method: req.method,
@@ -1587,21 +2537,21 @@ var InspectingProxy = class {
       request: { headers: req.headers, tap: new BodyTap() },
       response: { headers: {}, tap: new BodyTap() }
     };
-    this.#entries.push(entry2);
+    this.#entries.push(entry3);
     if (this.#entries.length > MAX_ENTRIES2) this.#entries.shift();
-    return entry2;
+    return entry3;
   }
   /** The dev server sees itself addressed as localhost:<its port>, as without the proxy. */
   #headers(req) {
     return { ...req.headers, host: `localhost:${this.target}` };
   }
   #forward(req, res) {
-    const entry2 = this.#record(req);
+    const entry3 = this.#record(req);
     const started = performance.now();
     const finish = () => {
-      entry2.duration = Math.round(performance.now() - started);
+      entry3.duration = Math.round(performance.now() - started);
     };
-    const upstream = http.request({
+    const upstream = http2.request({
       agent: false,
       host: "localhost",
       port: this.target,
@@ -1610,11 +2560,11 @@ var InspectingProxy = class {
       headers: this.#headers(req)
     });
     upstream.on("response", (up) => {
-      entry2.status = up.statusCode;
-      entry2.response.headers = up.headers;
+      entry3.status = up.statusCode;
+      entry3.response.headers = up.headers;
       res.writeHead(up.statusCode, up.statusMessage, up.rawHeaders);
       up.on("data", (chunk) => {
-        entry2.response.tap.push(chunk);
+        entry3.response.tap.push(chunk);
         res.write(chunk);
       });
       up.on("end", () => {
@@ -1625,14 +2575,14 @@ var InspectingProxy = class {
     });
     upstream.on("error", (e) => {
       finish();
-      entry2.error = e.code === "ECONNREFUSED" ? `nothing is listening on port ${this.target}` : e.message;
+      entry3.error = e.code === "ECONNREFUSED" ? `nothing is listening on port ${this.target}` : e.message;
       if (res.headersSent) return res.destroy();
-      entry2.status = 502;
+      entry3.status = 502;
       res.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
-      res.end(`coderemote preview: ${entry2.error}
+      res.end(`coderemote preview: ${entry3.error}
 `);
     });
-    req.on("data", (chunk) => entry2.request.tap.push(chunk));
+    req.on("data", (chunk) => entry3.request.tap.push(chunk));
     req.pipe(upstream);
     res.on("close", () => {
       if (!res.writableFinished) upstream.destroy();
@@ -1640,8 +2590,8 @@ var InspectingProxy = class {
   }
   /** WebSockets (hot reload) pass through as raw bytes; only the handshake is recorded. */
   #tunnelUpgrade(req, socket, head) {
-    const entry2 = this.#record(req);
-    const upstream = net.connect({ host: "localhost", port: this.target }, () => {
+    const entry3 = this.#record(req);
+    const upstream = net2.connect({ host: "localhost", port: this.target }, () => {
       const headers = this.#headers(req);
       const lines = [`${req.method} ${req.url} HTTP/1.1`];
       for (const [k, v] of Object.entries(headers)) {
@@ -1651,18 +2601,18 @@ var InspectingProxy = class {
 \r
 `);
       if (head?.length) upstream.write(head);
-      entry2.status = 101;
+      entry3.status = 101;
       upstream.pipe(socket);
       socket.pipe(upstream);
     });
     upstream.on("error", (e) => {
-      entry2.error = e.message;
+      entry3.error = e.message;
       socket.destroy();
     });
     socket.on("error", () => upstream.destroy());
   }
 };
-function summary(e) {
+function summary2(e) {
   return {
     id: e.id,
     time: e.time,
@@ -1678,16 +2628,369 @@ function summary(e) {
 }
 function detail(e) {
   return {
-    ...summary(e),
+    ...summary2(e),
     request: { headers: e.request.headers, body: e.request.tap.describe(e.request.headers) },
     response: { headers: e.response.headers, body: e.response.tap.describe(e.response.headers) }
   };
 }
 
+// ../../packages/agent-core/src/search.js
+import { execFile as execFile6, spawn as spawn3 } from "node:child_process";
+import fs11 from "node:fs/promises";
+import path8 from "node:path";
+import readline from "node:readline";
+var ALWAYS_SKIPPED = /* @__PURE__ */ new Set([".git", "node_modules"]);
+var MAX_FILE_BYTES = 2 * 1024 * 1024;
+var MAX_QUERY = 1e3;
+var MAX_LINE2 = 240;
+var LEAD = 40;
+var MAX_RANGES = 20;
+var NAME_LIMIT = 100;
+var DEFAULT_LIMIT = 500;
+var MAX_LIMIT = 2e3;
+var PER_FILE = 100;
+var TIMEOUT_MS = 15e3;
+var rgPath;
+function ripgrep() {
+  if (rgPath === void 0) rgPath = findExecutable("rg");
+  return rgPath;
+}
+function queryRegex(query, { caseSensitive = false, wholeWord = false, regex = false } = {}, global = false) {
+  let source = regex ? query : query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  if (wholeWord) source = `\\b(?:${source})\\b`;
+  try {
+    return new RegExp(source, `${global ? "g" : ""}${caseSensitive ? "" : "i"}`);
+  } catch (e) {
+    throw new HttpError(400, `invalid regular expression: ${e.message}`);
+  }
+}
+function globSource(glob) {
+  let out = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*" && glob[i + 1] === "*") {
+      if (glob[i + 2] === "/") {
+        out += "(?:.*/)?";
+        i += 2;
+      } else {
+        out += ".*";
+        i += 1;
+      }
+    } else if (c === "*") out += "[^/]*";
+    else if (c === "?") out += "[^/]";
+    else if (c === "{") out += "(?:";
+    else if (c === "}") out += ")";
+    else if (c === ",") out += "|";
+    else out += c.replace(/[.+^$()|[\]\\]/g, "\\$&");
+  }
+  return out;
+}
+function pathFilter(include = "", exclude = "") {
+  const matchers = (list) => splitPatterns(list).map((raw) => {
+    let p = raw.replace(/\\/g, "/").replace(/^\.\//, "");
+    if (!/[*?{]/.test(p)) {
+      if (p.startsWith("/")) {
+        const head = p.slice(1).replace(/\/$/, "").toLowerCase();
+        return (rel) => {
+          const r = rel.toLowerCase();
+          return r === head || r.startsWith(`${head}/`);
+        };
+      }
+      const needle = p.toLowerCase();
+      return (rel) => rel.toLowerCase().includes(needle);
+    }
+    if (p.startsWith("/")) p = p.slice(1);
+    else if (!p.startsWith("**/")) p = `**/${p}`;
+    const re = new RegExp(`^${globSource(p.replace(/\/$/, ""))}(?:/.*)?$`, "i");
+    return (rel) => re.test(rel);
+  });
+  const inc = matchers(include);
+  const exc = matchers(exclude);
+  return (rel) => (!inc.length || inc.some((m) => m(rel))) && !exc.some((m) => m(rel));
+}
+function splitPatterns(list) {
+  const out = [];
+  let depth = 0;
+  let cur = "";
+  for (const c of list) {
+    if (c === "{") depth++;
+    if (c === "}") depth = Math.max(0, depth - 1);
+    if (c === "," && depth === 0) {
+      out.push(cur);
+      cur = "";
+    } else cur += c;
+  }
+  out.push(cur);
+  return out.map((s) => s.trim()).filter(Boolean);
+}
+function preview(line, re) {
+  const all = [];
+  re.lastIndex = 0;
+  for (let m; all.length < MAX_RANGES && (m = re.exec(line)); ) {
+    if (m[0].length === 0) {
+      re.lastIndex++;
+      continue;
+    }
+    all.push([m.index, m.index + m[0].length]);
+  }
+  const indent2 = line.length - line.trimStart().length;
+  let start2 = indent2;
+  if (all.length && line.length - start2 > MAX_LINE2) start2 = Math.max(indent2, all[0][0] - LEAD);
+  const end = Math.min(line.length, start2 + MAX_LINE2);
+  const ranges = all.filter(([s, e]) => e > start2 && s < end).map(([s, e]) => [Math.max(s, start2) - start2, Math.min(e, end) - start2]);
+  return { text: line.slice(start2, end).trimEnd(), ranges, clipped: start2 > indent2 || end < line.length };
+}
+function runGit(cwd, args) {
+  return new Promise((resolve) => {
+    execFile6(
+      "git",
+      args,
+      { cwd, maxBuffer: 256 * 1024 * 1024, env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" } },
+      (err, out) => resolve(err ? null : out)
+    );
+  });
+}
+async function exists(p) {
+  try {
+    await fs11.lstat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listFiles(root2, signal) {
+  const files = [];
+  const skipped = (rel) => rel.split("/").some((part) => ALWAYS_SKIPPED.has(part));
+  const join = (prefix, name) => prefix ? `${prefix}/${name}` : name;
+  async function fromGit(dir, prefix) {
+    const [tracked, untracked] = await Promise.all([
+      runGit(dir, ["ls-files", "-z", "-s"]),
+      runGit(dir, ["ls-files", "-z", "-o", "--exclude-standard"])
+    ]);
+    if (tracked === null || untracked === null) return false;
+    const subdirs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry3 of tracked.split("\0")) {
+      if (!entry3) continue;
+      const tab = entry3.indexOf("	");
+      const mode = entry3.slice(0, entry3.indexOf(" "));
+      const rel = entry3.slice(tab + 1);
+      if (seen.has(rel)) continue;
+      seen.add(rel);
+      if (skipped(rel)) continue;
+      if (mode === "160000") subdirs.push(rel);
+      else if (mode !== "120000") files.push(join(prefix, rel));
+    }
+    for (const rel of untracked.split("\0")) {
+      if (!rel || skipped(rel)) continue;
+      if (rel.endsWith("/")) subdirs.push(rel.slice(0, -1));
+      else files.push(join(prefix, rel));
+    }
+    for (const rel of subdirs) await visit(path8.join(dir, rel), join(prefix, rel));
+    return true;
+  }
+  async function visit(dir, prefix) {
+    if (signal?.aborted) return;
+    if (await exists(path8.join(dir, ".git")) && await fromGit(dir, prefix)) return;
+    let entries2;
+    try {
+      entries2 = await fs11.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries2) {
+      if (ALWAYS_SKIPPED.has(e.name)) continue;
+      if (e.isDirectory()) await visit(path8.join(dir, e.name), join(prefix, e.name));
+      else if (e.isFile()) files.push(join(prefix, e.name));
+    }
+  }
+  await visit(root2, "");
+  return files;
+}
+var Results = class {
+  constructor(limit) {
+    this.limit = limit;
+    this.count = 0;
+    this.byFile = /* @__PURE__ */ new Map();
+    this.truncated = false;
+  }
+  get full() {
+    return this.count >= this.limit;
+  }
+  /** Whether a match came past the limit: there are more than it, so searching can stop. */
+  get done() {
+    return this.full && this.truncated;
+  }
+  add(rel, line, match) {
+    if (this.full) {
+      this.truncated = true;
+      return;
+    }
+    let file = this.byFile.get(rel);
+    if (!file) this.byFile.set(rel, file = []);
+    if (file.length >= PER_FILE) {
+      this.truncated = true;
+      return;
+    }
+    file.push({ line, ...match });
+    this.count++;
+  }
+};
+async function searchFile(root2, rel, test, re, results) {
+  const abs = path8.join(root2, ...rel.split("/"));
+  let stat;
+  try {
+    stat = await fs11.lstat(abs);
+  } catch {
+    return;
+  }
+  if (!stat.isFile() || stat.size > MAX_FILE_BYTES || stat.size === 0) return;
+  let buf;
+  try {
+    buf = await fs11.readFile(abs);
+  } catch {
+    return;
+  }
+  if (buf.subarray(0, 8e3).includes(0)) return;
+  const text = buf.toString("utf8");
+  if (!new RegExp(test.source, `${test.flags}m`).test(text)) return;
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length && !results.done; i++) {
+    const line = lines[i].endsWith("\r") ? lines[i].slice(0, -1) : lines[i];
+    if (test.test(line)) results.add(rel, i + 1, preview(line, re));
+  }
+}
+async function searchHere(root2, files, test, re, results, signal) {
+  let next = 0;
+  const worker = async () => {
+    while (next < files.length && !results.done && !signal?.aborted) {
+      await searchFile(root2, files[next++], test, re, results);
+    }
+  };
+  await Promise.all(Array.from({ length: 16 }, worker));
+}
+function runRipgrep(rg, root2, args, onLine, signal) {
+  return new Promise((resolve, reject) => {
+    const child = spawn3(rg, ["--no-config", "--no-messages", "--hidden", "--glob", "!.git", "--glob", "!node_modules", ...args], {
+      cwd: root2,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stderr = "";
+    let stopped = false;
+    const stop = () => {
+      stopped = true;
+      child.kill();
+    };
+    signal?.addEventListener("abort", stop, { once: true });
+    child.stderr.on("data", (d) => stderr += d);
+    const lines = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+    lines.on("line", (line) => {
+      if (!stopped && onLine(line) === false) stop();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      signal?.removeEventListener("abort", stop);
+      if (code === 2 && /regex/i.test(stderr)) return reject(new HttpError(400, stderr.trim().split("\n").pop()));
+      resolve();
+    });
+  });
+}
+var relOf = (p) => p.replace(/\\/g, "/").replace(/^\.\//, "");
+async function search({
+  root: root2,
+  query = "",
+  caseSensitive = false,
+  wholeWord = false,
+  regex = false,
+  include = "",
+  exclude = "",
+  limit = DEFAULT_LIMIT,
+  engine = "auto",
+  signal
+}) {
+  if (query.length > MAX_QUERY) throw new HttpError(400, "query is too long");
+  if (!query && !include.trim()) throw new HttpError(400, "missing query");
+  limit = Math.min(Math.max(1, Math.floor(limit) || DEFAULT_LIMIT), MAX_LIMIT);
+  const options = { caseSensitive, wholeWord, regex };
+  const re = query ? queryRegex(query, options, true) : null;
+  const test = query ? queryRegex(query, options) : null;
+  const keep = pathFilter(include, exclude);
+  const rg = engine === "node" ? null : ripgrep();
+  if (engine === "rg" && !rg) throw new HttpError(500, "ripgrep is not installed");
+  const timeout = new AbortController();
+  const timer = setTimeout(() => timeout.abort(), TIMEOUT_MS);
+  const stop = signal ? AbortSignal.any([signal, timeout.signal]) : timeout.signal;
+  const results = new Results(limit);
+  const names = [];
+  let namesTruncated = false;
+  const nameLimit = query ? NAME_LIMIT : limit;
+  const addName = (rel) => {
+    if (!keep(rel)) return true;
+    const base2 = rel.slice(rel.lastIndexOf("/") + 1);
+    if (test && !test.test(base2)) return true;
+    if (names.length >= nameLimit) {
+      namesTruncated = true;
+      return false;
+    }
+    names.push(rel);
+    return true;
+  };
+  try {
+    if (rg) {
+      const listing = runRipgrep(rg, root2, ["--files", "./"], (line) => addName(relOf(line)), stop);
+      const flags = [
+        "--json",
+        "--max-filesize",
+        String(MAX_FILE_BYTES),
+        "--max-count",
+        String(PER_FILE),
+        ...regex ? [] : ["--fixed-strings"],
+        ...caseSensitive ? ["--case-sensitive"] : ["--ignore-case"],
+        ...wholeWord ? ["--word-regexp"] : []
+      ];
+      const content = query ? runRipgrep(
+        rg,
+        root2,
+        [...flags, "--regexp", query, "--", "./"],
+        (line) => {
+          let msg;
+          try {
+            msg = JSON.parse(line);
+          } catch {
+            return true;
+          }
+          if (msg.type !== "match" || msg.data.path.text === void 0 || msg.data.lines.text === void 0) return true;
+          const rel = relOf(msg.data.path.text);
+          if (!keep(rel)) return true;
+          const text = msg.data.lines.text.replace(/\r?\n$/, "");
+          results.add(rel, msg.data.line_number, preview(text, re));
+          return !results.done;
+        },
+        stop
+      ) : null;
+      await Promise.all([listing, content]);
+      if (stop.aborted && !signal?.aborted) results.truncated = true;
+    } else {
+      const files = (await listFiles(root2, stop)).filter(keep);
+      for (const rel of files) if (!addName(rel)) break;
+      if (query) await searchHere(root2, files, test, re, results, stop);
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+  if (timeout.signal.aborted) results.truncated = true;
+  const byPath = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+  return {
+    names: names.sort(byPath).map((p) => ({ path: p })),
+    files: [...results.byFile.entries()].sort(([a], [b]) => byPath(a, b)).map(([p, matches]) => ({ path: p, matches })),
+    truncated: results.truncated || namesTruncated
+  };
+}
+
 // ../../packages/agent-core/src/sessions.js
-import { execFile as execFile5 } from "node:child_process";
-import { randomUUID as randomUUID2 } from "node:crypto";
-import os3 from "node:os";
+import { execFile as execFile7 } from "node:child_process";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import os4 from "node:os";
 import pty from "node-pty";
 var SCROLLBACK_LIMIT = 256 * 1024;
 function guardConpty(term) {
@@ -1706,7 +3009,7 @@ var TerminalSession = class {
    * terminalCommand says; the session ends when it exits.
    */
   constructor({ cols, rows, cwd, env = {}, command = null }) {
-    this.id = randomUUID2();
+    this.id = randomUUID3();
     this.createdAt = Date.now();
     this.chunks = [];
     this.bufferedBytes = 0;
@@ -1719,7 +3022,7 @@ var TerminalSession = class {
       name: "xterm-256color",
       cols,
       rows,
-      cwd: cwd || os3.homedir(),
+      cwd: cwd || os4.homedir(),
       // CODEREMOTE_TERM_ID lets `coderemote hook` tell which terminal a coding agent runs in.
       env: { ...process.env, ...env, CODEREMOTE_TERM_ID: this.id, TERM: "xterm-256color", COLORTERM: "truecolor" }
     });
@@ -1772,7 +3075,7 @@ var TerminalSession = class {
   /** Ends the session; on Windows, which has no signals, always forcibly (see releaseConpty). */
   kill(signal) {
     if (!isWindows) this.pty.kill(signal);
-    else if (this.exitCode === null) execFile5("taskkill", ["/T", "/F", "/PID", String(this.pty.pid)], () => {
+    else if (this.exitCode === null) execFile7("taskkill", ["/T", "/F", "/PID", String(this.pty.pid)], () => {
     });
   }
   /** Types into the session, as a client's keyboard would; nothing once it has exited. */
@@ -1831,21 +3134,21 @@ var SessionManager = class {
 };
 
 // ../../packages/agent-core/src/uploads.js
-import { execFile as execFile6 } from "node:child_process";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { execFile as execFile8 } from "node:child_process";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { createWriteStream } from "node:fs";
-import fs7 from "node:fs/promises";
-import os4 from "node:os";
-import path5 from "node:path";
+import fs12 from "node:fs/promises";
+import os5 from "node:os";
+import path9 from "node:path";
 import { Transform } from "node:stream";
-import { pipeline } from "node:stream/promises";
+import { pipeline as pipeline2 } from "node:stream/promises";
 import { promisify as promisify2 } from "node:util";
-var run3 = promisify2(execFile6);
+var run4 = promisify2(execFile8);
 var UPLOAD_LIMIT = 100 * 1024 * 1024;
 var KEEP = 7 * 24 * 60 * 60 * 1e3;
 var ID = /^[0-9a-f-]{36}$/;
 function safeName(name) {
-  const base2 = path5.basename(String(name ?? "").replace(/\\/g, "/"));
+  const base2 = path9.basename(String(name ?? "").replace(/\\/g, "/"));
   const clean = base2.replace(/[^\p{L}\p{N}._ -]/gu, "_").replace(/^[.\s]+/, "").slice(-80).trim();
   return clean || "file";
 }
@@ -1857,10 +3160,10 @@ var UploadStore = class {
   /** Streams `body` to disk. 413 past `limit`; HEIC photos become JPEG on macOS. */
   async save(body, { name, type, length, limit = UPLOAD_LIMIT }) {
     if (Number(length) > limit) throw new HttpError(413, `files are limited to ${limit / 1024 / 1024} MB`);
-    const id = randomUUID3();
+    const id = randomUUID4();
     const day = new Date(this.now()).toISOString().slice(0, 10);
-    await fs7.mkdir(path5.join(this.dir, day), { recursive: true, mode: 448 });
-    let file = path5.join(this.dir, day, `${id}-${safeName(name)}`);
+    await fs12.mkdir(path9.join(this.dir, day), { recursive: true, mode: 448 });
+    let file = path9.join(this.dir, day, `${id}-${safeName(name)}`);
     let size = 0;
     const counter = new Transform({
       transform(chunk, _enc, done) {
@@ -1869,41 +3172,41 @@ var UploadStore = class {
       }
     });
     try {
-      await pipeline(body, counter, createWriteStream(file, { mode: 384 }));
+      await pipeline2(body, counter, createWriteStream(file, { mode: 384 }));
     } catch (e) {
-      await fs7.rm(file, { force: true });
+      await fs12.rm(file, { force: true });
       throw e;
     }
     let kind = type || "application/octet-stream";
-    if ((kind === "image/heic" || /\.heic$/i.test(file)) && os4.platform() === "darwin") {
+    if ((kind === "image/heic" || /\.heic$/i.test(file)) && os5.platform() === "darwin") {
       const jpeg = file.replace(/(\.heic)?$/i, ".jpg");
       try {
-        await run3("sips", ["-s", "format", "jpeg", file, "--out", jpeg], { timeout: 3e4 });
-        await fs7.rm(file);
+        await run4("sips", ["-s", "format", "jpeg", file, "--out", jpeg], { timeout: 3e4 });
+        await fs12.rm(file);
         file = jpeg;
         kind = "image/jpeg";
-        size = (await fs7.stat(file)).size;
+        size = (await fs12.stat(file)).size;
       } catch {
       }
     }
-    return { id, name: path5.basename(file).slice(id.length + 1), type: kind, size, path: file };
+    return { id, name: path9.basename(file).slice(id.length + 1), type: kind, size, path: file };
   }
   /** The file of an upload; 404 once it's gone (swept, or never existed). */
   async path(id) {
     if (typeof id !== "string" || !ID.test(id)) throw new HttpError(400, "invalid upload id");
     let days = [];
     try {
-      days = (await fs7.readdir(this.dir)).sort().reverse();
+      days = (await fs12.readdir(this.dir)).sort().reverse();
     } catch {
     }
     for (const day of days) {
       let names = [];
       try {
-        names = await fs7.readdir(path5.join(this.dir, day));
+        names = await fs12.readdir(path9.join(this.dir, day));
       } catch {
       }
       const hit = names.find((n) => n.startsWith(`${id}-`));
-      if (hit) return path5.join(this.dir, day, hit);
+      if (hit) return path9.join(this.dir, day, hit);
     }
     throw new HttpError(404, "no such upload (they are kept for 7 days)");
   }
@@ -1911,25 +3214,25 @@ var UploadStore = class {
   async sweep() {
     let days = [];
     try {
-      days = await fs7.readdir(this.dir);
+      days = await fs12.readdir(this.dir);
     } catch {
       return;
     }
     const cutoff = this.now() - KEEP;
     for (const day of days) {
-      const dir = path5.join(this.dir, day);
+      const dir = path9.join(this.dir, day);
       let names = [];
       try {
-        names = await fs7.readdir(dir);
+        names = await fs12.readdir(dir);
       } catch {
         continue;
       }
       for (const n of names) {
-        const file = path5.join(dir, n);
-        const stat = await fs7.stat(file).catch(() => null);
-        if (stat && stat.mtimeMs < cutoff) await fs7.rm(file, { force: true });
+        const file = path9.join(dir, n);
+        const stat = await fs12.stat(file).catch(() => null);
+        if (stat && stat.mtimeMs < cutoff) await fs12.rm(file, { force: true });
       }
-      if (!(await fs7.readdir(dir).catch(() => [])).length) await fs7.rm(dir, { recursive: true, force: true });
+      if (!(await fs12.readdir(dir).catch(() => [])).length) await fs12.rm(dir, { recursive: true, force: true });
     }
   }
 };
@@ -1942,21 +3245,48 @@ function kindOf(stat) {
   return "other";
 }
 async function describe(fullPath, name) {
-  const lst = await fs8.lstat(fullPath);
-  const entry2 = { name, type: kindOf(lst), size: lst.size, mtime: lst.mtimeMs };
+  const lst = await fs13.lstat(fullPath);
+  const entry3 = { name, type: kindOf(lst), size: lst.size, mtime: lst.mtimeMs };
   if (lst.isSymbolicLink()) {
     try {
-      entry2.target = kindOf(await fs8.stat(fullPath));
+      entry3.target = kindOf(await fs13.stat(fullPath));
     } catch {
-      entry2.target = "broken";
+      entry3.target = "broken";
     }
   }
-  return entry2;
+  return entry3;
 }
 var PASTE_START = "\x1B[200~";
 var PASTE_END = "\x1B[201~";
 var KEYS = { interrupt: "\x1B", cycle_mode: "\x1B[Z" };
-var COMMANDS = ["/compact", "/clear", "/model"];
+var MEDIA_TYPES = {
+  ".mp4": "video/mp4",
+  ".m4v": "video/x-m4v",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm",
+  ".mp3": "audio/mpeg",
+  ".m4a": "audio/mp4",
+  ".aac": "audio/aac",
+  ".wav": "audio/wav",
+  ".caf": "audio/x-caf"
+};
+function byteRange(header, size) {
+  const m = /^bytes=(\d*)-(\d*)$/.exec(String(header ?? "").trim());
+  if (!m || m[1] === "" && m[2] === "") return null;
+  let start2;
+  let end;
+  if (m[1] === "") {
+    const n = Number(m[2]);
+    if (n === 0) return "unsatisfiable";
+    start2 = Math.max(0, size - n);
+    end = size - 1;
+  } else {
+    start2 = Number(m[1]);
+    end = m[2] === "" ? size - 1 : Math.min(Number(m[2]), size - 1);
+  }
+  if (start2 >= size || start2 > end) return "unsatisfiable";
+  return { start: start2, end };
+}
 function typeable(text) {
   return text.replace(/\r\n?/g, "\n").replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
 }
@@ -1966,7 +3296,7 @@ function sendJson(res, status2, body) {
   res.writeHead(status2, { "content-type": "application/json", "content-length": Buffer.byteLength(json) });
   res.end(json);
 }
-async function readJson(req) {
+async function readJson2(req) {
   const chunks = [];
   for await (const c of req) chunks.push(c);
   try {
@@ -1979,18 +3309,24 @@ function createAgentServer({
   token,
   root: root2,
   tunnelToken = async () => null,
-  preview = null,
+  preview: preview2 = null,
   tunnelStatus: tunnelStatus2 = null,
+  tunnelDelete: tunnelDelete2 = null,
   hookSecret = null,
   hookBin = null,
   uploadsDir = null,
   claudeCommand = "claude",
   codexCommand = "codex",
-  codexHome = process.env.CODEX_HOME || path6.join(os5.homedir(), ".codex"),
+  codexHome = process.env.CODEX_HOME || path10.join(os6.homedir(), ".codex"),
+  home = os6.homedir(),
+  xcodebuild = "xcodebuild",
+  builds = new BuildRunner({ xcodebuild }),
   pluginInstalled = null,
   agents = new AgentHub(),
   pushStore: pushStore2 = null,
-  pushOptions = {}
+  pushOptions = {},
+  previewSweep = {},
+  version = null
 }) {
   const handoff = new TunnelHandoff({ token, mint: tunnelToken });
   const sandbox = new Sandbox(root2);
@@ -2003,9 +3339,13 @@ function createAgentServer({
     });
   }, 10 * 60 * 1e3);
   sweep.unref();
-  let foregroundAt = 0;
-  const clientInForeground = () => Date.now() - foregroundAt < 3e4;
-  const push2 = new PushSender({ hub: agents, store: pushStore2, foreground: clientInForeground, ...pushOptions });
+  const presences = /* @__PURE__ */ new Map();
+  const freshPresences = () => [...presences.values()].filter((p) => Date.now() - p.at < 3e4);
+  const clientInForeground = () => freshPresences().length > 0;
+  const clientShows = ({ session = null, builds: builds2 = false }) => freshPresences().some((p) => p.all || (session ? p.session === session : builds2 && p.builds));
+  const push2 = new PushSender({ hub: agents, store: pushStore2, shows: clientShows, ...pushOptions });
+  builds.on("ended", (build) => push2.buildEnded(build).catch(() => {
+  }));
   if (!agents.presenceSet) {
     agents.present = async () => !clientInForeground() && await (pushOptions.userActive ?? userActiveHere)();
   }
@@ -2096,12 +3436,16 @@ function createAgentServer({
   }
   async function codexModels() {
     try {
-      const { models } = JSON.parse(await fs8.readFile(path6.join(codexHome, "models_cache.json"), "utf8"));
+      const { models } = JSON.parse(await fs13.readFile(path10.join(codexHome, "models_cache.json"), "utf8"));
       return models.filter((m) => m.visibility === "list" && typeof m.slug === "string").sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0)).map((m) => ({ id: m.slug, name: m.display_name || m.slug, description: m.description ?? "" }));
     } catch {
       return [];
     }
   }
+  const installs = preview2 ? new InstallLinks({ preview: preview2 }) : null;
+  function sessionCommands(session) {
+    return listCommands({ agent: session.agent, cwd: session.cwd || sandbox.root, home, codexHome });
+  }
   function hookAuthorized(req) {
     if (!hookSecret) return false;
     const got = Buffer.from(String(req.headers[HOOK_SECRET_HEADER] || ""));
@@ -2109,7 +3453,7 @@ function createAgentServer({
     return got.length === want.length && timingSafeEqual2(got, want);
   }
   function previewPort(value, ownPort) {
-    if (!preview) throw new HttpError(404, "previews need a tunnel");
+    if (!preview2) throw new HttpError(404, "previews need a tunnel");
     const port2 = Number(value);
     if (!Number.isInteger(port2) || port2 < 1 || port2 > 65535) throw new HttpError(400, "port must be 1-65535");
     if (port2 === ownPort) throw new HttpError(400, "the agent's own port is already on its tunnel");
@@ -2119,7 +3463,7 @@ function createAgentServer({
   const proxies = /* @__PURE__ */ new Map();
   function previewed(port2) {
     const proxy = proxies.get(port2);
-    if (!proxy || !preview.list().some((p) => p.port === proxy.port)) {
+    if (!proxy || !preview2.list().some((p) => p.port === proxy.port)) {
       throw new HttpError(404, "that port is not being previewed");
     }
     return proxy;
@@ -2130,36 +3474,68 @@ function createAgentServer({
     return proxy;
   }
   async function previews() {
-    const issued = await preview.token();
-    const forwarded = new Map(preview.list().map((p) => [p.port, p]));
+    const issued = await preview2.token();
+    const forwarded = new Map(preview2.list().map((p) => [p.port, p]));
     const ports = [];
     for (const [port2, proxy] of proxies) {
       const p = forwarded.get(proxy.port);
       if (p) ports.push({ ...p, port: port2 });
     }
     ports.sort((a, b) => a.port - b.port);
+    const install = installs?.sharing ? forwarded.get(installs.port) : null;
+    if (install) ports.push({ ...install, install: true });
     return { ports, token: issued?.token ?? null, expiresAt: issued?.expiresAt ?? null };
   }
+  const { checkMs = 5e3, graceMs = 3e4, killedMs = 1500 } = previewSweep;
+  const silentSince = /* @__PURE__ */ new Map();
+  let sweeping = false;
+  async function sweepPreviews(ports = [...proxies.keys()], now = false) {
+    const forwarded = new Set(preview2.list().map((p) => p.port));
+    for (const port2 of ports) {
+      const proxy = proxies.get(port2);
+      if (!proxy || !forwarded.has(proxy.port) || await isListening(port2)) {
+        silentSince.delete(port2);
+        continue;
+      }
+      if (!silentSince.has(port2)) silentSince.set(port2, Date.now());
+      if (!now && Date.now() - silentSince.get(port2) < graceMs) continue;
+      silentSince.delete(port2);
+      try {
+        await preview2.unforward(proxy.port);
+      } catch {
+      }
+    }
+  }
+  const previewTimer = preview2 && setInterval(async () => {
+    if (sweeping || !proxies.size) return;
+    sweeping = true;
+    try {
+      await sweepPreviews();
+    } finally {
+      sweeping = false;
+    }
+  }, checkMs);
+  previewTimer?.unref();
   function shellPids() {
     return new Map(sessions.list().map((s) => [s.pid, s.id]));
   }
   async function repoOf(p) {
     const repo = await sandbox.resolve(p);
     try {
-      await fs8.access(path6.join(repo, ".git"));
+      await fs13.access(path10.join(repo, ".git"));
     } catch {
       throw new HttpError(400, "not a git repository");
     }
     return repo;
   }
   async function filesIn(repo, files) {
-    if (!Array.isArray(files) || !files.length || files.some((f) => typeof f !== "string" || !f || path6.isAbsolute(f))) {
+    if (!Array.isArray(files) || !files.length || files.some((f) => typeof f !== "string" || !f || path10.isAbsolute(f))) {
       throw new HttpError(400, "files must be a non-empty list of paths relative to the repository");
     }
     return Promise.all(
       files.map(async (f) => {
-        const abs = await sandbox.resolve(path6.join(repo, f), { allowMissing: true });
-        const rel = path6.relative(repo, abs);
+        const abs = await sandbox.resolve(path10.join(repo, f), { allowMissing: true });
+        const rel = path10.relative(repo, abs);
         if (!rel || rel.startsWith("..")) throw new HttpError(403, "path is outside the repository");
         return rel;
       })
@@ -2168,55 +3544,95 @@ function createAgentServer({
   const routes = {
     [Routes.info]: async () => ({
       protocol: PROTOCOL_VERSION,
-      hostname: os5.hostname(),
-      platform: os5.platform(),
+      minClientProtocol: MIN_CLIENT_PROTOCOL,
+      version,
+      hostname: os6.hostname(),
+      platform: os6.platform(),
       root: sandbox.root,
-      user: os5.userInfo().username,
+      user: os6.userInfo().username,
       // On Windows, terminals run PowerShell whatever $SHELL (Git Bash sets one) says.
       shell: isWindows ? interactiveShell().file : process.env.SHELL || null
     }),
     [Routes.fsList]: async (url) => {
       const dir = await sandbox.resolve(url.searchParams.get("path"));
-      const names = await fs8.readdir(dir);
-      const entries = (await Promise.all(names.map((n) => describe(path6.join(dir, n), n).catch(() => null)))).filter(Boolean);
-      return { path: dir, entries };
+      const names = await fs13.readdir(dir);
+      const entries2 = (await Promise.all(names.map((n) => describe(path10.join(dir, n), n).catch(() => null)))).filter(Boolean);
+      return { path: dir, entries: entries2 };
     },
     [Routes.fsStat]: async (url) => {
       const p = await sandbox.resolve(url.searchParams.get("path"));
-      return { path: p, ...await describe(p, path6.basename(p)) };
+      return { path: p, ...await describe(p, path10.basename(p)) };
     },
     [Routes.fsRead]: async (url, req, res) => {
       const p = await sandbox.resolve(url.searchParams.get("path"));
-      const stat = await fs8.stat(p);
+      const stat = await fs13.stat(p);
       if (!stat.isFile()) throw new HttpError(400, "not a file");
-      res.writeHead(200, { "content-type": "application/octet-stream", "content-length": stat.size });
-      await pipeline2(createReadStream(p), res);
+      const type = MEDIA_TYPES[path10.extname(p).toLowerCase()] ?? "application/octet-stream";
+      const range = byteRange(req.headers.range, stat.size);
+      if (range === "unsatisfiable") {
+        res.writeHead(416, { "content-range": `bytes */${stat.size}`, "accept-ranges": "bytes" });
+        res.end();
+        return;
+      }
+      if (range) {
+        res.writeHead(206, {
+          "content-type": type,
+          "content-length": range.end - range.start + 1,
+          "content-range": `bytes ${range.start}-${range.end}/${stat.size}`,
+          "accept-ranges": "bytes"
+        });
+        await pipeline3(createReadStream2(p, range), res);
+        return;
+      }
+      res.writeHead(200, { "content-type": type, "content-length": stat.size, "accept-ranges": "bytes" });
+      await pipeline3(createReadStream2(p), res);
     },
     [Routes.fsWrite]: async (url, req) => {
       const p = await sandbox.resolveChild(url.searchParams.get("path"), { allowMissing: true });
       const tmp = `${p}.vsremote-${process.pid}-${Date.now()}.tmp`;
       try {
-        await pipeline2(req, createWriteStream2(tmp));
-        await fs8.rename(tmp, p);
+        await pipeline3(req, createWriteStream2(tmp));
+        await fs13.rename(tmp, p);
       } catch (e) {
-        await fs8.rm(tmp, { force: true });
+        await fs13.rm(tmp, { force: true });
         throw e;
       }
-      return describe(p, path6.basename(p));
+      return describe(p, path10.basename(p));
     },
     [Routes.fsMkdir]: async (url) => {
-      await fs8.mkdir(await sandbox.resolve(url.searchParams.get("path"), { allowMissing: true }), { recursive: true });
+      await fs13.mkdir(await sandbox.resolve(url.searchParams.get("path"), { allowMissing: true }), { recursive: true });
       return {};
     },
     [Routes.fsRename]: async (url, req) => {
-      const { from, to } = await readJson(req);
-      await fs8.rename(await sandbox.resolveChild(from), await sandbox.resolveChild(to, { allowMissing: true }));
+      const { from, to } = await readJson2(req);
+      await fs13.rename(await sandbox.resolveChild(from), await sandbox.resolveChild(to, { allowMissing: true }));
       return {};
     },
     [Routes.fsDelete]: async (url) => {
-      await fs8.rm(await sandbox.resolveChild(url.searchParams.get("path")), { recursive: true });
+      await fs13.rm(await sandbox.resolveChild(url.searchParams.get("path")), { recursive: true });
       return {};
     },
+    [Routes.fsSearch]: async (url, req, res) => {
+      const q = url.searchParams;
+      const flag2 = (name) => q.get(name) === "1";
+      const gone = new AbortController();
+      res.on("close", () => {
+        if (!res.writableFinished) gone.abort();
+      });
+      const found = await search({
+        root: sandbox.root,
+        query: q.get("q") ?? "",
+        caseSensitive: flag2("case"),
+        wholeWord: flag2("word"),
+        regex: flag2("regex"),
+        include: q.get("include") ?? "",
+        exclude: q.get("exclude") ?? "",
+        limit: Number(q.get("limit")) || void 0,
+        signal: gone.signal
+      });
+      if (gone.signal.aborted) return void 0;
+      return { root: sandbox.root, ...found };
+    },
     [Routes.gitRepos]: async () => ({ repos: await findRepos(sandbox.root) }),
     [Routes.gitStatus]: async (url) => status(await repoOf(url.searchParams.get("repo"))),
     [Routes.gitDiff]: async (url) => {
@@ -2228,46 +3644,48 @@ function createAgentServer({
       });
     },
     [Routes.gitStage]: async (url, req) => {
-      const { repo: r, files } = await readJson(req);
+      const { repo: r, files } = await readJson2(req);
       const repo = await repoOf(r);
       await stage(repo, await filesIn(repo, files));
       return status(repo);
     },
     [Routes.gitUnstage]: async (url, req) => {
-      const { repo: r, files } = await readJson(req);
+      const { repo: r, files } = await readJson2(req);
       const repo = await repoOf(r);
       await unstage(repo, await filesIn(repo, files));
       return status(repo);
     },
     [Routes.gitDiscard]: async (url, req) => {
-      const { repo: r, files } = await readJson(req);
+      const { repo: r, files } = await readJson2(req);
       const repo = await repoOf(r);
       await discard(repo, await filesIn(repo, files));
       return status(repo);
     },
     [Routes.gitCommit]: async (url, req) => {
-      const { repo: r, message } = await readJson(req);
+      const { repo: r, message } = await readJson2(req);
       return commit(await repoOf(r), message);
     },
     [Routes.gitLog]: async (url) => ({
       commits: await log(await repoOf(url.searchParams.get("repo")), parseInt(url.searchParams.get("limit"), 10) || 50)
     }),
     [Routes.gitShow]: async (url) => show(await repoOf(url.searchParams.get("repo")), url.searchParams.get("commit")),
-    [Routes.gitPull]: async (url, req) => ({ output: await pull(await repoOf((await readJson(req)).repo)) }),
-    [Routes.gitPush]: async (url, req) => ({ output: await push(await repoOf((await readJson(req)).repo)) }),
+    [Routes.gitPull]: async (url, req) => ({ output: await pull(await repoOf((await readJson2(req)).repo)) }),
+    [Routes.gitPush]: async (url, req) => ({ output: await push(await repoOf((await readJson2(req)).repo)) }),
     [Routes.termList]: async () => ({ sessions: sessions.list() }),
     [Routes.portsList]: async () => ({ ports: await listPorts(shellPids()) }),
     [Routes.portsKill]: async (url, req) => {
-      const { pid, force } = await readJson(req);
-      await killListener(pid, { force: force === true, shells: shellPids() });
+      const { pid, force } = await readJson2(req);
+      const ports = await killListener(pid, { force: force === true, shells: shellPids() });
+      if (preview2) setTimeout(() => sweepPreviews(ports, true).catch(() => {
+      }), killedMs).unref();
       return {};
     },
     [Routes.previewList]: async () => {
-      if (!preview) throw new HttpError(404, "previews need a tunnel");
+      if (!preview2) throw new HttpError(404, "previews need a tunnel");
       return previews();
     },
     [Routes.previewOpen]: async (url, req) => {
-      const port2 = previewPort((await readJson(req)).port, server.address()?.port);
+      const port2 = previewPort((await readJson2(req)).port, server.address()?.port);
       let proxy = proxies.get(port2);
       if (!proxy) {
         proxy = new InspectingProxy(port2);
@@ -2275,7 +3693,7 @@ function createAgentServer({
         proxies.set(port2, proxy);
       }
       try {
-        await preview.forward(proxy.port);
+        await preview2.forward(proxy.port);
       } catch (e) {
         throw new HttpError(502, e.message);
       }
@@ -2283,25 +3701,34 @@ function createAgentServer({
     },
     [Routes.previewClose]: async (url) => {
       const port2 = previewPort(url.searchParams.get("port"), server.address()?.port);
+      if (installs && port2 === installs.port) {
+        await installs.stop();
+        return previews();
+      }
       const proxy = proxies.get(port2);
-      if (proxy) await preview.unforward(proxy.port);
+      if (proxy) await preview2.unforward(proxy.port);
       return previews();
     },
     [Routes.previewShare]: async (url, req) => {
-      const { port: value, hours } = await readJson(req);
+      const { port: value, hours } = await readJson2(req);
       const proxy = previewed(previewPort(value, server.address()?.port));
       if (!Number.isInteger(hours) || hours < 1 || hours > 720) throw new HttpError(400, "hours must be 1-720");
       try {
-        await preview.share(proxy.port, hours);
+        await preview2.share(proxy.port, hours);
       } catch (e) {
         throw new HttpError(502, e.message);
       }
       return previews();
     },
     [Routes.previewUnshare]: async (url) => {
+      const asked = previewPort(url.searchParams.get("port"), server.address()?.port);
+      if (installs && asked === installs.port) {
+        await installs.stop();
+        return previews();
+      }
       const proxy = proxies.get(previewPort(url.searchParams.get("port"), server.address()?.port));
       try {
-        if (proxy) await preview.unshare(proxy.port);
+        if (proxy) await preview2.unshare(proxy.port);
       } catch (e) {
         throw new HttpError(502, e.message);
       }
@@ -2311,9 +3738,9 @@ function createAgentServer({
       requests: inspected(url.searchParams.get("port")).list(parseInt(url.searchParams.get("after"), 10) || 0)
     }),
     [Routes.previewRequest]: async (url) => {
-      const entry2 = inspected(url.searchParams.get("port")).get(parseInt(url.searchParams.get("id"), 10));
-      if (!entry2) throw new HttpError(404, "no such request (only the latest 200 are kept)");
-      return detail(entry2);
+      const entry3 = inspected(url.searchParams.get("port")).get(parseInt(url.searchParams.get("id"), 10));
+      if (!entry3) throw new HttpError(404, "no such request (only the latest 200 are kept)");
+      return detail(entry3);
     },
     [Routes.previewRequestsClear]: async (url) => {
       inspected(url.searchParams.get("port")).clear();
@@ -2324,6 +3751,11 @@ function createAgentServer({
       if (!status2) throw new HttpError(404, "this agent runs without a tunnel");
       return status2;
     },
+    [Routes.tunnelDelete]: async (url, req) => {
+      if (!tunnelDelete2) throw new HttpError(404, "this agent runs without a tunnel");
+      const { id, account, force } = await readJson2(req);
+      return tunnelDelete2({ id, account, force: force === true });
+    },
     [Routes.tunnelToken]: async () => {
       const issued = await handoff.issue();
       if (!issued) throw new HttpError(404, "this tunnel is anonymous");
@@ -2336,8 +3768,43 @@ function createAgentServer({
       const [plugin, codexPlugin] = await Promise.all([claude && hasPlugin("claude"), codex && hasPlugin("codex")]);
       return { claude, plugin: Boolean(plugin), codex, codexPlugin: Boolean(codexPlugin), codexModels: codex ? await codexModels() : [] };
     },
+    [Routes.agentsCommands]: async (url) => {
+      const session = agents.session(url.searchParams.get("session") ?? "");
+      if (!session) throw new HttpError(404, "no such session");
+      return { commands: await sessionCommands(session) };
+    },
+    [Routes.agentsHistory]: async (url) => {
+      const session = agents.session(url.searchParams.get("session") ?? "");
+      if (!session) throw new HttpError(404, "no such session");
+      const found = await listHistory({ agent: session.agent, cwd: session.cwd || sandbox.root, home, codexHome });
+      return { sessions: found.filter((h) => h.id !== session.id) };
+    },
+    [Routes.buildsSchemes]: async (url) => listSchemes(await sandbox.resolve(url.searchParams.get("path")), { xcodebuild }),
+    [Routes.buildsStart]: async (url, req) => {
+      const { path: folder, scheme, configuration } = await readJson2(req);
+      return builds.start({ folder: await sandbox.resolve(folder), scheme, configuration });
+    },
+    [Routes.buildsCurrent]: async (url) => {
+      const build = builds.current(parseInt(url.searchParams.get("after"), 10) || 0);
+      if (!build) throw new HttpError(404, "no build yet");
+      return build;
+    },
+    [Routes.buildsCancel]: async () => {
+      builds.cancel();
+      return {};
+    },
+    [Routes.buildsInstall]: async () => {
+      if (!installs) throw new HttpError(409, "installing needs the tunnel: start the agent with `coderemote up`");
+      const artifact = builds.artifact();
+      if (!artifact) throw new HttpError(409, "there is no successful build to install");
+      try {
+        return await installs.create(artifact);
+      } catch (e) {
+        throw e instanceof HttpError ? e : new HttpError(502, e.message);
+      }
+    },
     [Routes.agentsLaunch]: async (url, req) => {
-      const { agent = "claude", cwd, model, permissionMode, approvalPolicy, resume, cols, rows } = await readJson(req);
+      const { agent = "claude", cwd, model, permissionMode, approvalPolicy, resume, cols, rows } = await readJson2(req);
       if (approvalPolicy !== void 0 && !["on-request", "never"].includes(approvalPolicy)) {
         throw new HttpError(400, "approvalPolicy must be on-request or never");
       }
@@ -2349,7 +3816,7 @@ function createAgentServer({
       } catch (e) {
         throw new HttpError(400, e.message);
       }
-      if (!(await fs8.stat(dir)).isDirectory()) throw new HttpError(400, "cwd must be a folder");
+      if (!(await fs13.stat(dir)).isDirectory()) throw new HttpError(400, "cwd must be a folder");
       if (model !== void 0 && (typeof model !== "string" || !/^[A-Za-z0-9._[\]-]{1,80}$/.test(model))) {
         throw new HttpError(400, "invalid model");
       }
@@ -2370,8 +3837,8 @@ function createAgentServer({
       if (!await hasPlugin(agent)) {
         throw Object.assign(new HttpError(400, launcher.missingPlugin), { code: "ENOPLUGIN" });
       }
-      const id = resume ?? randomUUID4();
-      if (uploadsDir) await fs8.mkdir(uploadsDir, { recursive: true, mode: 448 });
+      const id = resume ?? randomUUID5();
+      if (uploadsDir) await fs13.mkdir(uploadsDir, { recursive: true, mode: 448 });
       const argv2 = [
         launcher.command,
         ...launcher.args({
@@ -2392,14 +3859,14 @@ function createAgentServer({
       return { terminal: term.id, session: agents.launched({ id, terminal: term.id, cwd: dir, agent }) };
     },
     [Routes.agentsPrompt]: async (url, req) => {
-      const { session: id, text, attachments } = await readJson(req);
+      const { session: id, text, attachments } = await readJson2(req);
       if (typeof text !== "string" || !text.trim() || text.length > 1e5) {
         throw new HttpError(400, "text must be a non-empty string");
       }
       const { term } = typingTarget(id, { whileWaiting: false });
       const paths = await attachmentPaths(attachments);
       const typed = typeable([text.trim(), ...paths].join("\n"));
-      const prompt = randomUUID4();
+      const prompt = randomUUID5();
       agents.prompted(id, { id: prompt, text: typed, paths });
       await typeInto(term, typed);
       return { prompt };
@@ -2419,23 +3886,30 @@ function createAgentServer({
       return { id, name: saved, type, size };
     },
     [Routes.agentsKeys]: async (url, req) => {
-      const { session: id, action, command } = await readJson(req);
+      const { session: id, action, command, args } = await readJson2(req);
       const allowed = agents.session(typeof id === "string" ? id : "")?.capabilities?.keys;
-      if (allowed && !allowed.includes(action === "command" ? command : action)) {
+      if (action !== "command" && allowed && !allowed.includes(action)) {
         throw new HttpError(400, `this session takes ${allowed.join(", ")}`);
       }
       if (action === "command") {
-        if (!COMMANDS.includes(command)) throw new HttpError(400, `command must be one of ${COMMANDS.join(", ")}`);
-        await typeInto(typingTarget(id, { whileWaiting: false }).term, command);
+        if (typeof command !== "string") throw new HttpError(400, "command must be a string");
+        if (args !== void 0 && (typeof args !== "string" || args.length > 1e5)) throw new HttpError(400, "args must be a string");
+        const { session, term } = typingTarget(id, { whileWaiting: false });
+        const listed = (await sessionCommands(session)).some((c) => c.kind === "command" && c.name === command);
+        if (!listed && !session.capabilities?.keys?.includes(command)) {
+          throw new HttpError(400, `${command} is not a command this session takes`);
+        }
+        await typeInto(term, typeable(args?.trim() ? `${command} ${args.trim()}` : command));
       } else if (Object.hasOwn(KEYS, action)) {
         typingTarget(id, { whileWaiting: true }).term.write(KEYS[action]);
+        if (action === "interrupt") agents.interrupted(id);
       } else {
         throw new HttpError(400, `action must be one of ${[...Object.keys(KEYS), "command"].join(", ")}`);
       }
       return {};
     },
     [Routes.agentsStop]: async (url, req) => {
-      const { session: id } = await readJson(req);
+      const { session: id } = await readJson2(req);
       const { term } = typingTarget(id, { whileWaiting: true });
       term.kill();
       setTimeout(() => {
@@ -2444,7 +3918,7 @@ function createAgentServer({
       return {};
     },
     [Routes.agentsForget]: async (url, req) => {
-      const { session: id } = await readJson(req);
+      const { session: id } = await readJson2(req);
       const session = typeof id === "string" ? agents.session(id) : null;
       if (!session) throw new HttpError(404, "no such session");
       if (session.state !== "ended" && session.terminal && sessions.get(session.terminal)) {
@@ -2454,11 +3928,11 @@ function createAgentServer({
       return {};
     },
     [Routes.agentsAnswer]: async (url, req) => {
-      agents.answer(await readJson(req));
+      agents.answer(await readJson2(req));
       return {};
     },
     [Routes.pushDeviceSet]: async (url, req) => {
-      push2.register(await readJson(req));
+      push2.register(await readJson2(req));
       return {};
     },
     [Routes.pushDeviceDelete]: async (url) => {
@@ -2466,7 +3940,7 @@ function createAgentServer({
       return {};
     },
     [Routes.pushTest]: async (url, req) => {
-      await push2.test((await readJson(req)).token);
+      await push2.test((await readJson2(req)).token);
       return {};
     },
     [Routes.termKill]: async (url) => {
@@ -2476,7 +3950,7 @@ function createAgentServer({
       return {};
     }
   };
-  const server = http2.createServer(async (req, res) => {
+  const server = http3.createServer(async (req, res) => {
     const url = new URL(req.url, "http://localhost");
     if (req.method === "GET" && url.pathname === "/") {
       res.writeHead(200, {
@@ -2504,14 +3978,16 @@ function createAgentServer({
     if (!hookAuthorized(req)) return sendJson(res, 401, { error: "unauthorized" });
     plugins[url.searchParams.get("agent") || "claude"] = { installed: true, checkedAt: Date.now() };
     const terminal = url.searchParams.get("terminal");
+    const app = url.searchParams.get("app");
     const closed = new AbortController();
     res.on("close", () => {
       if (!res.writableFinished) closed.abort();
     });
     try {
-      const output = await agents.handle(await readJson(req), {
+      const output = await agents.handle(await readJson2(req), {
         agent: url.searchParams.get("agent") || "claude",
         terminal: terminal && sessions.get(terminal) ? terminal : null,
+        app: app && app.length <= 1024 && /\.app$/.test(app) ? app : null,
         signal: closed.signal
       });
       if (res.destroyed) return;
@@ -2590,30 +4066,43 @@ function createAgentServer({
       } catch {
         return;
       }
-      if (msg.type === AgentsClientMessage.presence) foregroundAt = msg.foreground === true ? Date.now() : 0;
+      if (msg.type !== AgentsClientMessage.presence) return;
+      if (msg.foreground !== true) return presences.delete(ws);
+      presences.set(ws, {
+        at: Date.now(),
+        all: msg.session === void 0 && msg.builds === void 0,
+        session: typeof msg.session === "string" ? msg.session : null,
+        builds: msg.builds === true
+      });
+    });
+    ws.on("close", () => {
+      agents.off("message", send);
+      presences.delete(ws);
     });
-    ws.on("close", () => agents.off("message", send));
   }
   server.on("close", () => {
+    installs?.close();
     clearInterval(sweep);
+    clearInterval(previewTimer);
     sessions.killAll();
     for (const proxy of proxies.values()) proxy.close();
   });
   server.killAllSessions = () => sessions.killAll();
   server.agents = agents;
   server.clientInForeground = clientInForeground;
+  server.clientShows = clientShows;
   server.push = push2;
   server.agentsUploadPath = (id) => uploadPath(id);
   return server;
 }
 
 // src/devtunnel.js
-import { execFile as execFile7 } from "node:child_process";
+import { execFile as execFile9 } from "node:child_process";
 import { createHash } from "node:crypto";
-import fs9 from "node:fs";
-import path7 from "node:path";
+import fs14 from "node:fs";
+import path11 from "node:path";
 import { promisify as promisify3 } from "node:util";
-var run4 = promisify3(execFile7);
+var run5 = promisify3(execFile9);
 var DOWNLOAD_BASE = "https://tunnelsassetsprod.blob.core.windows.net/cli";
 var BUILDS = {
   "darwin-arm64": "osx-arm64-devtunnel",
@@ -2642,11 +4131,11 @@ async function ensureDevtunnel({ dir, progress }) {
       `No devtunnel build for ${process.platform}-${process.arch}. Install it yourself: https://learn.microsoft.com/azure/developer/dev-tunnels/get-started`
     );
   }
-  const bin = path7.join(dir, isWindows ? "devtunnel.exe" : "devtunnel");
-  const metaFile = path7.join(dir, "devtunnel.json");
+  const bin = path11.join(dir, isWindows ? "devtunnel.exe" : "devtunnel");
+  const metaFile = path11.join(dir, "devtunnel.json");
   let meta = {};
   try {
-    meta = JSON.parse(fs9.readFileSync(metaFile, "utf8"));
+    meta = JSON.parse(fs14.readFileSync(metaFile, "utf8"));
   } catch {
   }
   const installed = findExecutable(bin) !== null;
@@ -2657,7 +4146,7 @@ async function ensureDevtunnel({ dir, progress }) {
       const head = await fetch(url, { method: "HEAD", signal: AbortSignal.timeout(3e3) });
       const lastModified = head.headers.get("last-modified");
       if (head.ok && lastModified && lastModified === meta.lastModified) {
-        fs9.writeFileSync(metaFile, JSON.stringify({ ...meta, checkedAt: Date.now() }));
+        fs14.writeFileSync(metaFile, JSON.stringify({ ...meta, checkedAt: Date.now() }));
         return bin;
       }
     } catch {
@@ -2672,12 +4161,12 @@ async function ensureDevtunnel({ dir, progress }) {
   return bin;
 }
 async function download(url, bin, metaFile, progress) {
-  fs9.mkdirSync(path7.dirname(bin), { recursive: true, mode: 448 });
+  fs14.mkdirSync(path11.dirname(bin), { recursive: true, mode: 448 });
   const res = await fetch(url, { signal: AbortSignal.timeout(12e4) });
   if (!res.ok || !res.body) throw new Error(`Downloading devtunnel failed: HTTP ${res.status} from ${url}`);
   const total = Number(res.headers.get("content-length")) || 0;
   const tmp = `${bin}.${process.pid}.download`;
-  const out = fs9.createWriteStream(tmp, { mode: 493 });
+  const out = fs14.createWriteStream(tmp, { mode: 493 });
   const md5 = createHash("md5");
   let received = 0;
   try {
@@ -2690,22 +4179,22 @@ async function download(url, bin, metaFile, progress) {
     await new Promise((resolve, reject) => out.end((e) => e ? reject(e) : resolve()));
     if (total && received !== total) throw new Error(`devtunnel download was cut short (${received} of ${total} bytes)`);
     await verify(tmp, md5.digest("base64"), res.headers.get("content-md5"));
-    fs9.chmodSync(tmp, 493);
-    fs9.renameSync(tmp, bin);
+    fs14.chmodSync(tmp, 493);
+    fs14.renameSync(tmp, bin);
   } catch (e) {
     out.destroy();
-    fs9.rmSync(tmp, { force: true });
+    fs14.rmSync(tmp, { force: true });
     throw e;
   }
-  fs9.writeFileSync(metaFile, JSON.stringify({ lastModified: res.headers.get("last-modified"), checkedAt: Date.now() }));
+  fs14.writeFileSync(metaFile, JSON.stringify({ lastModified: res.headers.get("last-modified"), checkedAt: Date.now() }));
 }
 async function verify(file, md5, expectedMd5) {
   if (expectedMd5 && md5 !== expectedMd5) throw new Error("devtunnel download is corrupt (MD5 mismatch)");
   if (isWindows) return verifyAuthenticode(file);
   if (process.platform !== "darwin") return;
   try {
-    await run4("codesign", ["--verify", "--strict", file]);
-    const { stderr } = await run4("codesign", ["-dv", file]);
+    await run5("codesign", ["--verify", "--strict", file]);
+    const { stderr } = await run5("codesign", ["-dv", file]);
     if (!stderr.includes(`TeamIdentifier=${MICROSOFT_TEAM_ID}`)) throw new Error("not signed by Microsoft");
   } catch (e) {
     throw new Error(`devtunnel download failed its signature check: ${e.message}`);
@@ -2716,7 +4205,7 @@ async function verifyAuthenticode(file) {
   let status2;
   let signer;
   try {
-    const { stdout } = await run4("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+    const { stdout } = await run5("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
       env: { ...process.env, CODEREMOTE_VERIFY: file }
     });
     [status2, signer] = stdout.trim().split("|");
@@ -2729,51 +4218,52 @@ async function verifyAuthenticode(file) {
 }
 
 // src/hook.js
-import { randomBytes as randomBytes2 } from "node:crypto";
-import fs10 from "node:fs";
-import http3 from "node:http";
-import path8 from "node:path";
+import { execFile as execFile10 } from "node:child_process";
+import { randomBytes as randomBytes3 } from "node:crypto";
+import fs15 from "node:fs";
+import http4 from "node:http";
+import path12 from "node:path";
 var CONNECT_TIMEOUT = 1e3;
 var EVENT_TIMEOUT = 5e3;
 function ensureHookSecret(dir) {
-  const file = path8.join(dir, "hook-secret");
+  const file = path12.join(dir, "hook-secret");
   try {
-    const secret2 = fs10.readFileSync(file, "utf8").trim();
+    const secret2 = fs15.readFileSync(file, "utf8").trim();
     if (secret2) return secret2;
   } catch {
   }
-  fs10.mkdirSync(dir, { recursive: true, mode: 448 });
-  const secret = randomBytes2(32).toString("base64url");
-  fs10.writeFileSync(file, secret, { mode: 384 });
+  fs15.mkdirSync(dir, { recursive: true, mode: 448 });
+  const secret = randomBytes3(32).toString("base64url");
+  fs15.writeFileSync(file, secret, { mode: 384 });
   return secret;
 }
 function writeHookLauncher(dir, { node = process.execPath, script }) {
-  const bin = path8.join(dir, "bin");
-  fs10.mkdirSync(bin, { recursive: true, mode: 448 });
+  const bin = path12.join(dir, "bin");
+  fs15.mkdirSync(bin, { recursive: true, mode: 448 });
   const quote = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
-  const file = path8.join(bin, "hook");
-  fs10.writeFileSync(file, `#!/bin/sh
+  const file = path12.join(bin, "hook");
+  fs15.writeFileSync(file, `#!/bin/sh
 exec ${quote(node)} ${quote(script)} hook "$@"
 `, { mode: 493 });
-  fs10.chmodSync(file, 493);
-  fs10.writeFileSync(path8.join(bin, "hook.json"), JSON.stringify({ node, script }), { mode: 384 });
+  fs15.chmodSync(file, 493);
+  fs15.writeFileSync(path12.join(bin, "hook.json"), JSON.stringify({ node, script }), { mode: 384 });
   return file;
 }
 function readHookSecret(dir) {
   try {
-    return fs10.readFileSync(path8.join(dir, "hook-secret"), "utf8").trim() || null;
+    return fs15.readFileSync(path12.join(dir, "hook-secret"), "utf8").trim() || null;
   } catch {
     return null;
   }
 }
 function real(p) {
   try {
-    return fs10.realpathSync.native(p);
+    return fs15.realpathSync.native(p);
   } catch {
-    return path8.resolve(p);
+    return path12.resolve(p);
   }
 }
-var within = (dir, root2) => dir === root2 || dir.startsWith(root2.endsWith(path8.sep) ? root2 : root2 + path8.sep);
+var within = (dir, root2) => dir === root2 || dir.startsWith(root2.endsWith(path12.sep) ? root2 : root2 + path12.sep);
 function hookTarget(agents, cwd, env = process.env) {
   const port2 = parseInt(env.CODEREMOTE_AGENT_PORT, 10);
   if (port2 && agents.some((a) => a.port === port2)) return { port: port2, terminal: env.CODEREMOTE_TERM_ID || null };
@@ -2782,23 +4272,46 @@ function hookTarget(agents, cwd, env = process.env) {
   const match = agents.map((a) => ({ ...a, real: real(a.root) })).filter((a) => within(dir, a.real)).sort((a, b) => b.real.length - a.real.length)[0];
   return match ? { port: match.port, terminal: null } : null;
 }
-function deliverHook({ port: port2, terminal, agent, secret, body, wait }) {
+var HOST_EVENTS = /* @__PURE__ */ new Set(["SessionStart", "UserPromptSubmit", "PermissionRequest"]);
+function hostAppFrom(psOutput, pid) {
+  const parents = /* @__PURE__ */ new Map();
+  for (const line of psOutput.split("\n")) {
+    const m = line.match(/^\s*(\d+)\s+(\d+)\s+(.+)$/);
+    if (m) parents.set(Number(m[1]), { ppid: Number(m[2]), comm: m[3] });
+  }
+  for (let seen = 0, p = parents.get(pid); p && seen < 64; seen++, p = parents.get(p.ppid)) {
+    const at = p.comm.indexOf(".app/");
+    if (at > 0) return p.comm.slice(0, at + 4);
+    if (p.ppid <= 1) break;
+  }
+  return null;
+}
+function hostApp() {
+  if (process.platform !== "darwin") return Promise.resolve(null);
+  return new Promise((resolve) => {
+    execFile10("ps", ["-A", "-o", "pid=,ppid=,comm="], { timeout: 1e3, maxBuffer: 8 * 1024 * 1024 }, (err, stdout) => {
+      resolve(err ? null : hostAppFrom(stdout, process.ppid));
+    });
+  });
+}
+function deliverHook({ port: port2, terminal, app = null, agent, secret, body, wait }) {
   return new Promise((resolve) => {
     const query = new URLSearchParams({ agent });
     if (terminal) query.set("terminal", terminal);
-    const req = http3.request({
+    if (app) query.set("app", app);
+    const req = http4.request({
       host: "127.0.0.1",
       port: port2,
       method: "POST",
       path: `/api/agents/hook?${query}`,
       headers: { "content-type": "application/json", "content-length": Buffer.byteLength(body), [HOOK_SECRET_HEADER]: secret }
     });
-    const fail = () => {
+    const fail2 = () => {
       req.destroy();
       resolve("");
     };
-    const connect = setTimeout(fail, CONNECT_TIMEOUT);
-    const overall = wait ? null : setTimeout(fail, EVENT_TIMEOUT);
+    const connect = setTimeout(fail2, CONNECT_TIMEOUT);
+    const overall = wait ? null : setTimeout(fail2, EVENT_TIMEOUT);
     req.on("socket", (socket) => socket.once("connect", () => clearTimeout(connect)));
     req.on("error", () => resolve(""));
     req.on("response", (res) => {
@@ -2813,7 +4326,7 @@ function deliverHook({ port: port2, terminal, agent, secret, body, wait }) {
     req.end(body);
   });
 }
-async function runHook({ input, agents, secret, agent = "claude", env = process.env }) {
+async function runHook({ input, agents, secret, agent = "claude", env = process.env, findApp = hostApp }) {
   if (!secret) return "";
   let event;
   try {
@@ -2824,16 +4337,23 @@ async function runHook({ input, agents, secret, agent = "claude", env = process.
   const target = hookTarget(agents, event?.cwd, env);
   if (!target) return "";
   const wait = event.hook_event_name === "PermissionRequest";
-  const out = await deliverHook({ ...target, agent, secret, body: input, wait });
+  const app = !target.terminal && HOST_EVENTS.has(event.hook_event_name) ? await findApp() : null;
+  const out = await deliverHook({ ...target, app, agent, secret, body: input, wait });
   return wait ? out.trim() : "";
 }
 
 // src/preview.js
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 
 // src/tunnels.js
 var TUNNEL_LIMIT = 10;
 var PREVIEW_LABEL = "coderemote-preview";
+var LOGIN_NEEDED = /not logged in|login token expired|login required|please log ?in/i;
+function signedInUser(res) {
+  if (!res.ok || LOGIN_NEEDED.test(res.out)) return null;
+  const m = res.out.match(/Logged in as (\S+) using (\S+?)\.?\s*$/m);
+  return m ? `${m[1]} (${m[2]})` : res.out.trim() || null;
+}
 var base = (id) => String(id).split(".")[0];
 async function listTunnels(devtunnel2) {
   const res = await devtunnel2("list", "--limit", "100", "--json");
@@ -2965,8 +4485,8 @@ var PreviewTunnel = class {
         "--json"
       );
       if (!res.ok) throw new Error(`devtunnel access create failed: ${res.out.trim()}`);
-      const entries = JSON.parse(res.out.slice(res.out.indexOf("{"))).accessControlEntries ?? [];
-      const until = Date.parse(entries.find((e) => e.type === "Anonymous")?.expiration);
+      const entries2 = JSON.parse(res.out.slice(res.out.indexOf("{"))).accessControlEntries ?? [];
+      const until = Date.parse(entries2.find((e) => e.type === "Anonymous")?.expiration);
       this.#shares.set(port2, Number.isFinite(until) ? until : Date.now() + hours * 36e5);
     });
   }
@@ -3076,7 +4596,7 @@ ${created.out}`);
   }
   #startHost() {
     return new Promise((resolve, reject) => {
-      const child = spawn2(this.command(), ["host", this.#tunnelId], { stdio: ["ignore", "pipe", "pipe"] });
+      const child = spawn4(this.command(), ["host", this.#tunnelId], { stdio: ["ignore", "pipe", "pipe"] });
       const urls = /* @__PURE__ */ new Map();
       let log2 = "";
       const timer = setTimeout(() => {
@@ -3111,40 +4631,40 @@ ${log2}`));
 };
 
 // src/push-store.js
-import fs11 from "node:fs";
-import path9 from "node:path";
+import fs16 from "node:fs";
+import path13 from "node:path";
 function pushStore(dir, port2) {
-  const file = path9.join(dir, `${port2}.json`);
+  const file = path13.join(dir, `${port2}.json`);
   return {
     load() {
       try {
-        const devices = JSON.parse(fs11.readFileSync(file, "utf8"));
+        const devices = JSON.parse(fs16.readFileSync(file, "utf8"));
         return Array.isArray(devices) ? devices : [];
       } catch {
         return [];
       }
     },
     save(devices) {
-      fs11.mkdirSync(dir, { recursive: true, mode: 448 });
-      fs11.writeFileSync(file, JSON.stringify(devices, null, 2), { mode: 384 });
+      fs16.mkdirSync(dir, { recursive: true, mode: 448 });
+      fs16.writeFileSync(file, JSON.stringify(devices, null, 2), { mode: 384 });
     }
   };
 }
 
 // src/registry.js
-import fs12 from "node:fs";
-import path10 from "node:path";
+import fs17 from "node:fs";
+import path14 from "node:path";
 var AgentRegistry = class {
   constructor(dir) {
     this.dir = dir;
   }
   register({ port: port2, root: root2, url }) {
-    fs12.mkdirSync(this.dir, { recursive: true, mode: 448 });
+    fs17.mkdirSync(this.dir, { recursive: true, mode: 448 });
     const file = this.#file(port2);
-    fs12.writeFileSync(file, JSON.stringify({ pid: process.pid, port: port2, root: root2, url, startedAt: Date.now() }), { mode: 384 });
+    fs17.writeFileSync(file, JSON.stringify({ pid: process.pid, port: port2, root: root2, url, startedAt: Date.now() }), { mode: 384 });
     const cleanup = () => {
       try {
-        if (JSON.parse(fs12.readFileSync(file, "utf8")).pid === process.pid) fs12.rmSync(file);
+        if (JSON.parse(fs17.readFileSync(file, "utf8")).pid === process.pid) fs17.rmSync(file);
       } catch {
       }
     };
@@ -3155,30 +4675,31 @@ var AgentRegistry = class {
   list() {
     let names = [];
     try {
-      names = fs12.readdirSync(this.dir).filter((n) => n.endsWith(".json"));
+      names = fs17.readdirSync(this.dir).filter((n) => n.endsWith(".json"));
     } catch {
       return [];
     }
     const agents = [];
     for (const name of names) {
-      const file = path10.join(this.dir, name);
+      const file = path14.join(this.dir, name);
       try {
-        const agent = JSON.parse(fs12.readFileSync(file, "utf8"));
+        const agent = JSON.parse(fs17.readFileSync(file, "utf8"));
         process.kill(agent.pid, 0);
         agents.push(agent);
       } catch {
-        fs12.rmSync(file, { force: true });
+        fs17.rmSync(file, { force: true });
       }
     }
     return agents.sort((a, b) => a.port - b.port);
   }
   #file(port2) {
-    return path10.join(this.dir, `${port2}.json`);
+    return path14.join(this.dir, `${port2}.json`);
   }
 };
 
 // src/tunnel-status.js
 var MACHINE_LABEL = "coderemote";
+var PROVIDER = "devtunnels";
 var CACHE_MS = 15e3;
 function parse(out) {
   return JSON.parse(out.slice(out.indexOf("{")));
@@ -3186,6 +4707,13 @@ function parse(out) {
 function machineName(description) {
   return (description || "").replace(/^(coderemote|vsremote)\s+/, "").replace(/\.local\b/, "") || null;
 }
+var VSCODE_LABEL = "vscode-server-launcher";
+function otherTunnel(tunnel) {
+  const labels = tunnel.labels ?? [];
+  const kind = labels.includes(PREVIEW_LABEL) ? "preview" : labels.includes(VSCODE_LABEL) ? "vscode" : "other";
+  const name = kind === "preview" ? machineName((tunnel.description || "").replace(/^coderemote preview\s+/, "")) : tunnel.description || null;
+  return { id: tunnel.tunnelId, kind, name, online: tunnel.hostConnections > 0 };
+}
 function machine(tunnel, current) {
   return {
     id: tunnel.tunnelId,
@@ -3197,19 +4725,21 @@ function machine(tunnel, current) {
     current
   };
 }
-function tunnelStatus({ devtunnel: devtunnel2, tunnelId, account, anonymous: anonymous2, preview }) {
+function tunnelStatus({ devtunnel: devtunnel2, tunnelId, account, anonymous: anonymous2, preview: preview2 }) {
   let cached = null;
-  return async () => {
+  const status2 = async () => {
     const id = tunnelId();
     if (!id) return null;
-    if (cached && Date.now() - cached.at < CACHE_MS) return { ...cached.value, previewPorts: preview?.list().length ?? 0 };
+    if (cached && Date.now() - cached.at < CACHE_MS) return { ...cached.value, previewPorts: preview2?.list().length ?? 0 };
     const [own, listed] = await Promise.all([
       devtunnel2("show", id, "--json"),
-      devtunnel2("list", "--labels", MACHINE_LABEL, "--json")
+      // Every tunnel, previews' too: they all count against the account's limit.
+      devtunnel2("list", "--limit", "100", "--json")
     ]);
     if (!own.ok) throw new Error(`devtunnel show failed: ${own.out.trim()}`);
     const tunnel = parse(own.out).tunnel;
-    const others = listed.ok ? (parse(listed.out).tunnels ?? []).filter((t) => t.tunnelId !== id) : [];
+    const all = listed.ok ? parse(listed.out).tunnels ?? [] : null;
+    const others = (all ?? []).filter((t) => t.tunnelId !== id && t.labels?.includes(MACHINE_LABEL));
     const shown = await Promise.all(
       others.map(async (t) => {
         const res = await devtunnel2("show", t.tunnelId, "--json");
@@ -3218,6 +4748,7 @@ function tunnelStatus({ devtunnel: devtunnel2, tunnelId, account, anonymous: ano
     );
     const machines = [machine(tunnel, true), ...shown.filter(Boolean).map((t) => machine(t, false))];
     const value = {
+      provider: PROVIDER,
       account: account() ?? null,
       tunnel: {
         id,
@@ -3229,16 +4760,54 @@ function tunnelStatus({ devtunnel: devtunnel2, tunnelId, account, anonymous: ano
         uploaded: tunnel.uploadTotal ?? null,
         downloaded: tunnel.downloadTotal ?? null
       },
-      machines
+      machines,
+      // The account's tunnels that aren't machines; empty when it couldn't be listed.
+      others: (all ?? []).filter((t) => t.tunnelId !== id && !t.labels?.includes(MACHINE_LABEL)).map(otherTunnel),
+      // null when the account couldn't be listed
+      quota: all && { used: all.length, limit: TUNNEL_LIMIT }
     };
     cached = { at: Date.now(), value };
-    return { ...value, previewPorts: preview?.list().length ?? 0 };
+    return { ...value, previewPorts: preview2?.list().length ?? 0 };
+  };
+  status2.invalidate = () => {
+    cached = null;
+  };
+  return status2;
+}
+var fail = (status2, code, message) => Object.assign(new Error(message), { status: status2, code });
+function tunnelDelete({ devtunnel: devtunnel2, tunnelId, deleted = () => {
+} }) {
+  return async ({ id, account, force = false }) => {
+    if (typeof id !== "string" || !id) throw fail(400, "EINVAL", "id is required");
+    if (typeof account !== "string" || !account) throw fail(400, "EINVAL", "account is required");
+    const user = signedInUser(await devtunnel2("user", "show"));
+    if (!user) {
+      throw fail(403, "ELOGIN", "The computer\u2019s dev tunnels sign-in has expired. Run `coderemote login` on it, then try again.");
+    }
+    if (user !== account) {
+      throw fail(409, "EACCOUNT", `The computer is now signed in as ${user}, not ${account}. Refresh, then try again.`);
+    }
+    const { tunnels, error } = await listTunnels(devtunnel2);
+    if (error) throw fail(502, "EDEVTUNNEL", error);
+    const tunnel = findTunnel(tunnels, id);
+    if (!tunnel) throw fail(404, "ENOTUNNEL", `No tunnel ${id} on ${account}.`);
+    const own = tunnelId();
+    if (own && findTunnel([tunnel], own)) {
+      throw fail(409, "EOWN", "This is the tunnel this connection runs through. Delete it on the computer: `coderemote tunnels delete <id> --force`.");
+    }
+    if (tunnel.hostConnections > 0 && !force) {
+      throw fail(409, "EONLINE", "An agent is serving this tunnel right now. Deleting it unpairs its phones; send force to delete it anyway.");
+    }
+    const res = await devtunnel2("delete", tunnel.tunnelId, "-f");
+    if (!res.ok) throw fail(502, "EDEVTUNNEL", res.out.trim());
+    deleted(tunnel.tunnelId);
+    return { deleted: tunnel.tunnelId };
   };
 }
 
 // src/update.js
-import fs13 from "node:fs";
-import path11 from "node:path";
+import fs18 from "node:fs";
+import path15 from "node:path";
 var LATEST_URL = "https://registry.npmjs.org/coderemote/latest";
 var CHECK_INTERVAL_MS = 24 * 36e5;
 var SEMVER = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/;
@@ -3262,10 +4831,10 @@ async function fetchLatest({ fetch: fetch2 = globalThis.fetch, timeoutMs = 3e3 }
   }
 }
 async function availableUpdate({ current, dir, fetch: fetch2, now = Date.now() }) {
-  const file = path11.join(dir, "update.json");
+  const file = path15.join(dir, "update.json");
   let cache = {};
   try {
-    cache = JSON.parse(fs13.readFileSync(file, "utf8"));
+    cache = JSON.parse(fs18.readFileSync(file, "utf8"));
   } catch {
   }
   let latest = cache.latest;
@@ -3274,8 +4843,8 @@ async function availableUpdate({ current, dir, fetch: fetch2, now = Date.now() }
     if (fetched) {
       latest = fetched;
       try {
-        fs13.mkdirSync(dir, { recursive: true, mode: 448 });
-        fs13.writeFileSync(file, JSON.stringify({ latest, checkedAt: now }));
+        fs18.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs18.writeFileSync(file, JSON.stringify({ latest, checkedAt: now }));
       } catch {
       }
     }
@@ -3283,12 +4852,12 @@ async function availableUpdate({ current, dir, fetch: fetch2, now = Date.now() }
   return isNewer(latest, current) ? latest : null;
 }
 function installCommand(installedAt) {
-  const p = installedAt.split(path11.sep).join("/");
+  const p = installedAt.split(path15.sep).join("/");
   const runtime = p.match(/^(.*\/runtime\/node)\/(lib\/)?node_modules\/coderemote\//);
   if (runtime) {
     const prefix = installedAt.slice(0, runtime[1].length);
-    const [node, modules] = runtime[2] ? [path11.join(prefix, "bin", "node"), path11.join(prefix, "lib", "node_modules")] : [path11.join(prefix, "node.exe"), path11.join(prefix, "node_modules")];
-    return [node, [path11.join(modules, "npm", "bin", "npm-cli.js"), "install", "-g", "--prefix", prefix, "coderemote@latest"]];
+    const [node, modules] = runtime[2] ? [path15.join(prefix, "bin", "node"), path15.join(prefix, "lib", "node_modules")] : [path15.join(prefix, "node.exe"), path15.join(prefix, "node_modules")];
+    return [node, [path15.join(modules, "npm", "bin", "npm-cli.js"), "install", "-g", "--prefix", prefix, "coderemote@latest"]];
   }
   if (p.includes("/Cellar/coderemote/")) return ["brew", ["upgrade", "coderemote"]];
   if (p.includes("/pnpm/") || p.includes("/.pnpm/")) return ["pnpm", ["add", "-g", "coderemote@latest"]];
@@ -3300,7 +4869,7 @@ function installCommand(installedAt) {
 // package.json
 var package_default = {
   name: "coderemote",
-  version: "0.3.7",
+  version: "0.3.9",
   description: "Use your computer from your iPhone: files, git and a real terminal over a secure Microsoft Dev Tunnel. No SSH, no port forwarding, no VPN.",
   keywords: [
     "remote",
@@ -3623,28 +5192,28 @@ ${log2}`));
 }
 
 // bin/coderemote.js
-var run5 = promisify4(execFile8);
-var CONFIG_DIR = path12.join(os6.homedir(), ".coderemote");
-var LEGACY_CONFIG_DIR = path12.join(os6.homedir(), ".vsremote");
-if (!fs14.existsSync(CONFIG_DIR) && fs14.existsSync(LEGACY_CONFIG_DIR)) fs14.renameSync(LEGACY_CONFIG_DIR, CONFIG_DIR);
-var CONFIG_FILE = path12.join(CONFIG_DIR, "config.json");
-var PUSH_DIR = path12.join(CONFIG_DIR, "push");
-var UPLOADS_DIR = path12.join(CONFIG_DIR, "uploads");
+var run6 = promisify4(execFile11);
+var CONFIG_DIR = path16.join(os7.homedir(), ".coderemote");
+var LEGACY_CONFIG_DIR = path16.join(os7.homedir(), ".vsremote");
+if (!fs19.existsSync(CONFIG_DIR) && fs19.existsSync(LEGACY_CONFIG_DIR)) fs19.renameSync(LEGACY_CONFIG_DIR, CONFIG_DIR);
+var CONFIG_FILE = path16.join(CONFIG_DIR, "config.json");
+var PUSH_DIR = path16.join(CONFIG_DIR, "push");
+var UPLOADS_DIR = path16.join(CONFIG_DIR, "uploads");
 var DEFAULT_PORT = 31580;
 var VERSION = package_default.version;
-var PACKAGED = path12.basename(path12.dirname(fileURLToPath(import.meta.url))) === "dist";
+var PACKAGED = path16.basename(path16.dirname(fileURLToPath(import.meta.url))) === "dist";
 var spinner = new Spinner();
 function loadConfig() {
   let cfg2 = {};
   try {
-    cfg2 = JSON.parse(fs14.readFileSync(CONFIG_FILE, "utf8"));
+    cfg2 = JSON.parse(fs19.readFileSync(CONFIG_FILE, "utf8"));
   } catch {
   }
   if (!cfg2.token) {
-    cfg2.token = randomBytes3(32).toString("base64url");
+    cfg2.token = randomBytes4(32).toString("base64url");
     saveConfig(cfg2);
-    fs14.rmSync(PUSH_DIR, { recursive: true, force: true });
-    fs14.rmSync(UPLOADS_DIR, { recursive: true, force: true });
+    fs19.rmSync(PUSH_DIR, { recursive: true, force: true });
+    fs19.rmSync(UPLOADS_DIR, { recursive: true, force: true });
   }
   if (cfg2.tunnelId && !cfg2.tunnels) {
     cfg2.tunnels = { [DEFAULT_PORT]: cfg2.tunnelId };
@@ -3660,30 +5229,32 @@ function stopAgent(pid) {
   }
 }
 function saveConfig(cfg2) {
-  fs14.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
-  fs14.writeFileSync(CONFIG_FILE, JSON.stringify(cfg2, null, 2), { mode: 384 });
+  fs19.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  fs19.writeFileSync(CONFIG_FILE, JSON.stringify(cfg2, null, 2), { mode: 384 });
 }
 function portFree(port2) {
   return new Promise((resolve) => {
-    const probe = net2.createServer();
+    const probe = net3.createServer();
     probe.once("error", () => resolve(false));
     probe.listen(port2, "127.0.0.1", () => probe.close(() => resolve(true)));
   });
 }
-function listen(token, port2, root2, tunnelToken, preview, status2) {
+function listen(token, port2, root2, tunnelToken, preview2, status2, remover) {
   const hookSecret = ensureHookSecret(CONFIG_DIR);
-  writeHookLauncher(CONFIG_DIR, { script: fs14.realpathSync(process.argv[1]) });
+  writeHookLauncher(CONFIG_DIR, { script: fs19.realpathSync(process.argv[1]) });
   const server = createAgentServer({
     token,
     root: root2,
     tunnelToken,
-    preview,
+    preview: preview2,
     tunnelStatus: status2,
+    tunnelDelete: remover,
     hookSecret,
     // This very CLI, so coding agents in the app's terminals report through the same version.
-    hookBin: fs14.realpathSync(process.argv[1]),
+    hookBin: fs19.realpathSync(process.argv[1]),
     pushStore: pushStore(PUSH_DIR, port2),
-    uploadsDir: UPLOADS_DIR
+    uploadsDir: UPLOADS_DIR,
+    version: VERSION
   });
   return new Promise((resolve, reject) => {
     server.once("error", reject);
@@ -3694,7 +5265,7 @@ var DEVTUNNEL = "devtunnel";
 async function resolveDevtunnel() {
   let installing = false;
   DEVTUNNEL = await ensureDevtunnel({
-    dir: path12.join(CONFIG_DIR, "bin"),
+    dir: path16.join(CONFIG_DIR, "bin"),
     progress: (detail2) => {
       if (!installing) {
         installing = true;
@@ -3707,7 +5278,7 @@ async function resolveDevtunnel() {
 }
 async function devtunnel(...args) {
   try {
-    const { stdout } = await run5(DEVTUNNEL, args);
+    const { stdout } = await run6(DEVTUNNEL, args);
     return { ok: true, out: stdout };
   } catch (e) {
     return { ok: false, out: `${e.stdout || ""}${e.stderr || ""}` || e.message };
@@ -3721,10 +5292,9 @@ function loginArgs(opts = rest) {
 }
 function interactiveLogin(args) {
   return new Promise((resolve) => {
-    spawn3(DEVTUNNEL, args, { stdio: "inherit" }).on("exit", resolve);
+    spawn5(DEVTUNNEL, args, { stdio: "inherit" }).on("exit", resolve);
   });
 }
-var LOGIN_NEEDED = /not logged in|login token expired|login required|please log ?in/i;
 async function login(reason) {
   spinner.stop();
   console.error(`Dev tunnels: ${reason.trim()}`);
@@ -3740,12 +5310,11 @@ async function login(reason) {
 }
 async function tunnelUser() {
   let who = await devtunnel("user", "show");
-  if (!who.ok || LOGIN_NEEDED.test(who.out)) {
+  if (!signedInUser(who)) {
     await login(who.out || "not logged in");
     who = await devtunnel("user", "show");
   }
-  const m = who.out.match(/Logged in as (\S+) using (\S+?)\.?\s*$/m);
-  return m ? `${m[1]} (${m[2]})` : who.out.trim();
+  return signedInUser(who) ?? who.out.trim();
 }
 function applyAccess(tunnelId, anonymous2) {
   return anonymous2 ? devtunnel("access", "create", tunnelId, "--anonymous") : devtunnel("access", "reset", tunnelId);
@@ -3765,7 +5334,7 @@ ${access.out}`);
     if (!/not found/i.test(updated.out)) throw new Error(`devtunnel update failed:
 ${updated.out}`);
   }
-  const name = port2 === DEFAULT_PORT ? os6.hostname() : `${os6.hostname()} :${port2}`;
+  const name = port2 === DEFAULT_PORT ? os7.hostname() : `${os7.hostname()} :${port2}`;
   const createArgs = ["create", "--expiration", "30d", "-d", `coderemote ${name}`, "--labels", MACHINE_LABEL, "--json"];
   if (anonymous2) createArgs.push("--allow-anonymous");
   let created = await devtunnel(...createArgs);
@@ -3807,7 +5376,7 @@ ${res.out}`);
 }
 function hostTunnel(tunnelId, port2) {
   return new Promise((resolve, reject) => {
-    const child = spawn3(DEVTUNNEL, ["host", tunnelId], { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn5(DEVTUNNEL, ["host", tunnelId], { stdio: ["ignore", "pipe", "pipe"] });
     let log2 = "";
     const onData = (d) => {
       log2 += d;
@@ -3911,9 +5480,9 @@ var flag = (name) => {
 };
 var anonymous = rest.includes("--allow-anonymous") || rest.includes("--no-auth");
 var port = flag("--port") ? parseInt(flag("--port"), 10) : DEFAULT_PORT;
-var root = path12.resolve(flag("--root") ?? process.cwd());
+var root = path16.resolve(flag("--root") ?? process.cwd());
 var cfg = loadConfig();
-var registry = new AgentRegistry(path12.join(CONFIG_DIR, "agents"));
+var registry = new AgentRegistry(path16.join(CONFIG_DIR, "agents"));
 async function start({ tunnel }) {
   const agents = registry.list();
   if (flag("--port")) {
@@ -3945,10 +5514,10 @@ async function start({ tunnel }) {
   let server;
   let tunnelId;
   const tunnelToken = async () => tunnel && !anonymous && tunnelId ? connectToken(tunnelId) : null;
-  const preview = tunnel ? new PreviewTunnel({
+  const preview2 = tunnel ? new PreviewTunnel({
     devtunnel,
     command: () => DEVTUNNEL,
-    description: `coderemote preview ${os6.hostname()}`,
+    description: `coderemote preview ${os7.hostname()}`,
     leftover: cfg.previewTunnels?.[port],
     remember: (id) => {
       cfg.previewTunnels = { ...cfg.previewTunnels, [port]: id };
@@ -3958,10 +5527,19 @@ async function start({ tunnel }) {
     mintToken: connectToken
   }) : null;
   let account;
-  const status2 = tunnel ? tunnelStatus({ devtunnel, tunnelId: () => tunnelId, account: () => account, anonymous, preview }) : null;
+  const status2 = tunnel ? tunnelStatus({ devtunnel, tunnelId: () => tunnelId, account: () => account, anonymous, preview: preview2 }) : null;
+  const remover = tunnel ? tunnelDelete({
+    devtunnel,
+    tunnelId: () => tunnelId,
+    deleted: (id) => {
+      status2.invalidate();
+      const saved = loadConfig();
+      if (forgetTunnel(saved, id)) saveConfig(saved);
+    }
+  }) : null;
   spinner.start("Starting agent");
   try {
-    server = await listen(cfg.token, port, root, tunnelToken, preview, status2);
+    server = await listen(cfg.token, port, root, tunnelToken, preview2, status2, remover);
   } catch (e) {
     spinner.fail();
     if (e.code !== "EADDRINUSE") throw e;
@@ -3998,7 +5576,7 @@ async function start({ tunnel }) {
   registry.register({ port, root, url });
   const shutdown = async () => {
     child?.kill();
-    await preview?.close();
+    await preview2?.close();
     await server.killAllSessions();
     server.close();
     process.exit(0);
@@ -4008,7 +5586,7 @@ async function start({ tunnel }) {
   process.on("SIGHUP", shutdown);
   process.on("exit", () => {
     child?.kill();
-    preview?.stop();
+    preview2?.stop();
   });
   return { url, access };
 }
@@ -4131,7 +5709,7 @@ function currentAgent() {
   const agents = registry.list();
   if (flag("--port")) return agents.find((a) => a.port === port);
   const here = process.cwd();
-  const containing = agents.filter((a) => here === a.root || here.startsWith(a.root + path12.sep)).sort((a, b) => b.root.length - a.root.length);
+  const containing = agents.filter((a) => here === a.root || here.startsWith(a.root + path16.sep)).sort((a, b) => b.root.length - a.root.length);
   return containing[0] ?? (agents.length === 1 ? agents[0] : void 0);
 }
 async function previewPorts(agent, given) {
@@ -4267,7 +5845,7 @@ Token: ${cfg.token}`);
     break;
   }
   case "rotate-token": {
-    cfg.token = randomBytes3(32).toString("base64url");
+    cfg.token = randomBytes4(32).toString("base64url");
     saveConfig(cfg);
     const agents = registry.list();
     for (const agent of agents) {
@@ -4340,7 +5918,7 @@ Token: ${cfg.token}`);
       console.log(`coderemote ${VERSION} is the latest version.`);
       break;
     }
-    const [command, args] = installCommand(fs14.realpathSync(process.argv[1]));
+    const [command, args] = installCommand(fs19.realpathSync(process.argv[1]));
     console.log(`Updating coderemote ${VERSION} \u2192 ${latest}: ${command} ${args.join(" ")}
 `);
     const code = await new Promise((resolve) => {