coderemote 0.3.2 → 0.3.5

package/dist/coderemote.js

@@ -1,24 +1,25 @@
 #!/usr/bin/env node
 
 // bin/coderemote.js
-import { execFile as execFile5, spawn as spawn3 } from "node:child_process";
-import { randomBytes } from "node:crypto";
-import fs8 from "node:fs";
+import { execFile as execFile8, spawn as spawn3 } from "node:child_process";
+import { randomBytes as randomBytes3 } from "node:crypto";
+import fs13 from "node:fs";
 import net2 from "node:net";
-import os4 from "node:os";
-import path7 from "node:path";
+import os6 from "node:os";
+import path11 from "node:path";
 import { fileURLToPath } from "node:url";
-import { promisify as promisify3 } from "node:util";
+import { promisify as promisify5 } from "node:util";
 import qrcode from "qrcode-terminal";
 
 // ../../packages/agent-core/src/server.js
-import { createReadStream, createWriteStream } from "node:fs";
-import fs4 from "node:fs/promises";
+import { createReadStream, createWriteStream as createWriteStream2 } from "node:fs";
+import fs7 from "node:fs/promises";
 import http2 from "node:http";
-import os3 from "node:os";
-import path3 from "node:path";
-import { pipeline } from "node:stream/promises";
-import { timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import os5 from "node:os";
+import path5 from "node:path";
+import { pipeline as pipeline2 } from "node:stream/promises";
+import { randomUUID as randomUUID4, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { execFile as execFile5 } from "node:child_process";
 
 // ../../packages/protocol/index.js
 var PROTOCOL_VERSION = 4;
@@ -56,13 +57,39 @@ var Routes = Object.freeze({
   previewRequest: "GET /api/preview/request",
   previewRequestsClear: "DELETE /api/preview/requests",
   tunnelToken: "POST /api/tunnel/token",
-  tunnelStatus: "GET /api/tunnel"
+  tunnelStatus: "GET /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",
+  agentsPrompt: "POST /api/agents/prompt",
+  agentsKeys: "POST /api/agents/keys",
+  agentsStop: "POST /api/agents/stop",
+  agentsForget: "POST /api/agents/forget",
+  agentsUpload: "POST /api/agents/uploads",
+  pushDeviceSet: "PUT /api/push/device",
+  pushDeviceDelete: "DELETE /api/push/device",
+  pushTest: "POST /api/push/test"
 });
 var TUNNEL_HANDOFF_PATH = "/vsremote/handoff";
 var TUNNEL_AUTH_CALLBACK_HOST = "tunnel-auth";
 var TERMINAL_WS_PATH = "/api/term/ws";
 var TerminalServerMessage = Object.freeze({ session: "session", exit: "exit" });
 var TerminalClientMessage = Object.freeze({ input: "input", resize: "resize" });
+var AGENTS_WS_PATH = "/api/agents/ws";
+var HOOK_SECRET_HEADER = "x-coderemote-hook";
+var AgentsServerMessage = Object.freeze({
+  snapshot: "snapshot",
+  session: "session",
+  entry: "entry",
+  request: "request",
+  requestResolved: "request_resolved",
+  sessionRemoved: "session_removed",
+  promptConfirmed: "prompt_confirmed"
+});
+var AgentsClientMessage = Object.freeze({ presence: "presence" });
 function webUrl({ url, token }) {
   return `${url}/#token=${encodeURIComponent(token)}`;
 }
@@ -73,9 +100,9 @@ function pairingUrl({ url, token }) {
 // ../../packages/agent-core/src/server.js
 import { WebSocketServer } from "ws";
 
-// ../../packages/agent-core/src/git.js
-import { execFile } from "node:child_process";
-import fs2 from "node:fs/promises";
+// ../../packages/agent-core/src/agents.js
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
 import path2 from "node:path";
 
 // ../../packages/agent-core/src/sandbox.js
@@ -109,8 +136,8 @@ var Sandbox = class {
   }
   /** Like `resolve`, but refuses the root itself (deleting or renaming the shared folder). */
   async resolveChild(p, { allowMissing = false } = {}) {
-    const { abs, real } = await this.#check(p, allowMissing);
-    if (real === this.realRoot) throw new HttpError(403, "cannot modify the shared folder itself");
+    const { abs, real: real2 } = await this.#check(p, allowMissing);
+    if (real2 === this.realRoot) throw new HttpError(403, "cannot modify the shared folder itself");
     return abs;
   }
   async #check(p, allowMissing) {
@@ -120,9 +147,9 @@ var Sandbox = class {
     let tail = "";
     while (true) {
       try {
-        const real = path.join(await fs.realpath(existing), tail);
-        if (!this.#containsReal(real)) throw outside();
-        return { abs, real };
+        const real2 = path.join(await fs.realpath(existing), tail);
+        if (!this.#containsReal(real2)) throw outside();
+        return { abs, real: real2 };
       } catch (e) {
         if (e instanceof HttpError) throw e;
         if (!this.#containsLexically(abs)) throw outside();
@@ -139,7 +166,644 @@ function outside() {
   return new HttpError(403, "path is outside the shared folder");
 }
 
+// ../../packages/agent-core/src/codex-rollout.js
+import fs2 from "node:fs/promises";
+var POLL = 1e3;
+function codexItem(item) {
+  if (!item || typeof item !== "object") return null;
+  if (item.type === "AgentMessage") {
+    const text = (item.content ?? []).filter((c) => typeof c?.text === "string").map((c) => c.text).join("\n").trim();
+    return text ? { kind: "assistant", text } : null;
+  }
+  if (item.type === "FileChange" && item.changes && typeof item.changes === "object") {
+    const verbs = { add: "Added", update: "Updated", delete: "Deleted" };
+    const lines = Object.entries(item.changes).map(([file, change]) => `${verbs[change?.type] ?? "Changed"} ${file}`);
+    return { kind: "tool_result", toolUseId: item.id ?? null, output: lines.join("\n"), error: false };
+  }
+  const output = item.aggregated_output ?? item.aggregatedOutput ?? item.output;
+  if (typeof item.id === "string" && typeof output === "string") {
+    const code = item.exit_code ?? item.exitCode;
+    return { kind: "tool_result", toolUseId: item.id, output, error: typeof code === "number" && code !== 0 };
+  }
+  return null;
+}
+var RolloutTail = class {
+  #file;
+  #offset = null;
+  #partial = "";
+  #timer = null;
+  #onItem;
+  constructor(file, onItem) {
+    this.#file = file;
+    this.#onItem = onItem;
+    this.#timer = setInterval(() => this.poll().catch(() => {
+    }), POLL);
+    this.#timer.unref?.();
+  }
+  async poll() {
+    const handle = await fs2.open(this.#file, "r");
+    try {
+      const { size } = await handle.stat();
+      if (this.#offset === null || size < this.#offset) {
+        this.#offset = size;
+        return;
+      }
+      if (size === this.#offset) return;
+      const buf = Buffer.alloc(size - this.#offset);
+      await handle.read(buf, 0, buf.length, this.#offset);
+      this.#offset = size;
+      const lines = (this.#partial + buf.toString("utf8")).split("\n");
+      this.#partial = lines.pop();
+      for (const line of lines) {
+        let record;
+        try {
+          record = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (record?.type === "event_msg" && record.payload?.type === "item_completed") this.#onItem(record.payload.item);
+      }
+    } finally {
+      await handle.close();
+    }
+  }
+  stop() {
+    clearInterval(this.#timer);
+  }
+};
+
+// ../../packages/agent-core/src/transcript.js
+import fs3 from "node:fs/promises";
+var TAIL_BYTES = 2 * 1024 * 1024;
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((c) => c?.type === "text" && typeof c.text === "string").map((c) => c.text).join("\n");
+}
+function isTyped(text) {
+  const t = text.trim();
+  return t && !t.startsWith("<command-") && !t.startsWith("<local-command") && !t.startsWith("[Request interrupted");
+}
+function* entriesOf(record) {
+  if (!record || record.isSidechain || record.isMeta) return;
+  const time2 = Date.parse(record.timestamp) || 0;
+  const content = record.message?.content;
+  if (record.type === "user") {
+    if (typeof content === "string") {
+      if (isTyped(content)) yield { time: time2, kind: "prompt", text: content };
+      return;
+    }
+    if (!Array.isArray(content)) return;
+    for (const c of content) {
+      if (c?.type === "tool_result") {
+        yield { time: time2, kind: "tool_result", toolUseId: c.tool_use_id ?? null, name: null, output: textOf(c.content), error: c.is_error === true, truncated: false, duration: null };
+      }
+    }
+    const text = textOf(content);
+    if (isTyped(text) && content.every((c) => c?.type !== "tool_result")) yield { time: time2, kind: "prompt", text };
+  } else if (record.type === "assistant" && Array.isArray(content)) {
+    for (const c of content) {
+      if (c?.type === "text" && c.text?.trim()) yield { time: time2, kind: "assistant", text: c.text.trimEnd() };
+      else if (c?.type === "tool_use") yield { time: time2, kind: "tool", toolUseId: c.id ?? null, name: c.name ?? null, input: c.input ?? null };
+    }
+  }
+}
+async function readTranscript(file, limit = 500) {
+  let text;
+  try {
+    const handle = await fs3.open(file, "r");
+    try {
+      const { size } = await handle.stat();
+      const start2 = Math.max(0, size - TAIL_BYTES);
+      const buf = Buffer.alloc(size - start2);
+      await handle.read(buf, 0, buf.length, start2);
+      text = buf.toString("utf8");
+      if (start2 > 0) text = text.slice(text.indexOf("\n") + 1);
+    } finally {
+      await handle.close();
+    }
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      entries.push(...entriesOf(JSON.parse(line)));
+    } catch {
+    }
+  }
+  return entries.slice(-limit);
+}
+
+// ../../packages/agent-core/src/agents.js
+var MAX_ENTRIES = 500;
+var MAX_TEXT = 16 * 1024;
+var MAX_TITLE = 80;
+var ENDED_TTL = 24 * 60 * 60 * 1e3;
+var REQUEST_TTL = 60 * 60 * 1e3;
+var START_TIMEOUT = 15 * 1e3;
+var SEQUENTIAL_REQUEST_TTL = 10 * 60 * 1e3;
+var ADAPTERS = {
+  claude: {
+    name: "Claude Code",
+    capabilities: { approvals: "parallel", alwaysAllow: true, keys: ["interrupt", "cycle_mode", "/compact", "/clear", "/model"] },
+    normalize: (e) => e
+  },
+  codex: {
+    name: "Codex",
+    // Codex reports a session only once it gets its first prompt.
+    startsOnPrompt: true,
+    setupHint: ", then trust its hooks with `/hooks` in Codex",
+    capabilities: { approvals: "presence", alwaysAllow: false, keys: ["interrupt", "/compact", "/model"] },
+    normalize: (e) => ({
+      ...e,
+      // Codex's patch tool carries the patch where Bash has its command.
+      tool_input: e.tool_name === "apply_patch" && typeof e.tool_input === "string" ? { command: e.tool_input } : e.tool_input
+    })
+  }
+};
+function comparable(text, paths = []) {
+  let t = String(text);
+  for (const p of paths) t = t.split(p).join(" ");
+  return t.replace(/\[Image #\d+\]/g, " ").replace(/\s+/g, " ").trim();
+}
+function clip(text) {
+  const buf = Buffer.from(text, "utf8");
+  if (buf.length <= MAX_TEXT) return { text, truncated: false };
+  return { text: buf.subarray(0, MAX_TEXT).toString("utf8").replace(/�+$/, ""), truncated: true };
+}
+function clipInput(input) {
+  if (!input || typeof input !== "object") return input ?? null;
+  const out = Array.isArray(input) ? [] : {};
+  for (const [k, v] of Object.entries(input)) out[k] = typeof v === "string" ? clip(v).text : v;
+  return out;
+}
+function resultText(response) {
+  if (response == null) return "";
+  if (typeof response === "string") return response;
+  if (typeof response.stdout === "string" || typeof response.stderr === "string") {
+    return [response.stdout, response.stderr].filter(Boolean).join("\n");
+  }
+  return JSON.stringify(response, null, 2);
+}
+function titleOf(prompt) {
+  const line = prompt.trim().split("\n")[0].trim();
+  return line.length > MAX_TITLE ? `${line.slice(0, MAX_TITLE - 1)}\u2026` : line;
+}
+var AgentSession = class {
+  constructor({ id, agent, cwd, terminal, now }) {
+    this.id = id;
+    this.agent = agent;
+    this.cwd = cwd;
+    this.title = path2.basename(cwd || "") || "Session";
+    this.capabilities = (ADAPTERS[agent] ?? ADAPTERS.claude).capabilities;
+    this.titled = false;
+    this.state = "idle";
+    this.terminal = terminal;
+    this.startedAt = now;
+    this.lastActivityAt = now;
+    this.endedAt = null;
+    this.starting = false;
+    this.error = null;
+    this.turnStartedAt = null;
+    this.entries = [];
+    this.seq = 0;
+    this.streaming = /* @__PURE__ */ new Map();
+    this.requests = /* @__PURE__ */ new Map();
+    this.prompts = [];
+    this.tail = null;
+    this.ready = Promise.resolve();
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      agent: this.agent,
+      cwd: this.cwd,
+      title: this.title,
+      state: this.state,
+      terminal: this.terminal,
+      startedAt: this.startedAt,
+      lastActivityAt: this.lastActivityAt,
+      pending: this.requests.size,
+      starting: this.starting,
+      error: this.error,
+      capabilities: this.capabilities
+    };
+  }
+};
+var AgentHub = class extends EventEmitter {
+  #sessions = /* @__PURE__ */ new Map();
+  #requests = /* @__PURE__ */ new Map();
+  #now;
+  #requestTtl;
+  #transcript;
+  #startTimeout;
+  #sequentialTtl;
+  #rolloutTail;
+  /**
+   * `present` says whether someone is at the computer or looking at it in a client; agents whose
+   * approvals are sequential ask there instead of holding the request for the phone.
+   */
+  constructor({
+    now = Date.now,
+    requestTtl = REQUEST_TTL,
+    sequentialTtl = SEQUENTIAL_REQUEST_TTL,
+    transcript = readTranscript,
+    startTimeout = START_TIMEOUT,
+    present = async () => false,
+    rolloutTail = (file, onItem) => new RolloutTail(file, onItem)
+  } = {}) {
+    super();
+    this.#now = now;
+    this.#requestTtl = requestTtl;
+    this.#sequentialTtl = sequentialTtl;
+    this.#transcript = transcript;
+    this.#startTimeout = startTimeout;
+    this.present = present;
+    this.#rolloutTail = rolloutTail;
+    this.presenceSet = arguments[0]?.present !== void 0;
+  }
+  /**
+   * A prompt a client typed into a session's terminal. Once Claude Code reports a matching
+   * `UserPromptSubmit`, the socket gets `prompt_confirmed` with this id.
+   */
+  prompted(sessionId, { id, text, paths = [] }) {
+    const s = this.#sessions.get(sessionId);
+    if (!s) return;
+    s.prompts.push({ id, text: comparable(text, paths), at: this.#now() });
+    s.prompts = s.prompts.filter((p) => this.#now() - p.at < 6e4).slice(-20);
+  }
+  /** Whether `resume` may reopen a session: only one no process runs any more. */
+  canResume(id) {
+    const s = this.#sessions.get(id);
+    return !s || s.state === "ended";
+  }
+  /**
+   * A session the agent just started in `terminal` (`id`: the id it passed with --session-id,
+   * or the one it resumes). It shows right away; if Claude Code reports nothing within the
+   * start timeout, it ends with an error.
+   */
+  launched({ id, terminal, cwd, agent = "claude" }) {
+    const now = this.#now();
+    let s = this.#sessions.get(id);
+    if (!s) {
+      s = new AgentSession({ id, agent, cwd, terminal, now });
+      this.#sessions.set(id, s);
+    }
+    const adapter = ADAPTERS[agent] ?? ADAPTERS.claude;
+    const state = adapter.startsOnPrompt ? "idle" : "running";
+    Object.assign(s, { terminal, state, starting: true, error: null, endedAt: null, lastActivityAt: now });
+    if (adapter.startsOnPrompt) {
+      this.#emitSession(s);
+      return s.toJSON();
+    }
+    const timer = setTimeout(() => {
+      if (!s.starting || this.#sessions.get(id) !== s) return;
+      s.starting = false;
+      s.error = `${adapter.name} didn't report back. If it runs in the terminal, run \`coderemote setup ${agent}\` once on the computer${adapter.setupHint ?? ""}.`;
+      this.#end(s);
+      this.#emitSession(s);
+    }, this.#startTimeout);
+    timer.unref?.();
+    this.#emitSession(s);
+    return s.toJSON();
+  }
+  sessions() {
+    return [...this.#sessions.values()].map((s) => s.toJSON()).sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+  }
+  requests() {
+    return [...this.#requests.values()].map((r) => r.request);
+  }
+  session(id) {
+    return this.#sessions.get(id)?.toJSON() ?? 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) };
+  }
+  /**
+   * 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 } = {}) {
+    if (!raw || typeof raw.session_id !== "string" || !raw.session_id) {
+      throw new HttpError(400, "hook event without session_id");
+    }
+    if (!Object.hasOwn(ADAPTERS, agent)) throw new HttpError(400, `unknown agent ${agent}`);
+    const event = ADAPTERS[agent].normalize(raw);
+    const now = this.#now();
+    let replaced = null;
+    if (!this.#sessions.has(event.session_id)) {
+      const candidates = [...this.#sessions.values()].filter(
+        (p) => p.starting && (terminal ? p.terminal === terminal : p.agent === agent && p.cwd === event.cwd)
+      );
+      if (candidates.length === 1) {
+        replaced = candidates[0];
+        this.#sessions.delete(replaced.id);
+        terminal ??= replaced.terminal;
+      }
+    }
+    let s = this.#sessions.get(event.session_id);
+    if (!s) {
+      s = new AgentSession({ id: event.session_id, agent, cwd: event.cwd ?? null, terminal, now });
+      this.#sessions.set(s.id, s);
+      const fresh = event.hook_event_name === "SessionStart" && event.source !== "resume";
+      if (!fresh && typeof event.transcript_path === "string") s.ready = this.#backfill(s, event.transcript_path);
+    }
+    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.poll?.().catch(() => {
+      });
+    }
+    if (replaced) {
+      s.prompts.push(...replaced.prompts);
+      this.emit("message", { type: "session_removed", session: replaced.id, replacedBy: s.id });
+    }
+    if (terminal && !s.terminal) s.terminal = terminal;
+    s.starting = false;
+    s.lastActivityAt = now;
+    if (s.state === "ended" && event.hook_event_name !== "SessionEnd") {
+      s.state = "idle";
+      s.endedAt = null;
+    }
+    switch (event.hook_event_name) {
+      case "SessionStart":
+        break;
+      case "UserPromptSubmit": {
+        const text = typeof event.prompt === "string" ? event.prompt : "";
+        if (!s.titled && text.trim()) {
+          s.title = titleOf(text);
+          s.titled = true;
+        }
+        this.#startTurn(s, now);
+        this.#entry(s, { kind: "prompt", text });
+        const said = comparable(text);
+        const i = s.prompts.findIndex((p) => p.text === said || p.text && said.startsWith(p.text));
+        if (i >= 0) {
+          const [prompt] = s.prompts.splice(i, 1);
+          this.emit("message", { type: "prompt_confirmed", session: s.id, prompt: prompt.id });
+        }
+        break;
+      }
+      case "PreToolUse":
+        this.#startTurn(s, now);
+        this.#entry(s, {
+          kind: "tool",
+          toolUseId: event.tool_use_id ?? null,
+          name: event.tool_name,
+          input: clipInput(event.tool_input)
+        });
+        break;
+      case "PostToolUse":
+      case "PostToolUseFailure": {
+        const failed = event.hook_event_name === "PostToolUseFailure";
+        const { text, truncated } = clip(failed ? String(event.error ?? "") : resultText(event.tool_response));
+        this.#entry(s, {
+          kind: "tool_result",
+          toolUseId: event.tool_use_id ?? null,
+          name: event.tool_name,
+          output: text,
+          error: failed,
+          truncated,
+          duration: event.duration_ms ?? null
+        });
+        break;
+      }
+      case "MessageDisplay": {
+        const message = s.streaming.get(event.message_id) ?? { parts: /* @__PURE__ */ new Map(), last: null };
+        s.streaming.set(event.message_id, message);
+        message.parts.set(event.index ?? message.parts.size, event.delta ?? "");
+        if (event.final) message.last = event.index ?? message.parts.size - 1;
+        if (message.last === null || message.parts.size <= message.last) break;
+        s.streaming.delete(event.message_id);
+        const text = [...message.parts.entries()].sort((a, b) => a[0] - b[0]).map(([, d]) => d).join("").trimEnd();
+        const previous = s.entries.at(-1)?.kind === "turn_end" ? s.entries.at(-2) : s.entries.at(-1);
+        if (text.trim() && !(previous?.kind === "assistant" && previous.text.trim() === text.trim())) {
+          this.#entry(s, { kind: "assistant", text });
+        }
+        break;
+      }
+      case "PermissionRequest": {
+        this.#emitSession(s);
+        const sequential = s.capabilities.approvals === "presence";
+        const deferNow = sequential && await this.present().catch(() => false);
+        return this.#openRequest(s, event, signal, { deferNow, ttl: sequential ? this.#sequentialTtl : this.#requestTtl });
+      }
+      case "Stop":
+      case "StopFailure": {
+        const last = typeof event.last_assistant_message === "string" ? event.last_assistant_message.trim() : "";
+        const turnEntries = s.entries.filter((e) => e.time >= (s.turnStartedAt ?? 0));
+        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 });
+        break;
+      }
+      case "Interrupt":
+      case "Notification":
+        if ((event.hook_event_name === "Interrupt" || event.notification_type === "idle_prompt") && s.state === "running") {
+          s.state = "idle";
+          s.turnStartedAt = null;
+        }
+        break;
+      case "SessionEnd":
+        this.#end(s);
+        break;
+      default:
+        break;
+    }
+    this.#emitSession(s);
+    return {};
+  }
+  /** The terminal a session ran in exited: whatever ran in it is over. */
+  terminalExited(terminal) {
+    for (const s of this.#sessions.values()) {
+      if (s.terminal === terminal && s.state !== "ended") {
+        if (s.starting) s.error = `${(ADAPTERS[s.agent] ?? ADAPTERS.claude).name} exited before it started. Open the terminal to see why.`;
+        s.starting = false;
+        this.#end(s);
+        this.#emitSession(s);
+      }
+    }
+  }
+  /**
+   * Drops a session from the list, withdrawing its requests. One still running elsewhere comes
+   * back with its next hook event.
+   */
+  forget(id) {
+    const s = this.#sessions.get(id);
+    if (!s) throw new HttpError(404, "no such session");
+    if (s.state !== "ended") this.#end(s);
+    this.#sessions.delete(id);
+    this.emit("message", { type: "session_removed", session: id, replacedBy: null });
+  }
+  /** Forgets sessions that ended more than a day ago. */
+  sweep() {
+    const cutoff = this.#now() - ENDED_TTL;
+    for (const s of this.#sessions.values()) {
+      if (s.state === "ended" && s.endedAt < cutoff) {
+        s.tail?.stop();
+        this.#sessions.delete(s.id);
+      }
+    }
+  }
+  /**
+   * Answers an open request from a client. Throws 404 for an unknown request and 409 for one
+   * already resolved (by another device, the computer, or the timeout).
+   */
+  answer({ request: id, behavior, message, suggestion, answers } = {}) {
+    const pending = this.#requests.get(id);
+    if (!pending) {
+      throw new HttpError(this.#resolved.has(id) ? 409 : 404, this.#resolved.has(id) ? "already answered" : "no such request");
+    }
+    const { request } = pending;
+    if (behavior !== "allow" && behavior !== "deny") throw new HttpError(400, "behavior must be allow or deny");
+    let decision;
+    let outcome;
+    if (behavior === "deny") {
+      decision = { behavior: "deny", ...typeof message === "string" && message ? { message } : {} };
+      outcome = "denied";
+    } else if (request.kind === "question") {
+      if (!answers || typeof answers !== "object" || Object.values(answers).some((a) => typeof a !== "string")) {
+        throw new HttpError(400, "answers must map each question to a string");
+      }
+      decision = { behavior: "allow", updatedInput: { ...pending.input, answers } };
+      outcome = "answered";
+    } else {
+      decision = { behavior: "allow" };
+      if (suggestion !== void 0) {
+        const rule = Number.isInteger(suggestion) ? request.suggestions[suggestion] : void 0;
+        if (!rule || !pending.session.capabilities.alwaysAllow) {
+          throw new HttpError(400, "suggestion must index the request\u2019s suggestions");
+        }
+        decision.updatedPermissions = [rule];
+      }
+      outcome = "allowed";
+    }
+    this.#resolve(pending, { hookSpecificOutput: { hookEventName: "PermissionRequest", decision } }, outcome, "phone");
+  }
+  // Ids of requests resolved recently, to tell "already answered" (409) from unknown (404).
+  #resolved = /* @__PURE__ */ new Set();
+  #openRequest(s, event, signal, { deferNow = false, ttl = this.#requestTtl } = {}) {
+    const isQuestion = event.tool_name === "AskUserQuestion";
+    const input = event.tool_input ?? {};
+    const request = {
+      id: randomUUID(),
+      session: s.id,
+      kind: isQuestion ? "question" : "permission",
+      tool: event.tool_name ?? null,
+      input: clipInput(input),
+      suggestions: Array.isArray(event.permission_suggestions) ? event.permission_suggestions : [],
+      questions: isQuestion && Array.isArray(input.questions) ? input.questions : [],
+      createdAt: this.#now()
+    };
+    return new Promise((resolve) => {
+      const pending = { request, input, session: s, resolve, timer: null, signal, onAbort: null };
+      pending.timer = setTimeout(() => this.#resolve(pending, null, "expired", "agent"), ttl);
+      pending.timer.unref?.();
+      pending.onAbort = () => this.#resolve(pending, null, "withdrawn", "computer");
+      signal?.addEventListener("abort", pending.onAbort, { once: true });
+      s.requests.set(request.id, pending);
+      this.#requests.set(request.id, pending);
+      s.state = "waiting";
+      this.#entry(s, { kind: "request", request });
+      this.emit("message", { type: "request", request });
+      this.#emitSession(s);
+      if (signal?.aborted) pending.onAbort();
+      else if (deferNow) this.#resolve(pending, null, "deferred", "agent");
+    });
+  }
+  #resolve(pending, output, outcome, by) {
+    const { request, session: s } = pending;
+    if (!this.#requests.delete(request.id)) return;
+    s.requests.delete(request.id);
+    clearTimeout(pending.timer);
+    pending.signal?.removeEventListener("abort", pending.onAbort);
+    this.#resolved.add(request.id);
+    if (this.#resolved.size > 1e3) this.#resolved.delete(this.#resolved.values().next().value);
+    if (s.state === "waiting" && !s.requests.size) s.state = "running";
+    s.lastActivityAt = this.#now();
+    this.#entry(s, { kind: "request_resolved", request: request.id, outcome, by });
+    this.emit("message", { type: "request_resolved", session: s.id, request: request.id, outcome, by });
+    this.#emitSession(s);
+    pending.resolve(output);
+  }
+  async #backfill(s, file) {
+    let entries = [];
+    try {
+      entries = await this.#transcript(file, MAX_ENTRIES);
+    } catch {
+    }
+    const tools = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      if (e.kind === "tool") {
+        tools.set(e.toolUseId, e.name);
+        e.input = clipInput(e.input);
+      } else if (e.kind === "tool_result") {
+        e.name ??= tools.get(e.toolUseId) ?? null;
+        ({ text: e.output, truncated: e.truncated } = clip(e.output));
+      } else if (e.kind === "prompt" && !s.titled && e.text.trim()) {
+        s.title = titleOf(e.text);
+        s.titled = true;
+      }
+      s.entries.push({ seq: ++s.seq, ...e });
+    }
+    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. */
+  #fromRollout(s, item) {
+    const fields = codexItem(item);
+    if (!fields) return;
+    const recent = s.entries.slice(-8);
+    if (fields.kind === "assistant") {
+      if (recent.some((e) => e.kind === "assistant" && e.text.trim() === fields.text)) return;
+      this.#entry(s, fields);
+    } else {
+      if (s.entries.some((e) => e.kind === "tool_result" && e.toolUseId === fields.toolUseId)) return;
+      const call = [...s.entries].reverse().find((e) => e.kind === "tool" && e.toolUseId === fields.toolUseId);
+      if (!call) return;
+      const { text, truncated } = clip(fields.output);
+      this.#entry(s, { kind: "tool_result", toolUseId: fields.toolUseId, name: call.name, output: text, error: fields.error, truncated, duration: null });
+    }
+    s.lastActivityAt = this.#now();
+    this.#emitSession(s);
+  }
+  #startTurn(s, now) {
+    if (s.state !== "waiting") s.state = "running";
+    s.turnStartedAt ??= now;
+  }
+  #end(s) {
+    s.tail?.stop();
+    s.tail = null;
+    for (const pending of [...s.requests.values()]) this.#resolve(pending, null, "withdrawn", "computer");
+    s.state = "ended";
+    s.endedAt = this.#now();
+    s.turnStartedAt = null;
+  }
+  #entry(s, fields) {
+    const entry2 = { seq: ++s.seq, time: this.#now(), ...fields };
+    s.entries.push(entry2);
+    if (s.entries.length > MAX_ENTRIES) s.entries.shift();
+    this.emit("message", { type: "entry", session: s.id, entry: entry2 });
+  }
+  #emitSession(s) {
+    this.emit("message", { type: "session", session: s.toJSON() });
+  }
+};
+
 // ../../packages/agent-core/src/git.js
+import { execFile } from "node:child_process";
+import fs4 from "node:fs/promises";
+import path3 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;
@@ -168,7 +832,7 @@ async function findRepos(root2) {
   async function walk(dir, depth) {
     let entries;
     try {
-      entries = await fs2.readdir(dir, { withFileTypes: true });
+      entries = await fs4.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -178,14 +842,14 @@ async function findRepos(root2) {
     }
     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(path2.join(dir, e.name), depth + 1)));
+    await Promise.all(subdirs.map((e) => walk(path3.join(dir, e.name), depth + 1)));
   }
   await walk(root2, 0);
-  repos.sort((a, b) => a.split(path2.sep).length - b.split(path2.sep).length || a.localeCompare(b));
+  repos.sort((a, b) => a.split(path3.sep).length - b.split(path3.sep).length || a.localeCompare(b));
   return Promise.all(
     repos.map(async (repo) => ({
       path: repo,
-      name: repo === root2 ? path2.basename(root2) : path2.relative(root2, repo),
+      name: repo === root2 ? path3.basename(root2) : path3.relative(root2, repo),
       branch: await currentBranch(repo)
     }))
   );
@@ -389,7 +1053,7 @@ var LANDING_HTML = `<!doctype html>
 
 // ../../packages/agent-core/src/ports.js
 import { execFile as execFile2 } from "node:child_process";
-import fs3 from "node:fs/promises";
+import fs5 from "node:fs/promises";
 import os from "node:os";
 function run(cmd2, args) {
   return new Promise((resolve, reject) => {
@@ -447,7 +1111,7 @@ async function workingDirs(pids) {
   const dirs = /* @__PURE__ */ new Map();
   if (!pids.length) return dirs;
   if (os.platform() === "linux") {
-    await Promise.all(pids.map(async (pid2) => dirs.set(pid2, await fs3.readlink(`/proc/${pid2}/cwd`).catch(() => null))));
+    await Promise.all(pids.map(async (pid2) => dirs.set(pid2, await fs5.readlink(`/proc/${pid2}/cwd`).catch(() => null))));
     return dirs;
   }
   const out = await run("lsof", ["-a", "-p", pids.join(","), "-d", "cwd", "-F", "pn"]).catch(() => "");
@@ -507,11 +1171,228 @@ async function killListener(pid, { force = false, shells } = {}) {
   }
 }
 
+// ../../packages/agent-core/src/push.js
+import { execFile as execFile3 } from "node:child_process";
+import { createCipheriv, randomBytes } from "node:crypto";
+import os2 from "node:os";
+import { promisify } from "node:util";
+var run2 = promisify(execFile3);
+var FINISHED_AFTER = 60 * 1e3;
+var ACTIVE_WITHIN = 2 * 60;
+async function macIdleSeconds() {
+  if (os2.platform() !== "darwin") return null;
+  try {
+    const { stdout } = await run2("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 {
+    return null;
+  }
+}
+async function userActiveHere() {
+  const idle = await macIdleSeconds();
+  return idle !== null && idle < ACTIVE_WITHIN;
+}
+function seal(key, data) {
+  const nonce = randomBytes(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");
+}
+function relayUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return null;
+  }
+  const local = url.protocol === "http:" && (url.hostname === "127.0.0.1" || url.hostname === "localhost");
+  return url.protocol === "https:" || local ? url.href.replace(/\/$/, "") : null;
+}
+function deviceFrom(body) {
+  const relay = relayUrl(body?.relay);
+  if (!relay) throw new HttpError(400, "relay must be an https URL");
+  if (typeof body.token !== "string" || !/^[0-9a-f]{64,200}$/i.test(body.token)) throw new HttpError(400, "token must be an APNs device token (hex)");
+  if (body.environment !== "production" && body.environment !== "development") {
+    throw new HttpError(400, "environment must be production or development");
+  }
+  if (typeof body.ticket !== "string" || !body.ticket || body.ticket.length > 128) throw new HttpError(400, "ticket required");
+  if (typeof body.key !== "string" || Buffer.from(body.key, "base64").length !== 32) throw new HttpError(400, "key must be 32 bytes, base64");
+  if (typeof body.keyId !== "string" || !/^[A-Za-z0-9._-]{1,64}$/.test(body.keyId)) throw new HttpError(400, "keyId required");
+  const kinds = body.kinds ?? {};
+  return {
+    relay,
+    token: body.token.toLowerCase(),
+    environment: body.environment,
+    ticket: body.ticket,
+    key: body.key,
+    keyId: body.keyId,
+    kinds: { requests: kinds.requests !== false, finished: kinds.finished !== false }
+  };
+}
+function describeRequest(request) {
+  if (request.kind === "question") return request.questions[0]?.question ?? "Claude has a question";
+  const input = request.input ?? {};
+  const detail2 = input.command ?? input.file_path ?? input.notebook_path ?? input.url ?? input.pattern ?? null;
+  return detail2 ? `${request.tool}: ${String(detail2).split("\n")[0].slice(0, 200)}` : `Allow ${request.tool}?`;
+}
+function minutes(ms) {
+  const m = Math.round(ms / 6e4);
+  return m < 60 ? `${m} min` : `${Math.floor(m / 60)} h ${m % 60} min`;
+}
+var PushSender = class {
+  #devices;
+  #store;
+  #hub;
+  #foreground;
+  #userActive;
+  #fetch;
+  // Requests a notification went out for, so their resolution can replace it.
+  #notified = /* @__PURE__ */ new Set();
+  /**
+   * @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
+   */
+  constructor({ hub, store = null, foreground = () => false, userActive = null, fetch: fetch2 = globalThis.fetch }) {
+    this.#hub = hub;
+    this.#store = store;
+    this.#devices = store?.load() ?? [];
+    this.#foreground = foreground;
+    this.#userActive = userActive ?? userActiveHere;
+    this.#fetch = fetch2;
+    hub.on("message", (msg) => this.#follow(msg).catch(() => {
+    }));
+  }
+  devices() {
+    return this.#devices.map(({ key, ticket, ...rest2 }) => rest2);
+  }
+  register(body) {
+    const device = deviceFrom(body);
+    this.#devices = [...this.#devices.filter((d) => d.token !== device.token), device];
+    this.#save();
+  }
+  unregister(token) {
+    this.#devices = this.#devices.filter((d) => d.token !== String(token).toLowerCase());
+    this.#save();
+  }
+  /** Sends a test notification; throws 404 for an unknown token, 502 when it doesn't go out. */
+  async test(token) {
+    const device = this.#devices.find((d) => d.token === String(token ?? "").toLowerCase());
+    if (!device) throw new HttpError(404, "that device is not registered");
+    const result = await this.#send(device, {
+      kind: "test",
+      title: "Code Remote",
+      body: "Notifications from this computer work.",
+      category: null,
+      fallback: "Notifications work"
+    });
+    if (!result.ok) throw new HttpError(502, `push failed: ${result.reason ?? result.status}`);
+  }
+  #save() {
+    this.#store?.save(this.#devices);
+  }
+  async #quiet() {
+    if (this.#foreground()) return true;
+    try {
+      return await this.#userActive();
+    } catch {
+      return false;
+    }
+  }
+  async #follow(msg) {
+    if (!this.#devices.length) return;
+    if (msg.type === "request") {
+      const { request } = msg;
+      if (await this.#quiet()) return;
+      if (!this.#hub.requests().some((r) => r.id === request.id)) return;
+      this.#notified.add(request.id);
+      const question = request.kind === "question";
+      const answerable = question && request.questions.length === 1 && !request.questions[0].multiSelect;
+      await this.#broadcast("requests", {
+        kind: "request",
+        title: this.#hub.session(request.session)?.title ?? "Claude Code",
+        body: describeRequest(request),
+        session: request.session,
+        request: request.id,
+        question: answerable ? request.questions[0].question : void 0,
+        options: answerable ? request.questions[0].options.map((o) => o.label) : void 0,
+        category: question ? "QUESTION" : "PERMISSION",
+        collapseId: request.id,
+        fallback: "A session needs your attention"
+      });
+    } else if (msg.type === "request_resolved") {
+      if (!this.#notified.delete(msg.request) || msg.by === "phone") return;
+      await this.#broadcast("requests", {
+        kind: "resolved",
+        title: this.#hub.session(msg.session)?.title ?? "Claude Code",
+        body: msg.outcome === "expired" ? "No longer waiting for an answer" : "Answered on your computer",
+        session: msg.session,
+        request: msg.request,
+        category: null,
+        collapseId: msg.request,
+        priority: 5,
+        silent: true,
+        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;
+      const session = this.#hub.session(msg.session);
+      await this.#broadcast("finished", {
+        kind: "finished",
+        title: session?.title ?? "Claude Code",
+        body: `Finished after ${minutes(msg.entry.duration)}`,
+        session: msg.session,
+        category: "DONE",
+        fallback: "A session finished"
+      });
+    }
+  }
+  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 };
+    const aps = { alert: { title: "Code Remote", body: fallback }, "mutable-content": 1 };
+    if (category) aps.category = category;
+    if (session) aps["thread-id"] = session;
+    if (!silent) aps.sound = "default";
+    const payload = { aps, k: device.keyId, e: seal(Buffer.from(device.key, "base64"), secret) };
+    let res;
+    try {
+      res = await this.#fetch(`${device.relay}/v1/send`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          token: device.token,
+          environment: device.environment,
+          ticket: device.ticket,
+          payload,
+          ...collapseId ? { collapseId } : {},
+          ...priority ? { priority } : {}
+        }),
+        signal: AbortSignal.timeout(1e4)
+      });
+    } catch (e) {
+      return { ok: false, status: 0, reason: e.message };
+    }
+    let reason = null;
+    try {
+      reason = (await res.json()).reason ?? null;
+    } catch {
+    }
+    if (res.status === 410 || res.status === 400 && reason === "BadDeviceToken") this.unregister(device.token);
+    return { ok: res.ok, status: res.status, reason };
+  }
+};
+
 // ../../packages/agent-core/src/inspector.js
 import http from "node:http";
 import net from "node:net";
 import zlib from "node:zlib";
-var MAX_ENTRIES = 200;
+var MAX_ENTRIES2 = 200;
 var MAX_BODY = 64 * 1024;
 var TEXTUAL = /^(text\/|application\/(json|xml|javascript|x-www-form-urlencoded|graphql|[\w.+-]+\+(json|xml)))/i;
 var nextId = 1;
@@ -590,7 +1471,7 @@ var InspectingProxy = class {
       response: { headers: {}, tap: new BodyTap() }
     };
     this.#entries.push(entry2);
-    if (this.#entries.length > MAX_ENTRIES) this.#entries.shift();
+    if (this.#entries.length > MAX_ENTRIES2) this.#entries.shift();
     return entry2;
   }
   /** The dev server sees itself addressed as localhost:<its port>, as without the proxy. */
@@ -687,26 +1568,36 @@ function detail(e) {
 }
 
 // ../../packages/agent-core/src/sessions.js
-import { randomUUID } from "node:crypto";
-import os2 from "node:os";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import os3 from "node:os";
 import pty from "node-pty";
 var SCROLLBACK_LIMIT = 256 * 1024;
+function shellQuote(arg) {
+  return `'${String(arg).replace(/'/g, `'\\''`)}'`;
+}
 var TerminalSession = class {
-  constructor({ cols, rows, cwd }) {
-    this.id = randomUUID();
+  /**
+   * `command` (an argv array) runs that program through a login shell (for the user's PATH)
+   * instead of an interactive shell; the session ends when it exits.
+   */
+  constructor({ cols, rows, cwd, env = {}, command = null }) {
+    this.id = randomUUID2();
     this.createdAt = Date.now();
     this.chunks = [];
     this.bufferedBytes = 0;
     this.clients = /* @__PURE__ */ new Set();
     this.exitCode = null;
-    const shell = process.env.SHELL || (os2.platform() === "win32" ? "powershell.exe" : "/bin/sh");
+    const shell = process.env.SHELL || (os3.platform() === "win32" ? "powershell.exe" : "/bin/sh");
     this.shell = shell;
-    this.pty = pty.spawn(shell, ["-l"], {
+    this.command = command;
+    const args = command ? ["-l", "-c", `exec ${command.map(shellQuote).join(" ")}`] : ["-l"];
+    this.pty = pty.spawn(shell, args, {
       name: "xterm-256color",
       cols,
       rows,
-      cwd: cwd || os2.homedir(),
-      env: { ...process.env, TERM: "xterm-256color", COLORTERM: "truecolor" }
+      cwd: cwd || os3.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" }
     });
     this.pty.onData((data) => this.#output(Buffer.from(data, "utf8")));
     this.pty.onExit(({ exitCode }) => {
@@ -752,8 +1643,12 @@ var TerminalSession = class {
       this.pty.resize(cols, rows);
     }
   }
-  kill() {
-    this.pty.kill();
+  kill(signal) {
+    this.pty.kill(signal);
+  }
+  /** Types into the session, as a client's keyboard would. */
+  write(data) {
+    this.pty.write(data);
   }
   toJSON() {
     return {
@@ -768,9 +1663,16 @@ var TerminalSession = class {
 };
 var SessionManager = class {
   #sessions = /* @__PURE__ */ new Map();
+  /** @param {{ onExit?: (id: string) => void }} [opts] */
+  constructor({ onExit } = {}) {
+    this.onExit = onExit;
+  }
   create(opts) {
     const session = new TerminalSession(opts);
-    session.onExit = () => this.#sessions.delete(session.id);
+    session.onExit = () => {
+      this.#sessions.delete(session.id);
+      this.onExit?.(session.id);
+    };
     this.#sessions.set(session.id, session);
     return session;
   }
@@ -785,6 +1687,110 @@ var SessionManager = class {
   }
 };
 
+// ../../packages/agent-core/src/uploads.js
+import { execFile as execFile4 } from "node:child_process";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import fs6 from "node:fs/promises";
+import os4 from "node:os";
+import path4 from "node:path";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { promisify as promisify2 } from "node:util";
+var run3 = promisify2(execFile4);
+var UPLOAD_LIMIT = 100 * 1024 * 1024;
+var KEEP = 7 * 24 * 60 * 60 * 1e3;
+var ID = /^[0-9a-f-]{36}$/;
+function safeName(name) {
+  const base = path4.basename(String(name ?? "").replace(/\\/g, "/"));
+  const clean = base.replace(/[^\p{L}\p{N}._ -]/gu, "_").replace(/^[.\s]+/, "").slice(-80).trim();
+  return clean || "file";
+}
+var UploadStore = class {
+  constructor(dir, { now = Date.now } = {}) {
+    this.dir = dir;
+    this.now = now;
+  }
+  /** 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 day = new Date(this.now()).toISOString().slice(0, 10);
+    await fs6.mkdir(path4.join(this.dir, day), { recursive: true, mode: 448 });
+    let file = path4.join(this.dir, day, `${id}-${safeName(name)}`);
+    let size = 0;
+    const counter = new Transform({
+      transform(chunk, _enc, done) {
+        size += chunk.length;
+        done(size > limit ? new HttpError(413, `files are limited to ${limit / 1024 / 1024} MB`) : null, chunk);
+      }
+    });
+    try {
+      await pipeline(body, counter, createWriteStream(file, { mode: 384 }));
+    } catch (e) {
+      await fs6.rm(file, { force: true });
+      throw e;
+    }
+    let kind = type || "application/octet-stream";
+    if ((kind === "image/heic" || /\.heic$/i.test(file)) && os4.platform() === "darwin") {
+      const jpeg = file.replace(/(\.heic)?$/i, ".jpg");
+      try {
+        await run3("sips", ["-s", "format", "jpeg", file, "--out", jpeg], { timeout: 3e4 });
+        await fs6.rm(file);
+        file = jpeg;
+        kind = "image/jpeg";
+        size = (await fs6.stat(file)).size;
+      } catch {
+      }
+    }
+    return { id, name: path4.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 fs6.readdir(this.dir)).sort().reverse();
+    } catch {
+    }
+    for (const day of days) {
+      let names = [];
+      try {
+        names = await fs6.readdir(path4.join(this.dir, day));
+      } catch {
+      }
+      const hit = names.find((n) => n.startsWith(`${id}-`));
+      if (hit) return path4.join(this.dir, day, hit);
+    }
+    throw new HttpError(404, "no such upload (they are kept for 7 days)");
+  }
+  /** Deletes uploads older than a week. */
+  async sweep() {
+    let days = [];
+    try {
+      days = await fs6.readdir(this.dir);
+    } catch {
+      return;
+    }
+    const cutoff = this.now() - KEEP;
+    for (const day of days) {
+      const dir = path4.join(this.dir, day);
+      let names = [];
+      try {
+        names = await fs6.readdir(dir);
+      } catch {
+        continue;
+      }
+      for (const n of names) {
+        const file = path4.join(dir, n);
+        const stat = await fs6.stat(file).catch(() => null);
+        if (stat && stat.mtimeMs < cutoff) await fs6.rm(file, { force: true });
+      }
+      if (!(await fs6.readdir(dir).catch(() => [])).length) await fs6.rm(dir, { recursive: true, force: true });
+    }
+  }
+};
+
 // ../../packages/agent-core/src/server.js
 function kindOf(stat) {
   if (stat.isDirectory()) return "dir";
@@ -793,17 +1799,25 @@ function kindOf(stat) {
   return "other";
 }
 async function describe(fullPath, name) {
-  const lst = await fs4.lstat(fullPath);
+  const lst = await fs7.lstat(fullPath);
   const entry2 = { name, type: kindOf(lst), size: lst.size, mtime: lst.mtimeMs };
   if (lst.isSymbolicLink()) {
     try {
-      entry2.target = kindOf(await fs4.stat(fullPath));
+      entry2.target = kindOf(await fs7.stat(fullPath));
     } catch {
       entry2.target = "broken";
     }
   }
   return entry2;
 }
+var PASTE_START = "\x1B[200~";
+var PASTE_END = "\x1B[201~";
+var KEYS = { interrupt: "\x1B", cycle_mode: "\x1B[Z" };
+var COMMANDS = ["/compact", "/clear", "/model"];
+function typeable(text) {
+  return text.replace(/\r\n?/g, "\n").replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
+}
+var LAUNCH_MODES = ["manual", "acceptEdits", "plan", "auto"];
 function sendJson(res, status2, body) {
   const json = JSON.stringify(body);
   res.writeHead(status2, { "content-type": "application/json", "content-length": Buffer.byteLength(json) });
@@ -818,15 +1832,150 @@ async function readJson(req) {
     throw new HttpError(400, "invalid json");
   }
 }
-function createAgentServer({ token, root: root2, tunnelToken = async () => null, preview = null, tunnelStatus: tunnelStatus2 = null }) {
+function createAgentServer({
+  token,
+  root: root2,
+  tunnelToken = async () => null,
+  preview = null,
+  tunnelStatus: tunnelStatus2 = null,
+  hookSecret = null,
+  hookBin = null,
+  uploadsDir = null,
+  claudeCommand = "claude",
+  codexCommand = "codex",
+  codexHome = process.env.CODEX_HOME || path5.join(os5.homedir(), ".codex"),
+  pluginInstalled = null,
+  agents = new AgentHub(),
+  pushStore: pushStore2 = null,
+  pushOptions = {}
+}) {
   const handoff = new TunnelHandoff({ token, mint: tunnelToken });
   const sandbox = new Sandbox(root2);
-  const sessions = new SessionManager();
+  const sessions = new SessionManager({ onExit: (id) => agents.terminalExited(id) });
   const expected = Buffer.from(`Bearer ${token}`);
+  const uploads = uploadsDir ? new UploadStore(uploadsDir) : null;
+  const sweep = setInterval(() => {
+    agents.sweep();
+    uploads?.sweep().catch(() => {
+    });
+  }, 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 });
+  if (!agents.presenceSet) {
+    agents.present = async () => !clientInForeground() && await (pushOptions.userActive ?? userActiveHere)();
+  }
   function authorized(req) {
     const got = Buffer.from(req.headers.authorization || "");
     return got.length === expected.length && timingSafeEqual2(got, expected);
   }
+  function terminalEnv() {
+    return {
+      CODEREMOTE_AGENT_PORT: String(server.address()?.port ?? ""),
+      ...hookBin ? { CODEREMOTE_HOOK_BIN: hookBin } : {}
+    };
+  }
+  function typingTarget(id, { whileWaiting }) {
+    const session = typeof id === "string" ? agents.session(id) : null;
+    if (!session) throw new HttpError(404, "no such session");
+    const term = session.terminal && session.state !== "ended" ? sessions.get(session.terminal) : null;
+    if (!term) throw new HttpError(409, "this session runs outside Code Remote; it can be followed but not typed into");
+    if (!whileWaiting && session.state === "waiting") throw new HttpError(409, "answer the pending request first");
+    return { session, term };
+  }
+  async function typeInto(term, text) {
+    term.write(`${PASTE_START}${text}${PASTE_END}`);
+    await new Promise((r) => setTimeout(r, 300));
+    term.write("\r");
+  }
+  function uploadPath(id) {
+    if (!uploads) throw new HttpError(400, "this agent takes no uploads");
+    return uploads.path(id);
+  }
+  async function attachmentPaths(ids) {
+    if (ids === void 0) return [];
+    if (!Array.isArray(ids) || ids.some((a) => typeof a !== "string")) throw new HttpError(400, "attachments must be upload ids");
+    return Promise.all(ids.map((a) => uploadPath(a)));
+  }
+  function loginShell(script) {
+    const shell = process.env.SHELL || "/bin/sh";
+    return new Promise((resolve) => {
+      execFile5(
+        shell,
+        ["-l", "-c", script],
+        { timeout: 2e4, maxBuffer: 16 * 1024 * 1024 },
+        (err, out) => resolve(err ? null : out)
+      );
+    });
+  }
+  const launchers = {
+    claude: {
+      command: claudeCommand,
+      name: "Claude Code",
+      args: ({ id, resume, model, permissionMode }) => [
+        ...resume ? ["--resume", resume] : ["--session-id", id],
+        ...model ? ["--model", model] : [],
+        ...permissionMode ? ["--permission-mode", permissionMode] : [],
+        ...uploadsDir ? ["--add-dir", uploadsDir] : []
+      ],
+      // Fullscreen rendering can fail to start while no client is attached to answer the
+      // terminal's queries; the classic renderer doesn't need them.
+      env: { CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN: "1" },
+      async plugin() {
+        const list = JSON.parse(await loginShell(`${shellQuote(claudeCommand)} plugin list --json`) ?? "[]");
+        return list.some((p) => p.id === "coderemote@coderemote" && p.enabled !== false);
+      },
+      missingPlugin: "Claude Code needs the Code Remote plugin first: run `coderemote setup claude` once on the computer."
+    },
+    codex: {
+      command: codexCommand,
+      name: "Codex",
+      // Codex's sandbox reads anywhere already; --add-dir would make the uploads writable.
+      // Without -a, recent Codex rejects every escalation outright ("granular" policy), so a
+      // session started here asks, and its requests reach the phone or the terminal.
+      args: ({ resume, model, approvalPolicy }) => [
+        ...resume ? ["resume", resume] : [],
+        ...model ? ["-m", model] : [],
+        ...approvalPolicy ? ["-a", approvalPolicy] : []
+      ],
+      env: {},
+      async plugin() {
+        const list = JSON.parse(await loginShell(`${shellQuote(codexCommand)} plugin list --marketplace coderemote --json`) ?? "{}");
+        return (list.installed ?? []).some((p) => p.pluginId === "coderemote@coderemote" && p.enabled !== false);
+      },
+      missingPlugin: "Codex needs the Code Remote plugin first: run `coderemote setup codex` once on the computer, then trust its hooks with `/hooks` in Codex."
+    }
+  };
+  async function installed(agent) {
+    return Boolean((await loginShell(`command -v ${shellQuote(launchers[agent].command)}`))?.trim());
+  }
+  const plugins = {};
+  async function hasPlugin(agent) {
+    const known = plugins[agent];
+    if (known && Date.now() - known.checkedAt < 3e4) return known.installed;
+    let found = false;
+    try {
+      found = pluginInstalled ? await pluginInstalled(agent) : await launchers[agent].plugin();
+    } catch {
+    }
+    plugins[agent] = { installed: found, checkedAt: Date.now() };
+    return found;
+  }
+  async function codexModels() {
+    try {
+      const { models } = JSON.parse(await fs7.readFile(path5.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 [];
+    }
+  }
+  function hookAuthorized(req) {
+    if (!hookSecret) return false;
+    const got = Buffer.from(String(req.headers[HOOK_SECRET_HEADER] || ""));
+    const want = Buffer.from(hookSecret);
+    return got.length === want.length && timingSafeEqual2(got, want);
+  }
   function previewPort(value, ownPort) {
     if (!preview) throw new HttpError(404, "previews need a tunnel");
     const port2 = Number(value);
@@ -865,20 +2014,20 @@ function createAgentServer({ token, root: root2, tunnelToken = async () => null,
   async function repoOf(p) {
     const repo = await sandbox.resolve(p);
     try {
-      await fs4.access(path3.join(repo, ".git"));
+      await fs7.access(path5.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 || path3.isAbsolute(f))) {
+    if (!Array.isArray(files) || !files.length || files.some((f) => typeof f !== "string" || !f || path5.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(path3.join(repo, f), { allowMissing: true });
-        const rel = path3.relative(repo, abs);
+        const abs = await sandbox.resolve(path5.join(repo, f), { allowMissing: true });
+        const rel = path5.relative(repo, abs);
         if (!rel || rel.startsWith("..")) throw new HttpError(403, "path is outside the repository");
         return rel;
       })
@@ -887,52 +2036,52 @@ function createAgentServer({ token, root: root2, tunnelToken = async () => null,
   const routes = {
     [Routes.info]: async () => ({
       protocol: PROTOCOL_VERSION,
-      hostname: os3.hostname(),
-      platform: os3.platform(),
+      hostname: os5.hostname(),
+      platform: os5.platform(),
       root: sandbox.root,
-      user: os3.userInfo().username,
+      user: os5.userInfo().username,
       shell: process.env.SHELL || null
     }),
     [Routes.fsList]: async (url) => {
       const dir = await sandbox.resolve(url.searchParams.get("path"));
-      const names = await fs4.readdir(dir);
-      const entries = (await Promise.all(names.map((n) => describe(path3.join(dir, n), n).catch(() => null)))).filter(Boolean);
+      const names = await fs7.readdir(dir);
+      const entries = (await Promise.all(names.map((n) => describe(path5.join(dir, n), n).catch(() => null)))).filter(Boolean);
       return { path: dir, entries };
     },
     [Routes.fsStat]: async (url) => {
       const p = await sandbox.resolve(url.searchParams.get("path"));
-      return { path: p, ...await describe(p, path3.basename(p)) };
+      return { path: p, ...await describe(p, path5.basename(p)) };
     },
     [Routes.fsRead]: async (url, req, res) => {
       const p = await sandbox.resolve(url.searchParams.get("path"));
-      const stat = await fs4.stat(p);
+      const stat = await fs7.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 pipeline(createReadStream(p), res);
+      await pipeline2(createReadStream(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 pipeline(req, createWriteStream(tmp));
-        await fs4.rename(tmp, p);
+        await pipeline2(req, createWriteStream2(tmp));
+        await fs7.rename(tmp, p);
       } catch (e) {
-        await fs4.rm(tmp, { force: true });
+        await fs7.rm(tmp, { force: true });
         throw e;
       }
-      return describe(p, path3.basename(p));
+      return describe(p, path5.basename(p));
     },
     [Routes.fsMkdir]: async (url) => {
-      await fs4.mkdir(await sandbox.resolve(url.searchParams.get("path"), { allowMissing: true }), { recursive: true });
+      await fs7.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 fs4.rename(await sandbox.resolveChild(from), await sandbox.resolveChild(to, { allowMissing: true }));
+      await fs7.rename(await sandbox.resolveChild(from), await sandbox.resolveChild(to, { allowMissing: true }));
       return {};
     },
     [Routes.fsDelete]: async (url) => {
-      await fs4.rm(await sandbox.resolveChild(url.searchParams.get("path")), { recursive: true });
+      await fs7.rm(await sandbox.resolveChild(url.searchParams.get("path")), { recursive: true });
       return {};
     },
     [Routes.gitRepos]: async () => ({ repos: await findRepos(sandbox.root) }),
@@ -1047,6 +2196,146 @@ function createAgentServer({ token, root: root2, tunnelToken = async () => null,
       if (!issued) throw new HttpError(404, "this tunnel is anonymous");
       return issued;
     },
+    [Routes.agentsSessions]: async () => ({ sessions: agents.sessions() }),
+    [Routes.agentsTimeline]: async (url) => agents.timeline(url.searchParams.get("session"), parseInt(url.searchParams.get("after"), 10) || 0),
+    [Routes.agentsSetup]: async () => {
+      const [claude, codex] = await Promise.all([installed("claude"), installed("codex")]);
+      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.agentsLaunch]: async (url, req) => {
+      const { agent = "claude", cwd, model, permissionMode, approvalPolicy, resume, cols, rows } = await readJson(req);
+      if (approvalPolicy !== void 0 && !["on-request", "never"].includes(approvalPolicy)) {
+        throw new HttpError(400, "approvalPolicy must be on-request or never");
+      }
+      if (!Object.hasOwn(launchers, agent)) throw new HttpError(400, `agent must be one of ${Object.keys(launchers).join(", ")}`);
+      const launcher = launchers[agent];
+      let dir;
+      try {
+        dir = await sandbox.resolve(cwd || sandbox.root);
+      } catch (e) {
+        throw new HttpError(400, e.message);
+      }
+      if (!(await fs7.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");
+      }
+      if (permissionMode !== void 0 && !LAUNCH_MODES.includes(permissionMode)) {
+        throw new HttpError(400, `permissionMode must be one of ${LAUNCH_MODES.join(", ")}`);
+      }
+      if (resume !== void 0 && (typeof resume !== "string" || !/^[0-9a-f-]{8,64}$/i.test(resume))) {
+        throw new HttpError(400, "resume must be a session id");
+      }
+      if (resume && !agents.canResume(resume)) {
+        throw new HttpError(409, "that session is still open; continue it where it runs, or end it first");
+      }
+      if (!await installed(agent)) {
+        throw Object.assign(new HttpError(400, `${launcher.name} is not installed on this computer (no \`${launcher.command}\` command).`), {
+          code: agent === "claude" ? "ENOCLAUDE" : "ENOAGENT"
+        });
+      }
+      if (!await hasPlugin(agent)) {
+        throw Object.assign(new HttpError(400, launcher.missingPlugin), { code: "ENOPLUGIN" });
+      }
+      const id = resume ?? randomUUID4();
+      if (uploadsDir) await fs7.mkdir(uploadsDir, { recursive: true, mode: 448 });
+      const argv2 = [
+        launcher.command,
+        ...launcher.args({
+          id,
+          resume,
+          model,
+          permissionMode: agent === "claude" ? permissionMode : void 0,
+          approvalPolicy: agent === "codex" ? approvalPolicy ?? "on-request" : void 0
+        })
+      ];
+      const term = sessions.create({
+        cols: Number.isInteger(cols) && cols > 0 ? cols : 80,
+        rows: Number.isInteger(rows) && rows > 0 ? rows : 24,
+        cwd: dir,
+        env: { ...terminalEnv(), ...launcher.env },
+        command: argv2
+      });
+      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);
+      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();
+      agents.prompted(id, { id: prompt, text: typed, paths });
+      await typeInto(term, typed);
+      return { prompt };
+    },
+    [Routes.agentsUpload]: async (url, req) => {
+      if (!uploads) throw new HttpError(404, "this agent takes no uploads");
+      let name = req.headers["x-filename"];
+      try {
+        name = decodeURIComponent(name ?? "");
+      } catch {
+      }
+      const { id, name: saved, type, size } = await uploads.save(req, {
+        name,
+        type: req.headers["content-type"],
+        length: req.headers["content-length"]
+      });
+      return { id, name: saved, type, size };
+    },
+    [Routes.agentsKeys]: async (url, req) => {
+      const { session: id, action, command } = await readJson(req);
+      const allowed = agents.session(typeof id === "string" ? id : "")?.capabilities?.keys;
+      if (allowed && !allowed.includes(action === "command" ? command : 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);
+      } else if (Object.hasOwn(KEYS, action)) {
+        typingTarget(id, { whileWaiting: true }).term.write(KEYS[action]);
+      } 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 { term } = typingTarget(id, { whileWaiting: true });
+      term.kill();
+      setTimeout(() => {
+        if (term.exitCode === null) term.kill("SIGKILL");
+      }, 3e3).unref();
+      return {};
+    },
+    [Routes.agentsForget]: async (url, req) => {
+      const { session: id } = await readJson(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)) {
+        throw new HttpError(409, "this session still runs here; stop it first");
+      }
+      agents.forget(id);
+      return {};
+    },
+    [Routes.agentsAnswer]: async (url, req) => {
+      agents.answer(await readJson(req));
+      return {};
+    },
+    [Routes.pushDeviceSet]: async (url, req) => {
+      push2.register(await readJson(req));
+      return {};
+    },
+    [Routes.pushDeviceDelete]: async (url) => {
+      push2.unregister(url.searchParams.get("token") ?? "");
+      return {};
+    },
+    [Routes.pushTest]: async (url, req) => {
+      await push2.test((await readJson(req)).token);
+      return {};
+    },
     [Routes.termKill]: async (url) => {
       const s = sessions.get(url.searchParams.get("id"));
       if (!s) throw new HttpError(404, "no such session");
@@ -1065,6 +2354,7 @@ function createAgentServer({ token, root: root2, tunnelToken = async () => null,
       return res.end(LANDING_HTML);
     }
     if (req.method === "GET" && url.pathname === TUNNEL_HANDOFF_PATH) return handoffRedirect(url, res);
+    if (`${req.method} ${url.pathname}` === Routes.agentsHook) return hookDelivery(url, req, res);
     if (!authorized(req)) return sendJson(res, 401, { error: "unauthorized" });
     const handler = routes[`${req.method} ${url.pathname}`];
     if (!handler) return sendJson(res, 404, { error: "not found" });
@@ -1077,6 +2367,28 @@ function createAgentServer({ token, root: root2, tunnelToken = async () => null,
       else res.destroy(e);
     }
   });
+  async function hookDelivery(url, req, res) {
+    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 closed = new AbortController();
+    res.on("close", () => {
+      if (!res.writableFinished) closed.abort();
+    });
+    try {
+      const output = await agents.handle(await readJson(req), {
+        agent: url.searchParams.get("agent") || "claude",
+        terminal: terminal && sessions.get(terminal) ? terminal : null,
+        signal: closed.signal
+      });
+      if (res.destroyed) return;
+      if (output) return sendJson(res, 200, output);
+      res.writeHead(200, { "content-length": 0 });
+      res.end();
+    } catch (e) {
+      if (!res.headersSent) sendJson(res, e.status || 500, { error: e.message });
+    }
+  }
   async function handoffRedirect(url, res) {
     const state = url.searchParams.get("state") || "";
     if (!/^[A-Za-z0-9_-]{8,128}$/.test(state) || !handoff.verify(url.searchParams.get("nonce"), url.searchParams.get("sig"))) {
@@ -1099,6 +2411,10 @@ function createAgentServer({ token, root: root2, tunnelToken = async () => null,
   const wss = new WebSocketServer({ noServer: true });
   server.on("upgrade", async (req, socket, head) => {
     const url = new URL(req.url, "http://localhost");
+    if (url.pathname === AGENTS_WS_PATH && authorized(req)) {
+      wss.handleUpgrade(req, socket, head, watchAgents);
+      return;
+    }
     if (url.pathname !== TERMINAL_WS_PATH || !authorized(req)) {
       socket.end("HTTP/1.1 401 Unauthorized\r\n\r\n");
       return;
@@ -1117,7 +2433,8 @@ function createAgentServer({ token, root: root2, tunnelToken = async () => null,
           cols: parseInt(url.searchParams.get("cols"), 10) || 80,
           rows: parseInt(url.searchParams.get("rows"), 10) || 24,
           // New shells start in the shared folder unless a subfolder is asked for.
-          cwd: await sandbox.resolve(url.searchParams.get("cwd") || sandbox.root)
+          cwd: await sandbox.resolve(url.searchParams.get("cwd") || sandbox.root),
+          env: terminalEnv()
         });
       } catch (e) {
         socket.end(`HTTP/1.1 ${e.status || (e.code === "ENOENT" ? 404 : 500)} Error\r
@@ -1128,21 +2445,42 @@ function createAgentServer({ token, root: root2, tunnelToken = async () => null,
     }
     wss.handleUpgrade(req, socket, head, (ws) => session.attach(ws));
   });
+  function watchAgents(ws) {
+    const send = (msg) => ws.send(JSON.stringify(msg));
+    send({ type: "snapshot", sessions: agents.sessions(), requests: agents.requests() });
+    agents.on("message", send);
+    ws.on("message", (data, isBinary) => {
+      if (isBinary) return;
+      let msg;
+      try {
+        msg = JSON.parse(data.toString("utf8"));
+      } catch {
+        return;
+      }
+      if (msg.type === AgentsClientMessage.presence) foregroundAt = msg.foreground === true ? Date.now() : 0;
+    });
+    ws.on("close", () => agents.off("message", send));
+  }
   server.on("close", () => {
+    clearInterval(sweep);
     sessions.killAll();
     for (const proxy of proxies.values()) proxy.close();
   });
   server.killAllSessions = () => sessions.killAll();
+  server.agents = agents;
+  server.clientInForeground = clientInForeground;
+  server.push = push2;
+  server.agentsUploadPath = (id) => uploadPath(id);
   return server;
 }
 
 // src/devtunnel.js
-import { execFile as execFile3 } from "node:child_process";
+import { execFile as execFile6 } from "node:child_process";
 import { createHash } from "node:crypto";
-import fs5 from "node:fs";
-import path4 from "node:path";
-import { promisify } from "node:util";
-var run2 = promisify(execFile3);
+import fs8 from "node:fs";
+import path6 from "node:path";
+import { promisify as promisify3 } from "node:util";
+var run4 = promisify3(execFile6);
 var DOWNLOAD_BASE = "https://tunnelsassetsprod.blob.core.windows.net/cli";
 var BUILDS = {
   "darwin-arm64": "osx-arm64-devtunnel",
@@ -1154,15 +2492,15 @@ var MICROSOFT_TEAM_ID = "UBF8T346G9";
 var REFRESH_INTERVAL_MS = 24 * 36e5;
 function executable(file) {
   try {
-    fs5.accessSync(file, fs5.constants.X_OK);
-    return fs5.statSync(file).isFile();
+    fs8.accessSync(file, fs8.constants.X_OK);
+    return fs8.statSync(file).isFile();
   } catch {
     return false;
   }
 }
 function onPath(name) {
-  for (const dir of (process.env.PATH || "").split(path4.delimiter)) {
-    if (dir && executable(path4.join(dir, name))) return path4.join(dir, name);
+  for (const dir of (process.env.PATH || "").split(path6.delimiter)) {
+    if (dir && executable(path6.join(dir, name))) return path6.join(dir, name);
   }
   return null;
 }
@@ -1180,11 +2518,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 = path4.join(dir, "devtunnel");
-  const metaFile = path4.join(dir, "devtunnel.json");
+  const bin = path6.join(dir, "devtunnel");
+  const metaFile = path6.join(dir, "devtunnel.json");
   let meta = {};
   try {
-    meta = JSON.parse(fs5.readFileSync(metaFile, "utf8"));
+    meta = JSON.parse(fs8.readFileSync(metaFile, "utf8"));
   } catch {
   }
   const installed = executable(bin);
@@ -1195,7 +2533,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) {
-        fs5.writeFileSync(metaFile, JSON.stringify({ ...meta, checkedAt: Date.now() }));
+        fs8.writeFileSync(metaFile, JSON.stringify({ ...meta, checkedAt: Date.now() }));
         return bin;
       }
     } catch {
@@ -1206,12 +2544,12 @@ async function ensureDevtunnel({ dir, progress }) {
   return bin;
 }
 async function download(url, bin, metaFile, progress) {
-  fs5.mkdirSync(path4.dirname(bin), { recursive: true, mode: 448 });
+  fs8.mkdirSync(path6.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 = fs5.createWriteStream(tmp, { mode: 493 });
+  const out = fs8.createWriteStream(tmp, { mode: 493 });
   const md5 = createHash("md5");
   let received = 0;
   try {
@@ -1224,27 +2562,126 @@ 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"));
-    fs5.chmodSync(tmp, 493);
-    fs5.renameSync(tmp, bin);
+    fs8.chmodSync(tmp, 493);
+    fs8.renameSync(tmp, bin);
   } catch (e) {
     out.destroy();
-    fs5.rmSync(tmp, { force: true });
+    fs8.rmSync(tmp, { force: true });
     throw e;
   }
-  fs5.writeFileSync(metaFile, JSON.stringify({ lastModified: res.headers.get("last-modified"), checkedAt: Date.now() }));
+  fs8.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 (process.platform !== "darwin") return;
   try {
-    await run2("codesign", ["--verify", "--strict", file]);
-    const { stderr } = await run2("codesign", ["-dv", file]);
+    await run4("codesign", ["--verify", "--strict", file]);
+    const { stderr } = await run4("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}`);
   }
 }
 
+// src/hook.js
+import { randomBytes as randomBytes2 } from "node:crypto";
+import fs9 from "node:fs";
+import http3 from "node:http";
+import path7 from "node:path";
+var CONNECT_TIMEOUT = 1e3;
+var EVENT_TIMEOUT = 5e3;
+function ensureHookSecret(dir) {
+  const file = path7.join(dir, "hook-secret");
+  try {
+    const secret2 = fs9.readFileSync(file, "utf8").trim();
+    if (secret2) return secret2;
+  } catch {
+  }
+  fs9.mkdirSync(dir, { recursive: true, mode: 448 });
+  const secret = randomBytes2(32).toString("base64url");
+  fs9.writeFileSync(file, secret, { mode: 384 });
+  return secret;
+}
+function writeHookLauncher(dir, { node = process.execPath, script }) {
+  const bin = path7.join(dir, "bin");
+  fs9.mkdirSync(bin, { recursive: true, mode: 448 });
+  const quote = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
+  const file = path7.join(bin, "hook");
+  fs9.writeFileSync(file, `#!/bin/sh
+exec ${quote(node)} ${quote(script)} hook "$@"
+`, { mode: 493 });
+  fs9.chmodSync(file, 493);
+  return file;
+}
+function readHookSecret(dir) {
+  try {
+    return fs9.readFileSync(path7.join(dir, "hook-secret"), "utf8").trim() || null;
+  } catch {
+    return null;
+  }
+}
+function real(p) {
+  try {
+    return fs9.realpathSync(p);
+  } catch {
+    return path7.resolve(p);
+  }
+}
+var within = (dir, root2) => dir === root2 || dir.startsWith(root2.endsWith(path7.sep) ? root2 : root2 + path7.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 };
+  if (typeof cwd !== "string" || !cwd) return null;
+  const dir = real(cwd);
+  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 }) {
+  return new Promise((resolve) => {
+    const query = new URLSearchParams({ agent });
+    if (terminal) query.set("terminal", terminal);
+    const req = http3.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 = () => {
+      req.destroy();
+      resolve("");
+    };
+    const connect = setTimeout(fail, CONNECT_TIMEOUT);
+    const overall = wait ? null : setTimeout(fail, EVENT_TIMEOUT);
+    req.on("socket", (socket) => socket.once("connect", () => clearTimeout(connect)));
+    req.on("error", () => resolve(""));
+    req.on("response", (res) => {
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => {
+        clearTimeout(overall);
+        resolve(res.statusCode === 200 ? Buffer.concat(chunks).toString("utf8") : "");
+      });
+      res.on("error", () => resolve(""));
+    });
+    req.end(body);
+  });
+}
+async function runHook({ input, agents, secret, agent = "claude", env = process.env }) {
+  if (!secret) return "";
+  let event;
+  try {
+    event = JSON.parse(input);
+  } catch {
+    return "";
+  }
+  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 });
+  return wait ? out.trim() : "";
+}
+
 // src/preview.js
 import { spawn } from "node:child_process";
 var HOST_READY_TIMEOUT_MS = 3e4;
@@ -1428,20 +2865,41 @@ ${log2}`));
   }
 };
 
+// src/push-store.js
+import fs10 from "node:fs";
+import path8 from "node:path";
+function pushStore(dir, port2) {
+  const file = path8.join(dir, `${port2}.json`);
+  return {
+    load() {
+      try {
+        const devices = JSON.parse(fs10.readFileSync(file, "utf8"));
+        return Array.isArray(devices) ? devices : [];
+      } catch {
+        return [];
+      }
+    },
+    save(devices) {
+      fs10.mkdirSync(dir, { recursive: true, mode: 448 });
+      fs10.writeFileSync(file, JSON.stringify(devices, null, 2), { mode: 384 });
+    }
+  };
+}
+
 // src/registry.js
-import fs6 from "node:fs";
-import path5 from "node:path";
+import fs11 from "node:fs";
+import path9 from "node:path";
 var AgentRegistry = class {
   constructor(dir) {
     this.dir = dir;
   }
   register({ port: port2, root: root2, url }) {
-    fs6.mkdirSync(this.dir, { recursive: true, mode: 448 });
+    fs11.mkdirSync(this.dir, { recursive: true, mode: 448 });
     const file = this.#file(port2);
-    fs6.writeFileSync(file, JSON.stringify({ pid: process.pid, port: port2, root: root2, url, startedAt: Date.now() }), { mode: 384 });
+    fs11.writeFileSync(file, JSON.stringify({ pid: process.pid, port: port2, root: root2, url, startedAt: Date.now() }), { mode: 384 });
     const cleanup = () => {
       try {
-        if (JSON.parse(fs6.readFileSync(file, "utf8")).pid === process.pid) fs6.rmSync(file);
+        if (JSON.parse(fs11.readFileSync(file, "utf8")).pid === process.pid) fs11.rmSync(file);
       } catch {
       }
     };
@@ -1452,25 +2910,25 @@ var AgentRegistry = class {
   list() {
     let names = [];
     try {
-      names = fs6.readdirSync(this.dir).filter((n) => n.endsWith(".json"));
+      names = fs11.readdirSync(this.dir).filter((n) => n.endsWith(".json"));
     } catch {
       return [];
     }
     const agents = [];
     for (const name of names) {
-      const file = path5.join(this.dir, name);
+      const file = path9.join(this.dir, name);
       try {
-        const agent = JSON.parse(fs6.readFileSync(file, "utf8"));
+        const agent = JSON.parse(fs11.readFileSync(file, "utf8"));
         process.kill(agent.pid, 0);
         agents.push(agent);
       } catch {
-        fs6.rmSync(file, { force: true });
+        fs11.rmSync(file, { force: true });
       }
     }
     return agents.sort((a, b) => a.port - b.port);
   }
   #file(port2) {
-    return path5.join(this.dir, `${port2}.json`);
+    return path9.join(this.dir, `${port2}.json`);
   }
 };
 
@@ -1534,8 +2992,8 @@ function tunnelStatus({ devtunnel: devtunnel2, tunnelId, account, anonymous: ano
 }
 
 // src/update.js
-import fs7 from "node:fs";
-import path6 from "node:path";
+import fs12 from "node:fs";
+import path10 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.-]+))?$/;
@@ -1559,10 +3017,10 @@ async function fetchLatest({ fetch: fetch2 = globalThis.fetch, timeoutMs = 3e3 }
   }
 }
 async function availableUpdate({ current, dir, fetch: fetch2, now = Date.now() }) {
-  const file = path6.join(dir, "update.json");
+  const file = path10.join(dir, "update.json");
   let cache = {};
   try {
-    cache = JSON.parse(fs7.readFileSync(file, "utf8"));
+    cache = JSON.parse(fs12.readFileSync(file, "utf8"));
   } catch {
   }
   let latest = cache.latest;
@@ -1571,8 +3029,8 @@ async function availableUpdate({ current, dir, fetch: fetch2, now = Date.now() }
     if (fetched) {
       latest = fetched;
       try {
-        fs7.mkdirSync(dir, { recursive: true, mode: 448 });
-        fs7.writeFileSync(file, JSON.stringify({ latest, checkedAt: now }));
+        fs12.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs12.writeFileSync(file, JSON.stringify({ latest, checkedAt: now }));
       } catch {
       }
     }
@@ -1580,7 +3038,7 @@ async function availableUpdate({ current, dir, fetch: fetch2, now = Date.now() }
   return isNewer(latest, current) ? latest : null;
 }
 function installCommand(installedAt) {
-  const p = installedAt.split(path6.sep).join("/");
+  const p = installedAt.split(path10.sep).join("/");
   if (p.includes("/pnpm/") || p.includes("/.pnpm/")) return ["pnpm", ["add", "-g", "coderemote@latest"]];
   if (p.includes("/.bun/")) return ["bun", ["add", "-g", "coderemote@latest"]];
   if (p.includes("/.yarn/") || p.includes("/yarn/global/")) return ["yarn", ["global", "add", "coderemote@latest"]];
@@ -1590,7 +3048,7 @@ function installCommand(installedAt) {
 // package.json
 var package_default = {
   name: "coderemote",
-  version: "0.3.2",
+  version: "0.3.5",
   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",
@@ -1869,15 +3327,15 @@ var Spinner = class {
 };
 
 // src/vscode-tunnel.js
-import { execFile as execFile4, spawn as spawn2 } from "node:child_process";
-import { promisify as promisify2 } from "node:util";
-var run3 = promisify2(execFile4);
+import { execFile as execFile7, spawn as spawn2 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
+var run5 = promisify4(execFile7);
 function findCode() {
   return process.env.CODEREMOTE_CODE || onPath("code");
 }
 async function codeTunnelSignedIn(code) {
   try {
-    const { stdout } = await run3(code, ["tunnel", "user", "show"]);
+    const { stdout } = await run5(code, ["tunnel", "user", "show"]);
     return /^logged in/im.test(stdout);
   } catch {
     return false;
@@ -1919,24 +3377,28 @@ ${log2}`));
 }
 
 // bin/coderemote.js
-var run4 = promisify3(execFile5);
-var CONFIG_DIR = path7.join(os4.homedir(), ".coderemote");
-var LEGACY_CONFIG_DIR = path7.join(os4.homedir(), ".vsremote");
-if (!fs8.existsSync(CONFIG_DIR) && fs8.existsSync(LEGACY_CONFIG_DIR)) fs8.renameSync(LEGACY_CONFIG_DIR, CONFIG_DIR);
-var CONFIG_FILE = path7.join(CONFIG_DIR, "config.json");
+var run6 = promisify5(execFile8);
+var CONFIG_DIR = path11.join(os6.homedir(), ".coderemote");
+var LEGACY_CONFIG_DIR = path11.join(os6.homedir(), ".vsremote");
+if (!fs13.existsSync(CONFIG_DIR) && fs13.existsSync(LEGACY_CONFIG_DIR)) fs13.renameSync(LEGACY_CONFIG_DIR, CONFIG_DIR);
+var CONFIG_FILE = path11.join(CONFIG_DIR, "config.json");
+var PUSH_DIR = path11.join(CONFIG_DIR, "push");
+var UPLOADS_DIR = path11.join(CONFIG_DIR, "uploads");
 var DEFAULT_PORT = 31580;
 var VERSION = package_default.version;
-var PACKAGED = path7.basename(path7.dirname(fileURLToPath(import.meta.url))) === "dist";
+var PACKAGED = path11.basename(path11.dirname(fileURLToPath(import.meta.url))) === "dist";
 var spinner = new Spinner();
 function loadConfig() {
   let cfg2 = {};
   try {
-    cfg2 = JSON.parse(fs8.readFileSync(CONFIG_FILE, "utf8"));
+    cfg2 = JSON.parse(fs13.readFileSync(CONFIG_FILE, "utf8"));
   } catch {
   }
   if (!cfg2.token) {
-    cfg2.token = randomBytes(32).toString("base64url");
+    cfg2.token = randomBytes3(32).toString("base64url");
     saveConfig(cfg2);
+    fs13.rmSync(PUSH_DIR, { recursive: true, force: true });
+    fs13.rmSync(UPLOADS_DIR, { recursive: true, force: true });
   }
   if (cfg2.tunnelId && !cfg2.tunnels) {
     cfg2.tunnels = { [DEFAULT_PORT]: cfg2.tunnelId };
@@ -1945,8 +3407,8 @@ function loadConfig() {
   return cfg2;
 }
 function saveConfig(cfg2) {
-  fs8.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
-  fs8.writeFileSync(CONFIG_FILE, JSON.stringify(cfg2, null, 2), { mode: 384 });
+  fs13.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  fs13.writeFileSync(CONFIG_FILE, JSON.stringify(cfg2, null, 2), { mode: 384 });
 }
 function portFree(port2) {
   return new Promise((resolve) => {
@@ -1956,7 +3418,20 @@ function portFree(port2) {
   });
 }
 function listen(token, port2, root2, tunnelToken, preview, status2) {
-  const server = createAgentServer({ token, root: root2, tunnelToken, preview, tunnelStatus: status2 });
+  const hookSecret = ensureHookSecret(CONFIG_DIR);
+  writeHookLauncher(CONFIG_DIR, { script: fs13.realpathSync(process.argv[1]) });
+  const server = createAgentServer({
+    token,
+    root: root2,
+    tunnelToken,
+    preview,
+    tunnelStatus: status2,
+    hookSecret,
+    // This very CLI, so coding agents in the app's terminals report through the same version.
+    hookBin: fs13.realpathSync(process.argv[1]),
+    pushStore: pushStore(PUSH_DIR, port2),
+    uploadsDir: UPLOADS_DIR
+  });
   return new Promise((resolve, reject) => {
     server.once("error", reject);
     server.listen(port2, "127.0.0.1", () => resolve(server));
@@ -1966,7 +3441,7 @@ var DEVTUNNEL = "devtunnel";
 async function resolveDevtunnel() {
   let installing = false;
   DEVTUNNEL = await ensureDevtunnel({
-    dir: path7.join(CONFIG_DIR, "bin"),
+    dir: path11.join(CONFIG_DIR, "bin"),
     progress: (detail2) => {
       if (!installing) {
         installing = true;
@@ -1979,7 +3454,7 @@ async function resolveDevtunnel() {
 }
 async function devtunnel(...args) {
   try {
-    const { stdout } = await run4(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 };
@@ -2037,7 +3512,7 @@ ${access.out}`);
     if (!/not found/i.test(updated.out)) throw new Error(`devtunnel update failed:
 ${updated.out}`);
   }
-  const name = port2 === DEFAULT_PORT ? os4.hostname() : `${os4.hostname()} :${port2}`;
+  const name = port2 === DEFAULT_PORT ? os6.hostname() : `${os6.hostname()} :${port2}`;
   const createArgs = ["create", "--expiration", "30d", "-d", `coderemote ${name}`, "--labels", MACHINE_LABEL, "--json"];
   if (anonymous2) createArgs.push("--allow-anonymous");
   const created = await devtunnel(...createArgs);
@@ -2142,6 +3617,9 @@ var USAGE = `Usage: coderemote <command> [options]
   request <ID> [PORT]  headers and bodies of one request (bodies up to 64 KB are kept);
                        auth headers, cookies and token-like fields are masked unless
                        --show-secrets is given; --json on either for machine-readable output
+  setup claude         let the app follow Claude Code sessions and answer their prompts
+                       (installs the Code Remote plugin into Claude Code); --remove undoes it
+  setup codex          the same for Codex (then trust its hooks once with /hooks in Codex)
   version              print this coderemote's version (also --version, -v)
   login                sign in to Microsoft Dev Tunnels with GitHub (up does this when needed);
                        --microsoft for a Microsoft account, --device-code without a browser
@@ -2163,9 +3641,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 = path7.resolve(flag("--root") ?? process.cwd());
+var root = path11.resolve(flag("--root") ?? process.cwd());
 var cfg = loadConfig();
-var registry = new AgentRegistry(path7.join(CONFIG_DIR, "agents"));
+var registry = new AgentRegistry(path11.join(CONFIG_DIR, "agents"));
 async function start({ tunnel }) {
   const agents = registry.list();
   if (flag("--port")) {
@@ -2200,7 +3678,7 @@ async function start({ tunnel }) {
   const preview = tunnel ? new PreviewTunnel({
     devtunnel,
     command: () => DEVTUNNEL,
-    description: `coderemote preview ${os4.hostname()}`,
+    description: `coderemote preview ${os6.hostname()}`,
     leftover: cfg.previewTunnels?.[port],
     remember: (id) => {
       cfg.previewTunnels = { ...cfg.previewTunnels, [port]: id };
@@ -2263,6 +3741,105 @@ async function start({ tunnel }) {
   });
   return { url, access };
 }
+var PLUGIN = "coderemote@coderemote";
+async function claudeCli(...args) {
+  try {
+    return (await run6("claude", args, { timeout: 12e4 })).stdout.trim();
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw new Error((e.stderr || e.stdout || e.message).trim());
+  }
+}
+async function setupClaude() {
+  const version = await claudeCli("--version");
+  if (version === null) {
+    console.error("Claude Code is required: install it from https://claude.com/claude-code, then run this again.");
+    process.exit(1);
+  }
+  if (rest.includes("--remove")) {
+    await claudeCli("plugin", "uninstall", PLUGIN).catch((e) => console.error(e.message));
+    await claudeCli("plugin", "marketplace", "remove", "coderemote").catch(() => {
+    });
+    console.log("Removed the Code Remote plugin. New Claude Code sessions no longer reach the app.");
+    return;
+  }
+  const source = flag("--marketplace") ?? "CodeRemoteApp/coderemote";
+  spinner.start(`Installing the Code Remote plugin into ${version}`);
+  try {
+    await claudeCli("plugin", "marketplace", "add", source);
+    await claudeCli("plugin", "marketplace", "update", "coderemote").catch(() => {
+    });
+    await claudeCli("plugin", "install", PLUGIN);
+    await claudeCli("plugin", "update", PLUGIN).catch(() => {
+    });
+  } catch (e) {
+    spinner.fail();
+    console.error(e.message);
+    process.exit(1);
+  }
+  spinner.succeed();
+  console.log("\n  New Claude Code sessions in a folder shared with `coderemote up` now show in the");
+  console.log("  app\u2019s Agents tab, where you can answer their permission prompts and questions.");
+  console.log("  Sessions already running pick it up after a restart. Undo: coderemote setup claude --remove\n");
+}
+var CODEX_PLUGIN = "coderemote@coderemote";
+async function codexCli(...args) {
+  try {
+    return (await run6("codex", args, { timeout: 12e4 })).stdout.trim();
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw new Error((e.stderr || e.stdout || e.message).trim());
+  }
+}
+async function setupCodex() {
+  const version = await codexCli("--version");
+  if (version === null) {
+    console.error("Codex is required: install it (npm install -g @openai/codex), then run this again.");
+    process.exit(1);
+  }
+  const hooks = (await codexCli("features", "list")).split("\n").find((line) => /^hooks\s/.test(line));
+  if (!hooks) {
+    console.error(`${version} has no hooks. Update Codex to 0.139 or later (codex update), then run this again.`);
+    process.exit(1);
+  }
+  if (rest.includes("--remove")) {
+    await codexCli("plugin", "remove", CODEX_PLUGIN).catch((e) => console.error(e.message));
+    await codexCli("plugin", "marketplace", "remove", "coderemote").catch(() => {
+    });
+    console.log("Removed the Code Remote plugin. New Codex sessions no longer reach the app.");
+    return;
+  }
+  const given = flag("--marketplace");
+  const source = given ?? "CodeRemoteApp/coderemote";
+  spinner.start(`Installing the Code Remote plugin into ${version}`);
+  try {
+    if (/\bfalse\s*$/.test(hooks)) await codexCli("features", "enable", "hooks");
+    const known = /^coderemote\s/m.test(await codexCli("plugin", "marketplace", "list"));
+    if (known && given) {
+      await codexCli("plugin", "marketplace", "remove", "coderemote").catch(() => {
+      });
+      await codexCli("plugin", "marketplace", "add", source);
+    } else if (known) {
+      await codexCli("plugin", "marketplace", "upgrade", "coderemote").catch(() => {
+      });
+    } else {
+      await codexCli("plugin", "marketplace", "add", source);
+    }
+    await codexCli("plugin", "add", CODEX_PLUGIN);
+  } catch (e) {
+    spinner.fail();
+    console.error(e.message);
+    if (/not found in marketplace/.test(e.message) && !given) {
+      console.error("Your coderemote may be newer than the published plugin; point at a checkout with --marketplace <dir>.");
+    }
+    process.exit(1);
+  }
+  spinner.succeed();
+  console.log("\n  One more step, once: open Codex, type /hooks and trust the Code Remote hooks.");
+  console.log("  Codex runs a plugin's hooks only after you have reviewed them.");
+  console.log("  Then new Codex sessions in a folder shared with `coderemote up` show in the app.");
+  console.log("  Undo: coderemote setup codex --remove\n");
+}
 async function agentApi(agent, method, route, query = {}) {
   const url = new URL(route, `http://127.0.0.1:${agent.port}`);
   for (const [k, v] of Object.entries(query)) url.searchParams.set(k, v);
@@ -2283,7 +3860,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 + path7.sep)).sort((a, b) => b.root.length - a.root.length);
+  const containing = agents.filter((a) => here === a.root || here.startsWith(a.root + path11.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) {
@@ -2307,6 +3884,32 @@ function ago(ms) {
   return `${Math.round(s / 86400)}d`;
 }
 switch (cmd) {
+  case "hook": {
+    let out = "";
+    try {
+      const chunks = [];
+      for await (const c of process.stdin) chunks.push(c);
+      out = await runHook({
+        input: Buffer.concat(chunks).toString("utf8"),
+        agents: registry.list(),
+        secret: readHookSecret(CONFIG_DIR),
+        agent: flag("--agent") ?? "claude"
+      });
+    } catch {
+    }
+    if (out) process.stdout.write(`${out}
+`);
+    process.exit(0);
+  }
+  case "setup": {
+    if (rest[0] === "claude") await setupClaude();
+    else if (rest[0] === "codex") await setupCodex();
+    else {
+      console.error("Usage: coderemote setup claude|codex [--remove]");
+      process.exit(1);
+    }
+    break;
+  }
   case "serve": {
     await start({ tunnel: false });
     console.log(`coderemote agent on http://127.0.0.1:${port}
@@ -2393,7 +3996,7 @@ Token: ${cfg.token}`);
     break;
   }
   case "rotate-token": {
-    cfg.token = randomBytes(32).toString("base64url");
+    cfg.token = randomBytes3(32).toString("base64url");
     saveConfig(cfg);
     const agents = registry.list();
     for (const agent of agents) {
@@ -2422,7 +4025,7 @@ Token: ${cfg.token}`);
       console.log(`coderemote ${VERSION} is the latest version.`);
       break;
     }
-    const [command, args] = installCommand(fs8.realpathSync(process.argv[1]));
+    const [command, args] = installCommand(fs13.realpathSync(process.argv[1]));
     console.log(`Updating coderemote ${VERSION} \u2192 ${latest}: ${command} ${args.join(" ")}
 `);
     const code = await new Promise((resolve) => {