coderemote 0.3.5 → 0.3.6

package/dist/coderemote.js

@@ -1,25 +1,24 @@
 #!/usr/bin/env node
 
 // bin/coderemote.js
-import { execFile as execFile8, spawn as spawn3 } from "node:child_process";
+import { execFile as execFile8, execFileSync, spawn as spawn3 } from "node:child_process";
 import { randomBytes as randomBytes3 } from "node:crypto";
-import fs13 from "node:fs";
+import fs14 from "node:fs";
 import net2 from "node:net";
 import os6 from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 import { fileURLToPath } from "node:url";
-import { promisify as promisify5 } from "node:util";
+import { promisify as promisify4 } from "node:util";
 import qrcode from "qrcode-terminal";
 
 // ../../packages/agent-core/src/server.js
 import { createReadStream, createWriteStream as createWriteStream2 } from "node:fs";
-import fs7 from "node:fs/promises";
+import fs8 from "node:fs/promises";
 import http2 from "node:http";
 import os5 from "node:os";
-import path5 from "node:path";
+import path6 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;
@@ -118,7 +117,7 @@ var HttpError = class extends Error {
 var Sandbox = class {
   constructor(root2) {
     this.root = path.resolve(root2);
-    this.realRoot = fsSync.realpathSync(this.root);
+    this.realRoot = fsSync.realpathSync.native(this.root);
   }
   #containsReal(p) {
     return p === this.realRoot || p.startsWith(this.realRoot + path.sep);
@@ -1052,12 +1051,100 @@ var LANDING_HTML = `<!doctype html>
 `;
 
 // ../../packages/agent-core/src/ports.js
-import { execFile as execFile2 } from "node:child_process";
-import fs5 from "node:fs/promises";
+import { execFile as execFile3 } from "node:child_process";
+import fs6 from "node:fs/promises";
 import os from "node:os";
+
+// ../../packages/agent-core/src/platform.js
+import { execFile as execFile2, spawn } from "node:child_process";
+import fs5 from "node:fs";
+import path4 from "node:path";
+var isWindows = process.platform === "win32";
+function shellQuote(arg) {
+  return `'${String(arg).replace(/'/g, `'\\''`)}'`;
+}
+function runnable(file) {
+  try {
+    if (!isWindows) fs5.accessSync(file, fs5.constants.X_OK);
+    return fs5.statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function findExecutable(name, env = process.env) {
+  const exts = isWindows && !path4.extname(name) ? (env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
+  const match = (base2) => exts.map((e) => base2 + e).find(runnable) ?? null;
+  if (name.includes("/") || name.includes(path4.sep)) return match(path4.resolve(name));
+  for (const dir of (env.PATH ?? env.Path ?? "").split(path4.delimiter)) {
+    const found = dir && match(path4.join(dir.replace(/^"(.*)"$/, "$1"), name));
+    if (found) return found;
+  }
+  return null;
+}
+function interactiveShell() {
+  if (!isWindows) return { file: process.env.SHELL || "/bin/sh", args: ["-l"] };
+  return { file: findExecutable("pwsh") ?? "powershell.exe", args: ["-NoLogo"] };
+}
+function cmdQuote(arg) {
+  const s = String(arg);
+  if (/["%\r\n]/.test(s)) throw new Error(`${JSON.stringify(s)} can't be passed through cmd.exe`);
+  return `"${s.replace(/(\\+)$/, "$1$1")}"`;
+}
+function resolveCommand(argv2) {
+  const [name, ...rest2] = argv2;
+  if (!isWindows) return { file: name, args: rest2, verbatim: false };
+  const file = findExecutable(name) ?? name;
+  if (!/\.(bat|cmd)$/i.test(file)) return { file, args: rest2, verbatim: false };
+  const line = [file, ...rest2].map(cmdQuote).join(" ");
+  return { file: process.env.ComSpec || "cmd.exe", args: ["/d", "/v:off", "/s", "/c", `"${line}"`], verbatim: true };
+}
+function terminalCommand(argv2) {
+  if (!isWindows) return { file: interactiveShell().file, args: ["-l", "-c", `exec ${argv2.map(shellQuote).join(" ")}`] };
+  const { file, args, verbatim } = resolveCommand(argv2);
+  return { file, args: verbatim ? args.join(" ") : args };
+}
+function spawnCommand(argv2, options = {}) {
+  const { file, args, verbatim } = resolveCommand(argv2);
+  return spawn(file, args, { ...options, windowsVerbatimArguments: verbatim });
+}
+function execCommand(argv2, options = {}) {
+  return new Promise((resolve, reject) => {
+    const { file, args, verbatim } = resolveCommand(argv2);
+    execFile2(
+      file,
+      args,
+      { ...options, windowsVerbatimArguments: verbatim },
+      (err, stdout, stderr) => err ? reject(Object.assign(err, { stdout, stderr })) : resolve({ stdout, stderr })
+    );
+  });
+}
+function loginShell(script, timeout) {
+  return new Promise((resolve) => {
+    execFile2(
+      interactiveShell().file,
+      ["-l", "-c", script],
+      { timeout, maxBuffer: 16 * 1024 * 1024 },
+      (err, out) => resolve(err ? null : out)
+    );
+  });
+}
+async function capture(argv2, { timeout = 2e4 } = {}) {
+  if (!isWindows) return loginShell(argv2.map(shellQuote).join(" "), timeout);
+  try {
+    return (await execCommand(argv2, { timeout, maxBuffer: 16 * 1024 * 1024 })).stdout;
+  } catch {
+    return null;
+  }
+}
+async function commandExists(command) {
+  if (isWindows) return findExecutable(command) !== null;
+  return Boolean((await loginShell(`command -v ${shellQuote(command)}`, 2e4))?.trim());
+}
+
+// ../../packages/agent-core/src/ports.js
 function run(cmd2, args) {
   return new Promise((resolve, reject) => {
-    execFile2(cmd2, args, { maxBuffer: 8 * 1024 * 1024 }, (err, stdout) => {
+    execFile3(cmd2, args, { maxBuffer: 8 * 1024 * 1024 }, (err, stdout) => {
       if (err?.code === "ENOENT") reject(err);
       else resolve(stdout || "");
     });
@@ -1109,9 +1196,9 @@ async function processTable() {
 }
 async function workingDirs(pids) {
   const dirs = /* @__PURE__ */ new Map();
-  if (!pids.length) return dirs;
+  if (!pids.length || isWindows) return dirs;
   if (os.platform() === "linux") {
-    await Promise.all(pids.map(async (pid2) => dirs.set(pid2, await fs5.readlink(`/proc/${pid2}/cwd`).catch(() => null))));
+    await Promise.all(pids.map(async (pid2) => dirs.set(pid2, await fs6.readlink(`/proc/${pid2}/cwd`).catch(() => null))));
     return dirs;
   }
   const out = await run("lsof", ["-a", "-p", pids.join(","), "-d", "cwd", "-F", "pn"]).catch(() => "");
@@ -1122,9 +1209,39 @@ async function workingDirs(pids) {
   }
   return dirs;
 }
-var AGENT_COMMAND = /(^|[\/\s])coderemote(\.js)?\s+up(\s|$)/;
+var WINDOWS_SHELLS = /* @__PURE__ */ new Set(["cmd.exe", "powershell.exe", "pwsh.exe", "bash.exe", "wsl.exe", "windowsterminal.exe", "openconsole.exe"]);
+async function windowsListeners() {
+  const query = "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name,CommandLine | ConvertTo-Json -Compress";
+  const [v4, v6, json] = await Promise.all([
+    run("netstat", ["-ano", "-p", "TCP"]),
+    run("netstat", ["-ano", "-p", "TCPv6"]),
+    run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", query])
+  ]);
+  const table = /* @__PURE__ */ new Map();
+  for (const p of [JSON.parse(json || "[]")].flat()) {
+    table.set(p.ProcessId, { ppid: p.ParentProcessId, name: p.Name, tty: null, command: p.CommandLine });
+  }
+  for (const proc of table.values()) {
+    for (let p = proc.ppid, depth = 0; p && depth < 64; p = table.get(p)?.ppid, depth++) {
+      if (WINDOWS_SHELLS.has(table.get(p)?.name?.toLowerCase())) {
+        proc.tty = "console";
+        break;
+      }
+    }
+  }
+  const sockets = [];
+  for (const line of `${v4}
+${v6}`.split(/\r?\n/)) {
+    const m = line.match(/^\s*TCP\s+(\S+)\s+(\S+)\s+\S+\s+(\d+)\s*$/);
+    const hp = m && m[2].endsWith(":0") && splitHostPort(m[1]);
+    const pid = hp && parseInt(m[3], 10);
+    if (hp && table.get(pid)?.command) sockets.push({ pid, name: table.get(pid).name, ...hp });
+  }
+  return [sockets, table];
+}
+var AGENT_COMMAND = /(^|[\/\\\s])coderemote(\.js)?"?\s+up(\s|$)/;
 async function listPorts(shells = /* @__PURE__ */ new Map()) {
-  const [sockets, table] = await Promise.all([listeningSockets(), processTable()]);
+  const [sockets, table] = isWindows ? await windowsListeners() : await Promise.all([listeningSockets(), processTable()]);
   const byKey = /* @__PURE__ */ new Map();
   for (const s of sockets) {
     const key = `${s.pid}:${s.port}`;
@@ -1172,11 +1289,11 @@ async function killListener(pid, { force = false, shells } = {}) {
 }
 
 // ../../packages/agent-core/src/push.js
-import { execFile as execFile3 } from "node:child_process";
+import { execFile as execFile4 } 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 run2 = promisify(execFile4);
 var FINISHED_AFTER = 60 * 1e3;
 var ACTIVE_WITHIN = 2 * 60;
 async function macIdleSeconds() {
@@ -1568,17 +1685,25 @@ function detail(e) {
 }
 
 // ../../packages/agent-core/src/sessions.js
+import { execFile as execFile5 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import os3 from "node:os";
 import pty from "node-pty";
 var SCROLLBACK_LIMIT = 256 * 1024;
-function shellQuote(arg) {
-  return `'${String(arg).replace(/'/g, `'\\''`)}'`;
+function guardConpty(term) {
+  term._agent?._inSocket?.on?.("error", () => {
+  });
+  term._agent?._conoutSocketWorker?._worker?.on?.("error", () => {
+  });
+}
+function releaseConpty(term) {
+  term._agent?._conoutSocketWorker?.dispose?.();
+  term._agent?._inSocket?.destroy?.();
 }
 var TerminalSession = class {
   /**
-   * `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.
+   * `command` (an argv array) runs that program instead of an interactive shell, started as
+   * terminalCommand says; the session ends when it exits.
    */
   constructor({ cols, rows, cwd, env = {}, command = null }) {
     this.id = randomUUID2();
@@ -1587,11 +1712,10 @@ var TerminalSession = class {
     this.bufferedBytes = 0;
     this.clients = /* @__PURE__ */ new Set();
     this.exitCode = null;
-    const shell = process.env.SHELL || (os3.platform() === "win32" ? "powershell.exe" : "/bin/sh");
-    this.shell = shell;
+    const { file, args } = command ? terminalCommand(command) : interactiveShell();
+    this.shell = command ? interactiveShell().file : file;
     this.command = command;
-    const args = command ? ["-l", "-c", `exec ${command.map(shellQuote).join(" ")}`] : ["-l"];
-    this.pty = pty.spawn(shell, args, {
+    this.pty = pty.spawn(file, args, {
       name: "xterm-256color",
       cols,
       rows,
@@ -1599,9 +1723,11 @@ var TerminalSession = class {
       // 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" }
     });
+    if (isWindows) guardConpty(this.pty);
     this.pty.onData((data) => this.#output(Buffer.from(data, "utf8")));
     this.pty.onExit(({ exitCode }) => {
       this.exitCode = exitCode;
+      if (isWindows) releaseConpty(this.pty);
       for (const ws of this.clients) {
         ws.send(JSON.stringify({ type: "exit", code: exitCode }));
         ws.close(1e3, "session exited");
@@ -1624,7 +1750,7 @@ var TerminalSession = class {
     if (replay.length) ws.send(replay, { binary: true });
     ws.on("message", (data, isBinary) => {
       if (isBinary) {
-        this.pty.write(data.toString("utf8"));
+        this.write(data.toString("utf8"));
         return;
       }
       let msg;
@@ -1633,22 +1759,25 @@ var TerminalSession = class {
       } catch {
         return;
       }
-      if (msg.type === "input" && typeof msg.data === "string") this.pty.write(msg.data);
+      if (msg.type === "input" && typeof msg.data === "string") this.write(msg.data);
       else if (msg.type === "resize") this.resize(msg.cols, msg.rows);
     });
     ws.on("close", () => this.clients.delete(ws));
   }
   resize(cols, rows) {
-    if (Number.isInteger(cols) && Number.isInteger(rows) && cols > 0 && rows > 0) {
+    if (this.exitCode === null && Number.isInteger(cols) && Number.isInteger(rows) && cols > 0 && rows > 0) {
       this.pty.resize(cols, rows);
     }
   }
+  /** Ends the session; on Windows, which has no signals, always forcibly (see releaseConpty). */
   kill(signal) {
-    this.pty.kill(signal);
+    if (!isWindows) this.pty.kill(signal);
+    else if (this.exitCode === null) execFile5("taskkill", ["/T", "/F", "/PID", String(this.pty.pid)], () => {
+    });
   }
-  /** Types into the session, as a client's keyboard would. */
+  /** Types into the session, as a client's keyboard would; nothing once it has exited. */
   write(data) {
-    this.pty.write(data);
+    if (this.exitCode === null) this.pty.write(data);
   }
   toJSON() {
     return {
@@ -1682,28 +1811,42 @@ var SessionManager = class {
   list() {
     return [...this.#sessions.values()].map((s) => s.toJSON());
   }
-  killAll() {
-    for (const s of this.#sessions.values()) s.kill();
+  /**
+   * Ends every session; resolves once they have all exited, or after `timeout` ms. Wait for it
+   * before exiting: on Windows terminals end asynchronously (see releaseConpty), and exiting
+   * while node-pty still holds a console open can crash the process.
+   */
+  killAll(timeout = 3e3) {
+    const exited = [...this.#sessions.values()].map((s) => {
+      const done = new Promise((resolve) => s.pty.onExit(resolve));
+      s.kill();
+      return done;
+    });
+    let timer;
+    const late = new Promise((resolve) => {
+      timer = setTimeout(resolve, timeout);
+    });
+    return Promise.race([Promise.all(exited), late]).finally(() => clearTimeout(timer));
   }
 };
 
 // ../../packages/agent-core/src/uploads.js
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile6 } from "node:child_process";
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { createWriteStream } from "node:fs";
-import fs6 from "node:fs/promises";
+import fs7 from "node:fs/promises";
 import os4 from "node:os";
-import path4 from "node:path";
+import path5 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 run3 = promisify2(execFile6);
 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();
+  const base2 = path5.basename(String(name ?? "").replace(/\\/g, "/"));
+  const clean = base2.replace(/[^\p{L}\p{N}._ -]/gu, "_").replace(/^[.\s]+/, "").slice(-80).trim();
   return clean || "file";
 }
 var UploadStore = class {
@@ -1716,8 +1859,8 @@ var UploadStore = class {
     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)}`);
+    await fs7.mkdir(path5.join(this.dir, day), { recursive: true, mode: 448 });
+    let file = path5.join(this.dir, day, `${id}-${safeName(name)}`);
     let size = 0;
     const counter = new Transform({
       transform(chunk, _enc, done) {
@@ -1728,7 +1871,7 @@ var UploadStore = class {
     try {
       await pipeline(body, counter, createWriteStream(file, { mode: 384 }));
     } catch (e) {
-      await fs6.rm(file, { force: true });
+      await fs7.rm(file, { force: true });
       throw e;
     }
     let kind = type || "application/octet-stream";
@@ -1736,31 +1879,31 @@ var UploadStore = class {
       const jpeg = file.replace(/(\.heic)?$/i, ".jpg");
       try {
         await run3("sips", ["-s", "format", "jpeg", file, "--out", jpeg], { timeout: 3e4 });
-        await fs6.rm(file);
+        await fs7.rm(file);
         file = jpeg;
         kind = "image/jpeg";
-        size = (await fs6.stat(file)).size;
+        size = (await fs7.stat(file)).size;
       } catch {
       }
     }
-    return { id, name: path4.basename(file).slice(id.length + 1), type: kind, size, path: file };
+    return { id, name: path5.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();
+      days = (await fs7.readdir(this.dir)).sort().reverse();
     } catch {
     }
     for (const day of days) {
       let names = [];
       try {
-        names = await fs6.readdir(path4.join(this.dir, day));
+        names = await fs7.readdir(path5.join(this.dir, day));
       } catch {
       }
       const hit = names.find((n) => n.startsWith(`${id}-`));
-      if (hit) return path4.join(this.dir, day, hit);
+      if (hit) return path5.join(this.dir, day, hit);
     }
     throw new HttpError(404, "no such upload (they are kept for 7 days)");
   }
@@ -1768,25 +1911,25 @@ var UploadStore = class {
   async sweep() {
     let days = [];
     try {
-      days = await fs6.readdir(this.dir);
+      days = await fs7.readdir(this.dir);
     } catch {
       return;
     }
     const cutoff = this.now() - KEEP;
     for (const day of days) {
-      const dir = path4.join(this.dir, day);
+      const dir = path5.join(this.dir, day);
       let names = [];
       try {
-        names = await fs6.readdir(dir);
+        names = await fs7.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 });
+        const file = path5.join(dir, n);
+        const stat = await fs7.stat(file).catch(() => null);
+        if (stat && stat.mtimeMs < cutoff) await fs7.rm(file, { force: true });
       }
-      if (!(await fs6.readdir(dir).catch(() => [])).length) await fs6.rm(dir, { recursive: true, force: true });
+      if (!(await fs7.readdir(dir).catch(() => [])).length) await fs7.rm(dir, { recursive: true, force: true });
     }
   }
 };
@@ -1799,11 +1942,11 @@ function kindOf(stat) {
   return "other";
 }
 async function describe(fullPath, name) {
-  const lst = await fs7.lstat(fullPath);
+  const lst = await fs8.lstat(fullPath);
   const entry2 = { name, type: kindOf(lst), size: lst.size, mtime: lst.mtimeMs };
   if (lst.isSymbolicLink()) {
     try {
-      entry2.target = kindOf(await fs7.stat(fullPath));
+      entry2.target = kindOf(await fs8.stat(fullPath));
     } catch {
       entry2.target = "broken";
     }
@@ -1843,7 +1986,7 @@ function createAgentServer({
   uploadsDir = null,
   claudeCommand = "claude",
   codexCommand = "codex",
-  codexHome = process.env.CODEX_HOME || path5.join(os5.homedir(), ".codex"),
+  codexHome = process.env.CODEX_HOME || path6.join(os5.homedir(), ".codex"),
   pluginInstalled = null,
   agents = new AgentHub(),
   pushStore: pushStore2 = null,
@@ -1898,17 +2041,6 @@ function createAgentServer({
     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,
@@ -1923,7 +2055,7 @@ function createAgentServer({
       // 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`) ?? "[]");
+        const list = JSON.parse(await capture([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."
@@ -1941,14 +2073,14 @@ function createAgentServer({
       ],
       env: {},
       async plugin() {
-        const list = JSON.parse(await loginShell(`${shellQuote(codexCommand)} plugin list --marketplace coderemote --json`) ?? "{}");
+        const list = JSON.parse(await capture([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());
+  function installed(agent) {
+    return commandExists(launchers[agent].command);
   }
   const plugins = {};
   async function hasPlugin(agent) {
@@ -1964,7 +2096,7 @@ function createAgentServer({
   }
   async function codexModels() {
     try {
-      const { models } = JSON.parse(await fs7.readFile(path5.join(codexHome, "models_cache.json"), "utf8"));
+      const { models } = JSON.parse(await fs8.readFile(path6.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 [];
@@ -2014,20 +2146,20 @@ function createAgentServer({
   async function repoOf(p) {
     const repo = await sandbox.resolve(p);
     try {
-      await fs7.access(path5.join(repo, ".git"));
+      await fs8.access(path6.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 || path5.isAbsolute(f))) {
+    if (!Array.isArray(files) || !files.length || files.some((f) => typeof f !== "string" || !f || path6.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(path5.join(repo, f), { allowMissing: true });
-        const rel = path5.relative(repo, abs);
+        const abs = await sandbox.resolve(path6.join(repo, f), { allowMissing: true });
+        const rel = path6.relative(repo, abs);
         if (!rel || rel.startsWith("..")) throw new HttpError(403, "path is outside the repository");
         return rel;
       })
@@ -2040,21 +2172,22 @@ function createAgentServer({
       platform: os5.platform(),
       root: sandbox.root,
       user: os5.userInfo().username,
-      shell: process.env.SHELL || null
+      // On Windows, terminals run PowerShell whatever $SHELL (Git Bash sets one) says.
+      shell: isWindows ? interactiveShell().file : process.env.SHELL || null
     }),
     [Routes.fsList]: async (url) => {
       const dir = await sandbox.resolve(url.searchParams.get("path"));
-      const names = await fs7.readdir(dir);
-      const entries = (await Promise.all(names.map((n) => describe(path5.join(dir, n), n).catch(() => null)))).filter(Boolean);
+      const names = await fs8.readdir(dir);
+      const entries = (await Promise.all(names.map((n) => describe(path6.join(dir, n), n).catch(() => null)))).filter(Boolean);
       return { path: dir, entries };
     },
     [Routes.fsStat]: async (url) => {
       const p = await sandbox.resolve(url.searchParams.get("path"));
-      return { path: p, ...await describe(p, path5.basename(p)) };
+      return { path: p, ...await describe(p, path6.basename(p)) };
     },
     [Routes.fsRead]: async (url, req, res) => {
       const p = await sandbox.resolve(url.searchParams.get("path"));
-      const stat = await fs7.stat(p);
+      const stat = await fs8.stat(p);
       if (!stat.isFile()) throw new HttpError(400, "not a file");
       res.writeHead(200, { "content-type": "application/octet-stream", "content-length": stat.size });
       await pipeline2(createReadStream(p), res);
@@ -2064,24 +2197,24 @@ function createAgentServer({
       const tmp = `${p}.vsremote-${process.pid}-${Date.now()}.tmp`;
       try {
         await pipeline2(req, createWriteStream2(tmp));
-        await fs7.rename(tmp, p);
+        await fs8.rename(tmp, p);
       } catch (e) {
-        await fs7.rm(tmp, { force: true });
+        await fs8.rm(tmp, { force: true });
         throw e;
       }
-      return describe(p, path5.basename(p));
+      return describe(p, path6.basename(p));
     },
     [Routes.fsMkdir]: async (url) => {
-      await fs7.mkdir(await sandbox.resolve(url.searchParams.get("path"), { allowMissing: true }), { recursive: true });
+      await fs8.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 fs7.rename(await sandbox.resolveChild(from), await sandbox.resolveChild(to, { allowMissing: true }));
+      await fs8.rename(await sandbox.resolveChild(from), await sandbox.resolveChild(to, { allowMissing: true }));
       return {};
     },
     [Routes.fsDelete]: async (url) => {
-      await fs7.rm(await sandbox.resolveChild(url.searchParams.get("path")), { recursive: true });
+      await fs8.rm(await sandbox.resolveChild(url.searchParams.get("path")), { recursive: true });
       return {};
     },
     [Routes.gitRepos]: async () => ({ repos: await findRepos(sandbox.root) }),
@@ -2216,7 +2349,7 @@ function createAgentServer({
       } catch (e) {
         throw new HttpError(400, e.message);
       }
-      if (!(await fs7.stat(dir)).isDirectory()) throw new HttpError(400, "cwd must be a folder");
+      if (!(await fs8.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");
       }
@@ -2238,7 +2371,7 @@ function createAgentServer({
         throw Object.assign(new HttpError(400, launcher.missingPlugin), { code: "ENOPLUGIN" });
       }
       const id = resume ?? randomUUID4();
-      if (uploadsDir) await fs7.mkdir(uploadsDir, { recursive: true, mode: 448 });
+      if (uploadsDir) await fs8.mkdir(uploadsDir, { recursive: true, mode: 448 });
       const argv2 = [
         launcher.command,
         ...launcher.args({
@@ -2475,42 +2608,33 @@ function createAgentServer({
 }
 
 // src/devtunnel.js
-import { execFile as execFile6 } from "node:child_process";
+import { execFile as execFile7 } from "node:child_process";
 import { createHash } from "node:crypto";
-import fs8 from "node:fs";
-import path6 from "node:path";
+import fs9 from "node:fs";
+import path7 from "node:path";
 import { promisify as promisify3 } from "node:util";
-var run4 = promisify3(execFile6);
+var run4 = promisify3(execFile7);
 var DOWNLOAD_BASE = "https://tunnelsassetsprod.blob.core.windows.net/cli";
 var BUILDS = {
   "darwin-arm64": "osx-arm64-devtunnel",
   "darwin-x64": "osx-x64-devtunnel",
   "linux-arm64": "linux-arm64-devtunnel",
-  "linux-x64": "linux-x64-devtunnel"
+  "linux-x64": "linux-x64-devtunnel",
+  "win32-x64": "devtunnel.exe",
+  // There's no Arm build for Windows; the x64 one runs there under emulation.
+  "win32-arm64": "devtunnel.exe"
 };
 var MICROSOFT_TEAM_ID = "UBF8T346G9";
+var MICROSOFT_SIGNER = /^CN=Microsoft Corporation, O=Microsoft Corporation,/;
 var REFRESH_INTERVAL_MS = 24 * 36e5;
-function executable(file) {
-  try {
-    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(path6.delimiter)) {
-    if (dir && executable(path6.join(dir, name))) return path6.join(dir, name);
-  }
-  return null;
-}
 async function ensureDevtunnel({ dir, progress }) {
   const override = process.env.CODEREMOTE_DEVTUNNEL;
   if (override) {
-    if (executable(override)) return override;
+    const found = findExecutable(override);
+    if (found) return found;
     throw new Error(`CODEREMOTE_DEVTUNNEL=${override} isn't an executable file.`);
   }
-  const fromPath = onPath("devtunnel");
+  const fromPath = findExecutable("devtunnel");
   if (fromPath) return fromPath;
   const build = BUILDS[`${process.platform}-${process.arch}`];
   if (!build) {
@@ -2518,14 +2642,14 @@ 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 = path6.join(dir, "devtunnel");
-  const metaFile = path6.join(dir, "devtunnel.json");
+  const bin = path7.join(dir, isWindows ? "devtunnel.exe" : "devtunnel");
+  const metaFile = path7.join(dir, "devtunnel.json");
   let meta = {};
   try {
-    meta = JSON.parse(fs8.readFileSync(metaFile, "utf8"));
+    meta = JSON.parse(fs9.readFileSync(metaFile, "utf8"));
   } catch {
   }
-  const installed = executable(bin);
+  const installed = findExecutable(bin) !== null;
   if (installed && Date.now() - (meta.checkedAt ?? 0) < REFRESH_INTERVAL_MS) return bin;
   const url = `${DOWNLOAD_BASE}/${build}`;
   if (installed) {
@@ -2533,23 +2657,27 @@ 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) {
-        fs8.writeFileSync(metaFile, JSON.stringify({ ...meta, checkedAt: Date.now() }));
+        fs9.writeFileSync(metaFile, JSON.stringify({ ...meta, checkedAt: Date.now() }));
         return bin;
       }
     } catch {
       return bin;
     }
   }
-  await download(url, bin, metaFile, progress);
+  try {
+    await download(url, bin, metaFile, progress);
+  } catch (e) {
+    if (!installed) throw e;
+  }
   return bin;
 }
 async function download(url, bin, metaFile, progress) {
-  fs8.mkdirSync(path6.dirname(bin), { recursive: true, mode: 448 });
+  fs9.mkdirSync(path7.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 = fs8.createWriteStream(tmp, { mode: 493 });
+  const out = fs9.createWriteStream(tmp, { mode: 493 });
   const md5 = createHash("md5");
   let received = 0;
   try {
@@ -2562,17 +2690,18 @@ 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"));
-    fs8.chmodSync(tmp, 493);
-    fs8.renameSync(tmp, bin);
+    fs9.chmodSync(tmp, 493);
+    fs9.renameSync(tmp, bin);
   } catch (e) {
     out.destroy();
-    fs8.rmSync(tmp, { force: true });
+    fs9.rmSync(tmp, { force: true });
     throw e;
   }
-  fs8.writeFileSync(metaFile, JSON.stringify({ lastModified: res.headers.get("last-modified"), checkedAt: Date.now() }));
+  fs9.writeFileSync(metaFile, JSON.stringify({ lastModified: res.headers.get("last-modified"), checkedAt: Date.now() }));
 }
 async function verify(file, md5, expectedMd5) {
   if (expectedMd5 && md5 !== expectedMd5) throw new Error("devtunnel download is corrupt (MD5 mismatch)");
+  if (isWindows) return verifyAuthenticode(file);
   if (process.platform !== "darwin") return;
   try {
     await run4("codesign", ["--verify", "--strict", file]);
@@ -2582,52 +2711,69 @@ async function verify(file, md5, expectedMd5) {
     throw new Error(`devtunnel download failed its signature check: ${e.message}`);
   }
 }
+async function verifyAuthenticode(file) {
+  const script = '$s = Get-AuthenticodeSignature -LiteralPath $env:CODEREMOTE_VERIFY; "$($s.Status)|$($s.SignerCertificate.Subject)"';
+  let status2;
+  let signer;
+  try {
+    const { stdout } = await run4("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+      env: { ...process.env, CODEREMOTE_VERIFY: file }
+    });
+    [status2, signer] = stdout.trim().split("|");
+  } catch (e) {
+    throw new Error(`devtunnel download failed its signature check: ${e.message}`);
+  }
+  if (status2 !== "Valid" || !MICROSOFT_SIGNER.test(signer ?? "")) {
+    throw new Error(`devtunnel download failed its signature check: ${status2}, signed by ${signer || "nobody"}`);
+  }
+}
 
 // src/hook.js
 import { randomBytes as randomBytes2 } from "node:crypto";
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import http3 from "node:http";
-import path7 from "node:path";
+import path8 from "node:path";
 var CONNECT_TIMEOUT = 1e3;
 var EVENT_TIMEOUT = 5e3;
 function ensureHookSecret(dir) {
-  const file = path7.join(dir, "hook-secret");
+  const file = path8.join(dir, "hook-secret");
   try {
-    const secret2 = fs9.readFileSync(file, "utf8").trim();
+    const secret2 = fs10.readFileSync(file, "utf8").trim();
     if (secret2) return secret2;
   } catch {
   }
-  fs9.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs10.mkdirSync(dir, { recursive: true, mode: 448 });
   const secret = randomBytes2(32).toString("base64url");
-  fs9.writeFileSync(file, secret, { mode: 384 });
+  fs10.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 bin = path8.join(dir, "bin");
+  fs10.mkdirSync(bin, { recursive: true, mode: 448 });
   const quote = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
-  const file = path7.join(bin, "hook");
-  fs9.writeFileSync(file, `#!/bin/sh
+  const file = path8.join(bin, "hook");
+  fs10.writeFileSync(file, `#!/bin/sh
 exec ${quote(node)} ${quote(script)} hook "$@"
 `, { mode: 493 });
-  fs9.chmodSync(file, 493);
+  fs10.chmodSync(file, 493);
+  fs10.writeFileSync(path8.join(bin, "hook.json"), JSON.stringify({ node, script }), { mode: 384 });
   return file;
 }
 function readHookSecret(dir) {
   try {
-    return fs9.readFileSync(path7.join(dir, "hook-secret"), "utf8").trim() || null;
+    return fs10.readFileSync(path8.join(dir, "hook-secret"), "utf8").trim() || null;
   } catch {
     return null;
   }
 }
 function real(p) {
   try {
-    return fs9.realpathSync(p);
+    return fs10.realpathSync.native(p);
   } catch {
-    return path7.resolve(p);
+    return path8.resolve(p);
   }
 }
-var within = (dir, root2) => dir === root2 || dir.startsWith(root2.endsWith(path7.sep) ? root2 : root2 + path7.sep);
+var within = (dir, root2) => dir === root2 || dir.startsWith(root2.endsWith(path8.sep) ? root2 : root2 + path8.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 };
@@ -2683,8 +2829,80 @@ async function runHook({ input, agents, secret, agent = "claude", env = process.
 }
 
 // src/preview.js
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
+
+// src/tunnels.js
+var TUNNEL_LIMIT = 10;
+var PREVIEW_LABEL = "coderemote-preview";
+var base = (id) => String(id).split(".")[0];
+async function listTunnels(devtunnel2) {
+  const res = await devtunnel2("list", "--limit", "100", "--json");
+  if (!res.ok) return { error: res.out.trim() };
+  try {
+    const { tunnels } = JSON.parse(res.out.slice(res.out.indexOf("{")));
+    if (Array.isArray(tunnels)) return { tunnels };
+  } catch {
+  }
+  return { error: `unexpected devtunnel list output:
+${res.out}` };
+}
+async function tunnelsAtLimit(devtunnel2) {
+  const { tunnels } = await listTunnels(devtunnel2);
+  return tunnels && tunnels.length >= TUNNEL_LIMIT ? tunnels : null;
+}
+async function makeRoom(devtunnel2) {
+  const tunnels = await tunnelsAtLimit(devtunnel2);
+  if (!tunnels) return null;
+  const idle = tunnels.filter((t) => t.labels?.includes(PREVIEW_LABEL) && !(t.hostConnections > 0));
+  const deleted = await Promise.all(idle.map((t) => devtunnel2("delete", t.tunnelId, "-f")));
+  const freed = idle.filter((_, i) => deleted[i].ok).map((t) => t.tunnelId);
+  return freed.length ? { freed } : { full: tunnels };
+}
+function ownUse(cfg2, id) {
+  for (const [port2, t] of Object.entries(cfg2.tunnels ?? {})) if (base(t) === base(id)) return `agent on port ${port2}`;
+  if (cfg2.tunnelId && base(cfg2.tunnelId) === base(id)) return "agent";
+  for (const [port2, t] of Object.entries(cfg2.previewTunnels ?? {})) if (base(t) === base(id)) return `previews on port ${port2}`;
+  return null;
+}
+function forgetTunnel(cfg2, id) {
+  let changed = false;
+  for (const key of ["tunnels", "previewTunnels"]) {
+    for (const [port2, t] of Object.entries(cfg2[key] ?? {})) {
+      if (base(t) !== base(id)) continue;
+      delete cfg2[key][port2];
+      changed = true;
+    }
+  }
+  if (cfg2.tunnelId && base(cfg2.tunnelId) === base(id)) {
+    delete cfg2.tunnelId;
+    changed = true;
+  }
+  return changed;
+}
+function findTunnel(tunnels, id) {
+  return tunnels.find((t) => t.tunnelId === id || base(t.tunnelId) === base(id)) ?? null;
+}
+function formatTunnels(tunnels, cfg2) {
+  const width = Math.max(...tunnels.map((t) => t.tunnelId.length));
+  return tunnels.map((t) => {
+    const notes = [t.hostConnections > 0 ? "online" : null, ownUse(cfg2, t.tunnelId) && `this computer's ${ownUse(cfg2, t.tunnelId)}`];
+    const about = t.description || t.labels?.join(", ") || "(no description)";
+    return `  ${t.tunnelId.padEnd(width)}  ${[...notes.filter(Boolean), about].join(" \xB7 ")}`;
+  });
+}
+function tunnelLimitHelp(tunnels, cfg2 = {}) {
+  return [
+    `Your Dev Tunnels account already has ${tunnels.length} tunnels, the most it may keep:`,
+    ...formatTunnels(tunnels, cfg2),
+    "Delete the ones nothing uses any more, then try again. Deleting a tunnel an agent still uses",
+    "changes its URL and unpairs its phones.",
+    "  coderemote tunnels delete <tunnel id>..."
+  ].join("\n");
+}
+
+// src/preview.js
 var HOST_READY_TIMEOUT_MS = 3e4;
+var CLOSE_TIMEOUT_MS = 5e3;
 var TOKEN_REUSE_MS = 12 * 36e5;
 var PreviewTunnel = class {
   #queue = Promise.resolve();
@@ -2764,8 +2982,13 @@ var PreviewTunnel = class {
     return this.#serial(async () => {
       const url = this.#host?.urls.get(port2);
       if (url) return { port: port2, url };
-      const id = await this.#ensureTunnel();
-      const res = await this.devtunnel("port", "create", id, "-p", String(port2), "--protocol", "http");
+      let id = await this.#ensureTunnel();
+      let res = await this.devtunnel("port", "create", id, "-p", String(port2), "--protocol", "http");
+      if (!res.ok && /not found/i.test(res.out)) {
+        this.#forgetTunnel();
+        id = await this.#ensureTunnel();
+        res = await this.devtunnel("port", "create", id, "-p", String(port2), "--protocol", "http");
+      }
       if (!res.ok && !/already exists|conflict/i.test(res.out)) throw new Error(`devtunnel port create failed: ${res.out.trim()}`);
       this.#ports.add(port2);
       try {
@@ -2800,20 +3023,42 @@ var PreviewTunnel = class {
   stop() {
     this.#stopHost();
   }
+  /**
+   * Stops hosting and deletes the tunnel (or the last run's), which nothing reuses: each run
+   * starts a new one. If that fails or takes too long, the next run deletes it.
+   */
+  async close() {
+    this.#stopHost();
+    const id = this.#tunnelId ?? this.leftover;
+    if (!id) return;
+    const res = await Promise.race([
+      this.devtunnel("delete", id, "-f"),
+      new Promise((resolve) => setTimeout(resolve, CLOSE_TIMEOUT_MS, { ok: false, out: "timed out" }))
+    ]);
+    if (res.ok || /not found/i.test(res.out)) this.remember(null);
+  }
+  #forgetTunnel() {
+    this.#stopHost();
+    this.#tunnelId = null;
+    this.#token = null;
+    this.#ports.clear();
+    this.#shares.clear();
+  }
   async #ensureTunnel() {
     if (this.#tunnelId) return this.#tunnelId;
     if (this.leftover) await this.devtunnel("delete", this.leftover, "-f");
-    const created = await this.devtunnel(
-      "create",
-      "--expiration",
-      "30d",
-      "-d",
-      this.description,
-      "--labels",
-      "coderemote-preview",
-      "--json"
-    );
-    if (!created.ok) throw new Error(`devtunnel create failed: ${created.out.trim()}`);
+    const create = () => this.devtunnel("create", "--expiration", "30d", "-d", this.description, "--labels", PREVIEW_LABEL, "--json");
+    let created = await create();
+    if (!created.ok) {
+      const room = await makeRoom(this.devtunnel);
+      if (room?.freed) created = await create();
+      if (room?.full) {
+        throw new Error(
+          `Your Dev Tunnels account already has ${TUNNEL_LIMIT} tunnels, the most it may keep. Delete ones nothing uses on the computer (coderemote tunnels, coderemote tunnels delete <id>), then try again.`
+        );
+      }
+      if (!created.ok) throw new Error(`devtunnel create failed: ${created.out.trim()}`);
+    }
     const id = JSON.parse(created.out.slice(created.out.indexOf("{"))).tunnel?.tunnelId;
     if (!id) throw new Error(`could not parse tunnel id from:
 ${created.out}`);
@@ -2831,7 +3076,7 @@ ${created.out}`);
   }
   #startHost() {
     return new Promise((resolve, reject) => {
-      const child = spawn(this.command(), ["host", this.#tunnelId], { stdio: ["ignore", "pipe", "pipe"] });
+      const child = spawn2(this.command(), ["host", this.#tunnelId], { stdio: ["ignore", "pipe", "pipe"] });
       const urls = /* @__PURE__ */ new Map();
       let log2 = "";
       const timer = setTimeout(() => {
@@ -2866,40 +3111,40 @@ ${log2}`));
 };
 
 // src/push-store.js
-import fs10 from "node:fs";
-import path8 from "node:path";
+import fs11 from "node:fs";
+import path9 from "node:path";
 function pushStore(dir, port2) {
-  const file = path8.join(dir, `${port2}.json`);
+  const file = path9.join(dir, `${port2}.json`);
   return {
     load() {
       try {
-        const devices = JSON.parse(fs10.readFileSync(file, "utf8"));
+        const devices = JSON.parse(fs11.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 });
+      fs11.mkdirSync(dir, { recursive: true, mode: 448 });
+      fs11.writeFileSync(file, JSON.stringify(devices, null, 2), { mode: 384 });
     }
   };
 }
 
 // src/registry.js
-import fs11 from "node:fs";
-import path9 from "node:path";
+import fs12 from "node:fs";
+import path10 from "node:path";
 var AgentRegistry = class {
   constructor(dir) {
     this.dir = dir;
   }
   register({ port: port2, root: root2, url }) {
-    fs11.mkdirSync(this.dir, { recursive: true, mode: 448 });
+    fs12.mkdirSync(this.dir, { recursive: true, mode: 448 });
     const file = this.#file(port2);
-    fs11.writeFileSync(file, JSON.stringify({ pid: process.pid, port: port2, root: root2, url, startedAt: Date.now() }), { mode: 384 });
+    fs12.writeFileSync(file, JSON.stringify({ pid: process.pid, port: port2, root: root2, url, startedAt: Date.now() }), { mode: 384 });
     const cleanup = () => {
       try {
-        if (JSON.parse(fs11.readFileSync(file, "utf8")).pid === process.pid) fs11.rmSync(file);
+        if (JSON.parse(fs12.readFileSync(file, "utf8")).pid === process.pid) fs12.rmSync(file);
       } catch {
       }
     };
@@ -2910,25 +3155,25 @@ var AgentRegistry = class {
   list() {
     let names = [];
     try {
-      names = fs11.readdirSync(this.dir).filter((n) => n.endsWith(".json"));
+      names = fs12.readdirSync(this.dir).filter((n) => n.endsWith(".json"));
     } catch {
       return [];
     }
     const agents = [];
     for (const name of names) {
-      const file = path9.join(this.dir, name);
+      const file = path10.join(this.dir, name);
       try {
-        const agent = JSON.parse(fs11.readFileSync(file, "utf8"));
+        const agent = JSON.parse(fs12.readFileSync(file, "utf8"));
         process.kill(agent.pid, 0);
         agents.push(agent);
       } catch {
-        fs11.rmSync(file, { force: true });
+        fs12.rmSync(file, { force: true });
       }
     }
     return agents.sort((a, b) => a.port - b.port);
   }
   #file(port2) {
-    return path9.join(this.dir, `${port2}.json`);
+    return path10.join(this.dir, `${port2}.json`);
   }
 };
 
@@ -2992,8 +3237,8 @@ function tunnelStatus({ devtunnel: devtunnel2, tunnelId, account, anonymous: ano
 }
 
 // src/update.js
-import fs12 from "node:fs";
-import path10 from "node:path";
+import fs13 from "node:fs";
+import path11 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.-]+))?$/;
@@ -3017,10 +3262,10 @@ async function fetchLatest({ fetch: fetch2 = globalThis.fetch, timeoutMs = 3e3 }
   }
 }
 async function availableUpdate({ current, dir, fetch: fetch2, now = Date.now() }) {
-  const file = path10.join(dir, "update.json");
+  const file = path11.join(dir, "update.json");
   let cache = {};
   try {
-    cache = JSON.parse(fs12.readFileSync(file, "utf8"));
+    cache = JSON.parse(fs13.readFileSync(file, "utf8"));
   } catch {
   }
   let latest = cache.latest;
@@ -3029,8 +3274,8 @@ async function availableUpdate({ current, dir, fetch: fetch2, now = Date.now() }
     if (fetched) {
       latest = fetched;
       try {
-        fs12.mkdirSync(dir, { recursive: true, mode: 448 });
-        fs12.writeFileSync(file, JSON.stringify({ latest, checkedAt: now }));
+        fs13.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs13.writeFileSync(file, JSON.stringify({ latest, checkedAt: now }));
       } catch {
       }
     }
@@ -3038,7 +3283,14 @@ async function availableUpdate({ current, dir, fetch: fetch2, now = Date.now() }
   return isNewer(latest, current) ? latest : null;
 }
 function installCommand(installedAt) {
-  const p = installedAt.split(path10.sep).join("/");
+  const p = installedAt.split(path11.sep).join("/");
+  const runtime = p.match(/^(.*\/runtime\/node)\/(lib\/)?node_modules\/coderemote\//);
+  if (runtime) {
+    const prefix = installedAt.slice(0, runtime[1].length);
+    const [node, modules] = runtime[2] ? [path11.join(prefix, "bin", "node"), path11.join(prefix, "lib", "node_modules")] : [path11.join(prefix, "node.exe"), path11.join(prefix, "node_modules")];
+    return [node, [path11.join(modules, "npm", "bin", "npm-cli.js"), "install", "-g", "--prefix", prefix, "coderemote@latest"]];
+  }
+  if (p.includes("/Cellar/coderemote/")) return ["brew", ["upgrade", "coderemote"]];
   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"]];
@@ -3048,7 +3300,7 @@ function installCommand(installedAt) {
 // package.json
 var package_default = {
   name: "coderemote",
-  version: "0.3.5",
+  version: "0.3.6",
   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",
@@ -3091,17 +3343,13 @@ var package_default = {
   engines: {
     node: ">=20"
   },
-  os: [
-    "darwin",
-    "linux"
-  ],
   scripts: {
     build: "node scripts/build.js",
     prepare: "node scripts/build.js",
-    prepack: "node scripts/build.js && cp ../../LICENSE LICENSE",
-    postpack: "rm -f LICENSE",
+    prepack: `node scripts/build.js && node -e "require('fs').copyFileSync('../../LICENSE', 'LICENSE')"`,
+    postpack: `node -e "require('fs').rmSync('LICENSE', { force: true })"`,
     postinstall: "node scripts/fix-node-pty.js",
-    test: "node --test 'test/*.test.js'"
+    test: 'node --test "test/*.test.js"'
   },
   dependencies: {
     "node-pty": "^1.1.0",
@@ -3327,15 +3575,12 @@ var Spinner = class {
 };
 
 // src/vscode-tunnel.js
-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");
+  return process.env.CODEREMOTE_CODE || findExecutable("code");
 }
 async function codeTunnelSignedIn(code) {
   try {
-    const { stdout } = await run5(code, ["tunnel", "user", "show"]);
+    const { stdout } = await execCommand([code, "tunnel", "user", "show"]);
     return /^logged in/im.test(stdout);
   } catch {
     return false;
@@ -3343,12 +3588,12 @@ async function codeTunnelSignedIn(code) {
 }
 function codeTunnelLogin(code) {
   return new Promise((resolve) => {
-    spawn2(code, ["tunnel", "user", "login", "--provider", "github"], { stdio: "inherit" }).on("exit", resolve);
+    spawnCommand([code, "tunnel", "user", "login", "--provider", "github"], { stdio: "inherit" }).on("exit", resolve);
   });
 }
 function hostCodeTunnel(code, root2, timeoutMs = 6e4) {
   return new Promise((resolve, reject) => {
-    const child = spawn2(code, ["tunnel"], { cwd: root2, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawnCommand([code, "tunnel"], { cwd: root2, stdio: ["ignore", "pipe", "pipe"] });
     let log2 = "";
     const timer = setTimeout(() => {
       child.kill();
@@ -3360,7 +3605,8 @@ ${log2}`));
       const m = log2.match(/https:\/\/vscode\.dev\/tunnel\/([^/\s]+)/);
       if (!m) return;
       clearTimeout(timer);
-      resolve({ child, url: `https://vscode.dev/tunnel/${m[1]}${encodeURI(root2)}` });
+      const folder = isWindows ? `/${root2.replaceAll("\\", "/")}` : root2;
+      resolve({ child, url: `https://vscode.dev/tunnel/${m[1]}${encodeURI(folder)}` });
     };
     child.stdout.on("data", onData);
     child.stderr.on("data", onData);
@@ -3377,28 +3623,28 @@ ${log2}`));
 }
 
 // bin/coderemote.js
-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 run5 = promisify4(execFile8);
+var CONFIG_DIR = path12.join(os6.homedir(), ".coderemote");
+var LEGACY_CONFIG_DIR = path12.join(os6.homedir(), ".vsremote");
+if (!fs14.existsSync(CONFIG_DIR) && fs14.existsSync(LEGACY_CONFIG_DIR)) fs14.renameSync(LEGACY_CONFIG_DIR, CONFIG_DIR);
+var CONFIG_FILE = path12.join(CONFIG_DIR, "config.json");
+var PUSH_DIR = path12.join(CONFIG_DIR, "push");
+var UPLOADS_DIR = path12.join(CONFIG_DIR, "uploads");
 var DEFAULT_PORT = 31580;
 var VERSION = package_default.version;
-var PACKAGED = path11.basename(path11.dirname(fileURLToPath(import.meta.url))) === "dist";
+var PACKAGED = path12.basename(path12.dirname(fileURLToPath(import.meta.url))) === "dist";
 var spinner = new Spinner();
 function loadConfig() {
   let cfg2 = {};
   try {
-    cfg2 = JSON.parse(fs13.readFileSync(CONFIG_FILE, "utf8"));
+    cfg2 = JSON.parse(fs14.readFileSync(CONFIG_FILE, "utf8"));
   } catch {
   }
   if (!cfg2.token) {
     cfg2.token = randomBytes3(32).toString("base64url");
     saveConfig(cfg2);
-    fs13.rmSync(PUSH_DIR, { recursive: true, force: true });
-    fs13.rmSync(UPLOADS_DIR, { recursive: true, force: true });
+    fs14.rmSync(PUSH_DIR, { recursive: true, force: true });
+    fs14.rmSync(UPLOADS_DIR, { recursive: true, force: true });
   }
   if (cfg2.tunnelId && !cfg2.tunnels) {
     cfg2.tunnels = { [DEFAULT_PORT]: cfg2.tunnelId };
@@ -3406,9 +3652,16 @@ function loadConfig() {
   }
   return cfg2;
 }
+function stopAgent(pid) {
+  if (!isWindows) return process.kill(pid, "SIGTERM");
+  try {
+    execFileSync("taskkill", ["/T", "/F", "/PID", String(pid)], { stdio: "ignore" });
+  } catch {
+  }
+}
 function saveConfig(cfg2) {
-  fs13.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
-  fs13.writeFileSync(CONFIG_FILE, JSON.stringify(cfg2, null, 2), { mode: 384 });
+  fs14.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  fs14.writeFileSync(CONFIG_FILE, JSON.stringify(cfg2, null, 2), { mode: 384 });
 }
 function portFree(port2) {
   return new Promise((resolve) => {
@@ -3419,7 +3672,7 @@ function portFree(port2) {
 }
 function listen(token, port2, root2, tunnelToken, preview, status2) {
   const hookSecret = ensureHookSecret(CONFIG_DIR);
-  writeHookLauncher(CONFIG_DIR, { script: fs13.realpathSync(process.argv[1]) });
+  writeHookLauncher(CONFIG_DIR, { script: fs14.realpathSync(process.argv[1]) });
   const server = createAgentServer({
     token,
     root: root2,
@@ -3428,7 +3681,7 @@ function listen(token, port2, root2, tunnelToken, preview, status2) {
     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]),
+    hookBin: fs14.realpathSync(process.argv[1]),
     pushStore: pushStore(PUSH_DIR, port2),
     uploadsDir: UPLOADS_DIR
   });
@@ -3441,7 +3694,7 @@ var DEVTUNNEL = "devtunnel";
 async function resolveDevtunnel() {
   let installing = false;
   DEVTUNNEL = await ensureDevtunnel({
-    dir: path11.join(CONFIG_DIR, "bin"),
+    dir: path12.join(CONFIG_DIR, "bin"),
     progress: (detail2) => {
       if (!installing) {
         installing = true;
@@ -3454,7 +3707,7 @@ async function resolveDevtunnel() {
 }
 async function devtunnel(...args) {
   try {
-    const { stdout } = await run6(DEVTUNNEL, args);
+    const { stdout } = await run5(DEVTUNNEL, args);
     return { ok: true, out: stdout };
   } catch (e) {
     return { ok: false, out: `${e.stdout || ""}${e.stderr || ""}` || e.message };
@@ -3515,9 +3768,23 @@ ${updated.out}`);
   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);
-  if (!created.ok) throw new Error(`devtunnel create failed:
+  let created = await devtunnel(...createArgs);
+  if (!created.ok) {
+    const room = await makeRoom(devtunnel);
+    if (room?.full) {
+      spinner.fail();
+      console.error(`
+${tunnelLimitHelp(room.full, cfg2)}`);
+      process.exit(1);
+    }
+    if (room?.freed) {
+      spinner.update(`(deleted ${room.freed.length} idle preview tunnel${room.freed.length > 1 ? "s" : ""} to make room)`);
+      if (room.freed.filter((id) => forgetTunnel(cfg2, id)).length) saveConfig(cfg2);
+      created = await devtunnel(...createArgs);
+    }
+    if (!created.ok) throw new Error(`devtunnel create failed:
 ${created.out}`);
+  }
   const tunnelId = JSON.parse(created.out.slice(created.out.indexOf("{"))).tunnel?.tunnelId;
   if (!tunnelId) throw new Error(`could not parse tunnel id from:
 ${created.out}`);
@@ -3610,6 +3877,9 @@ var USAGE = `Usage: coderemote <command> [options]
   kill <id>... | --all kill terminal sessions (an id prefix is enough)
   stop [--all]         stop the agent for this folder (or every agent)
   rotate-token         revoke every paired device and stop running agents
+  tunnels              list your dev tunnels account's tunnels (it may keep 10)
+  tunnels delete <id>...  delete tunnels nothing uses; one that is online or is this
+                       computer's needs --force (its URL changes, its phones unpair)
   update               install the latest coderemote (up says when there's one)
   requests [PORT]      list the requests that reached a previewed port, oldest first;
                        --grep TEXT, --failed (errors, 4xx and 5xx), --limit N (default 50)
@@ -3641,9 +3911,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 = path11.resolve(flag("--root") ?? process.cwd());
+var root = path12.resolve(flag("--root") ?? process.cwd());
 var cfg = loadConfig();
-var registry = new AgentRegistry(path11.join(CONFIG_DIR, "agents"));
+var registry = new AgentRegistry(path12.join(CONFIG_DIR, "agents"));
 async function start({ tunnel }) {
   const agents = registry.list();
   if (flag("--port")) {
@@ -3682,6 +3952,7 @@ async function start({ tunnel }) {
     leftover: cfg.previewTunnels?.[port],
     remember: (id) => {
       cfg.previewTunnels = { ...cfg.previewTunnels, [port]: id };
+      if (!id) delete cfg.previewTunnels[port];
       saveConfig(cfg);
     },
     mintToken: connectToken
@@ -3695,7 +3966,7 @@ async function start({ tunnel }) {
     spinner.fail();
     if (e.code !== "EADDRINUSE") throw e;
     console.error(`Port ${port} is already in use by another process.`);
-    console.error(`See what holds it with: lsof -nP -iTCP:${port} -sTCP:LISTEN`);
+    console.error(`See what holds it with: ${isWindows ? `netstat -ano | findstr :${port}` : `lsof -nP -iTCP:${port} -sTCP:LISTEN`}`);
     console.error("Stop that process, or pick another port with --port.");
     process.exit(1);
   }
@@ -3725,10 +3996,10 @@ async function start({ tunnel }) {
   }
   spinner.succeed();
   registry.register({ port, root, url });
-  const shutdown = () => {
+  const shutdown = async () => {
     child?.kill();
-    preview?.stop();
-    server.killAllSessions();
+    await preview?.close();
+    await server.killAllSessions();
     server.close();
     process.exit(0);
   };
@@ -3744,7 +4015,7 @@ async function start({ tunnel }) {
 var PLUGIN = "coderemote@coderemote";
 async function claudeCli(...args) {
   try {
-    return (await run6("claude", args, { timeout: 12e4 })).stdout.trim();
+    return (await execCommand(["claude", ...args], { timeout: 12e4 })).stdout.trim();
   } catch (e) {
     if (e.code === "ENOENT") return null;
     throw new Error((e.stderr || e.stdout || e.message).trim());
@@ -3785,7 +4056,7 @@ async function setupClaude() {
 var CODEX_PLUGIN = "coderemote@coderemote";
 async function codexCli(...args) {
   try {
-    return (await run6("codex", args, { timeout: 12e4 })).stdout.trim();
+    return (await execCommand(["codex", ...args], { timeout: 12e4 })).stdout.trim();
   } catch (e) {
     if (e.code === "ENOENT") return null;
     throw new Error((e.stderr || e.stdout || e.message).trim());
@@ -3860,7 +4131,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 + path11.sep)).sort((a, b) => b.root.length - a.root.length);
+  const containing = agents.filter((a) => here === a.root || here.startsWith(a.root + path12.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) {
@@ -3990,7 +4261,7 @@ Token: ${cfg.token}`);
       break;
     }
     for (const agent of targets) {
-      process.kill(agent.pid, "SIGTERM");
+      stopAgent(agent.pid);
       console.log(`stopped agent for ${agent.root} (pid ${agent.pid})`);
     }
     break;
@@ -4000,13 +4271,57 @@ Token: ${cfg.token}`);
     saveConfig(cfg);
     const agents = registry.list();
     for (const agent of agents) {
-      process.kill(agent.pid, "SIGTERM");
+      stopAgent(agent.pid);
       console.log(`stopped agent for ${agent.root} (pid ${agent.pid})`);
     }
     console.log("Token rotated. Re-pair your devices.");
     if (agents.length) console.log("Run `coderemote up` again in each folder above; each keeps its tunnel URL.");
     break;
   }
+  case "tunnels": {
+    await resolveDevtunnel();
+    const { tunnels, error } = await listTunnels(devtunnel);
+    if (error) {
+      console.error(error);
+      console.error("Signed in? Run `coderemote login`.");
+      process.exit(1);
+    }
+    if (rest[0] !== "delete") {
+      console.log(tunnels.length ? formatTunnels(tunnels, cfg).join("\n") : "No tunnels on this account.");
+      break;
+    }
+    const ids = rest.slice(1).filter((a) => !a.startsWith("--"));
+    if (!ids.length) {
+      console.error("Usage: coderemote tunnels delete <tunnel id>... [--force]");
+      process.exit(1);
+    }
+    let failed = false;
+    for (const id of ids) {
+      const tunnel = findTunnel(tunnels, id);
+      if (!tunnel) {
+        console.error(`${id}: no such tunnel on this account`);
+        failed = true;
+        continue;
+      }
+      const use = ownUse(cfg, tunnel.tunnelId);
+      if (!rest.includes("--force") && (tunnel.hostConnections > 0 || use)) {
+        const why = tunnel.hostConnections > 0 ? "an agent is serving it right now" : `it is this computer's ${use}`;
+        console.error(`${tunnel.tunnelId}: kept, ${why}. Deleting it unpairs its phones; add --force to delete it anyway.`);
+        failed = true;
+        continue;
+      }
+      const res = await devtunnel("delete", tunnel.tunnelId, "-f");
+      if (!res.ok) {
+        console.error(`${tunnel.tunnelId}: ${res.out.trim()}`);
+        failed = true;
+        continue;
+      }
+      if (forgetTunnel(cfg, tunnel.tunnelId)) saveConfig(cfg);
+      console.log(`deleted ${tunnel.tunnelId}${use ? ` (this computer's ${use}: the next \`coderemote up\` makes a new one)` : ""}`);
+    }
+    if (failed) process.exit(1);
+    break;
+  }
   case "login": {
     await resolveDevtunnel();
     process.exit(await interactiveLogin(loginArgs()));
@@ -4025,16 +4340,16 @@ Token: ${cfg.token}`);
       console.log(`coderemote ${VERSION} is the latest version.`);
       break;
     }
-    const [command, args] = installCommand(fs13.realpathSync(process.argv[1]));
+    const [command, args] = installCommand(fs14.realpathSync(process.argv[1]));
     console.log(`Updating coderemote ${VERSION} \u2192 ${latest}: ${command} ${args.join(" ")}
 `);
     const code = await new Promise((resolve) => {
-      spawn3(command, args, { stdio: "inherit" }).on("exit", resolve).on("error", () => resolve(127));
+      spawnCommand([command, ...args], { stdio: "inherit" }).on("exit", resolve).on("error", () => resolve(127));
     });
     if (code !== 0) {
       console.error(`
 The update failed (${command} exited with ${code}).`);
-      console.error(`If it was a permission error (EACCES), run it with sudo: sudo ${command} ${args.join(" ")}`);
+      if (!isWindows && command === "npm") console.error(`If it was a permission error (EACCES), run it with sudo: sudo ${command} ${args.join(" ")}`);
       process.exit(code || 1);
     }
     const running = registry.list();