token-larper 1.10.0 → 1.10.1

package/bin/cli.js

@@ -32,7 +32,7 @@ function dataDir() {
 
 function bunPath() {
   if (typeof Bun !== "undefined") return process.execPath;
-  if (spawnSync("bun", ["--version"], { stdio: "ignore" }).status === 0) return "bun";
+  if (spawnSync("bun", ["--version"], { stdio: "ignore", windowsHide: true }).status === 0) return "bun";
   console.error("🔥 Token Larper requires Bun (v1.1+) to run.");
   console.error("\nInstall Bun with one command:");
   if (process.platform === "win32") {
@@ -85,26 +85,47 @@ async function foreground() {
   process.exit(child.status ?? 0);
 }
 
+/**
+ * Start the server so it outlives this terminal. On Windows it goes through Start-Process:
+ * the server then gets a hidden console that everything it starts shares (a process with
+ * no console at all makes Windows open a window for each console program it runs), and it
+ * inherits no handles, so it can't end up holding an older copy's port when this CLI was
+ * itself started by one during an update. The server writes its own log (src/logFile.ts).
+ */
+function startServerProcess(bun, env) {
+  if (process.platform === "win32") {
+    const quote = (value) => `'${value.replace(/'/g, "''")}'`;
+    const command = [
+      "Start-Process -WindowStyle Hidden",
+      `-FilePath ${quote(bun)}`,
+      `-ArgumentList ${quote(`"${serverScript}"`)}`,
+      `-WorkingDirectory ${quote(rootDir)}`,
+    ].join(" ");
+    const hop = spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", command], {
+      stdio: "ignore",
+      windowsHide: true,
+      env,
+    });
+    return hop.status === 0;
+  }
+  spawn(bun, [serverScript], { cwd: rootDir, detached: true, stdio: "ignore", env }).unref();
+  return true;
+}
+
 async function background(open) {
   const bun = bunPath();
   const dir = dataDir();
   mkdirSync(dir, { recursive: true });
   const logFile = join(dir, "server.log");
-  const log = openSync(logFile, "w");
+  closeSync(openSync(logFile, "w"));
 
   // The server moves to the next free port if another program has this one, and takes
   // over from an older Token Larper on the same port (see src/server.ts).
-  const child = spawn(bun, [serverScript], {
-    cwd: rootDir,
-    detached: true,
-    windowsHide: true,
-    stdio: ["ignore", log, log],
-    env: { ...process.env, TOKEN_LARPER_NO_BROWSER: "1" },
+  const started = startServerProcess(bun, {
+    ...process.env,
+    TOKEN_LARPER_NO_BROWSER: "1",
+    TOKEN_LARPER_LOG_FILE: logFile,
   });
-  let exited = false;
-  child.on("exit", () => (exited = true));
-  child.unref();
-  closeSync(log);
 
   const readLog = () => {
     try {
@@ -117,10 +138,22 @@ async function background(open) {
   // Ready once the server says where it is listening. A copy of the same version that
   // is already running says so too ("already running at ..."), then the new one exits.
   let url = null;
-  for (let i = 0; i < 120 && !url; i++) {
+  let waitingForPort = false;
+  for (let i = 0; started && i < 120 && !url; i++) {
     await sleep(250);
-    url = readLog().match(/running at (http:\/\/localhost:\d+)/)?.[1] ?? null;
-    if (!url && exited) break;
+    const text = readLog();
+    url = text.match(/running at (http:\/\/localhost:\d+)/)?.[1] ?? null;
+    // Taking over from an older copy can take a minute while its port is released. This
+    // CLI may be holding that port itself (when the old copy started it for an update),
+    // so leave now instead of waiting.
+    waitingForPort = !url && text.includes("Waiting for port");
+    if (waitingForPort) break;
+    if (/Token Larper stopped:/.test(text)) break;
+  }
+
+  if (waitingForPort) {
+    console.log(`🔥 Token Larper is replacing an older copy. It will be at http://localhost:${port} in a minute.`);
+    process.exit(0);
   }
 
   if (!url) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "token-larper",
-  "version": "1.10.0",
+  "version": "1.10.1",
   "description": "Token Larper — Multi-Harness AI Coding Usage & Cost Telemetry Dashboard powered by ccusage",
   "type": "module",
   "license": "MIT",

package/src/ccusage.ts

@@ -337,6 +337,21 @@ export function estimateFrontierCost(params: {
   );
 }
 
+// Runs still in progress. On Windows a child keeps the server's listening socket open, so
+// shutdown stops them; otherwise a newer copy can't take over the port.
+const activeRuns = new Set<ReturnType<typeof Bun.spawn>>();
+
+export function stopCcusageRuns(): void {
+  for (const proc of activeRuns) {
+    try {
+      proc.kill();
+    } catch {
+      // Already exited.
+    }
+  }
+  activeRuns.clear();
+}
+
 async function runCcusageJson(subcommandArgs: string[], timeoutMs = 25000): Promise<any | null> {
   const { cmd } = resolveCcusageBinary();
   let timer: ReturnType<typeof setTimeout> | undefined;
@@ -345,7 +360,10 @@ async function runCcusageJson(subcommandArgs: string[], timeoutMs = 25000): Prom
     const proc = Bun.spawn([...cmd, ...subcommandArgs, "--json", "-O"], {
       stdout: "pipe",
       stderr: "ignore",
+      windowsHide: true,
     });
+    activeRuns.add(proc);
+    void proc.exited.finally(() => activeRuns.delete(proc));
 
     timer = setTimeout(() => {
       try {

package/src/logFile.ts

@@ -0,0 +1,37 @@
+import { appendFileSync, writeFileSync } from "node:fs";
+
+// When the CLI starts the server in the background it has no terminal, so the server
+// writes its own output to the file named in TOKEN_LARPER_LOG_FILE (the CLI reads it
+// to learn the URL). Imported first by server.ts so nothing is missed.
+
+const file = process.env.TOKEN_LARPER_LOG_FILE;
+
+if (file) {
+  try {
+    writeFileSync(file, "");
+  } catch {
+    // Logging is best effort.
+  }
+  const write = (args: unknown[]) => {
+    try {
+      appendFileSync(file, args.map((a) => (a instanceof Error ? a.stack ?? a.message : String(a))).join(" ") + "\n");
+    } catch {
+      // Logging is best effort.
+    }
+  };
+  for (const level of ["log", "info", "warn", "error"] as const) {
+    const original = console[level].bind(console);
+    console[level] = (...args: unknown[]) => {
+      write(args);
+      original(...args);
+    };
+  }
+  process.on("uncaughtException", (error) => {
+    write(["Token Larper stopped:", error]);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    write(["Token Larper stopped:", reason]);
+    process.exit(1);
+  });
+}

package/src/server.ts

@@ -1,5 +1,6 @@
+import "./logFile.ts";
 import { join, resolve } from "node:path";
-import { getDashboardData } from "./ccusage.ts";
+import { getDashboardData, stopCcusageRuns } from "./ccusage.ts";
 import { getStartupStatus, repointStartupIfStale, setStartupStatus } from "./startup.ts";
 import { startSystemTray, stopSystemTray } from "./tray.ts";
 import { buildTrayStatus, parseTheme, saveTheme } from "./trayStatus.ts";
@@ -60,7 +61,7 @@ function openDashboard(port: number) {
       : process.platform === "darwin"
       ? `open http://localhost:${port}`
       : `xdg-open http://localhost:${port}`;
-  import("node:child_process").then(({ exec }) => exec(cmd));
+  import("node:child_process").then(({ exec }) => exec(cmd, { windowsHide: true }));
 }
 
 /** The version of a Token Larper already on the port, "0.0.0" for one too old to say, or null if none. */
@@ -82,6 +83,22 @@ async function runningVersion(port: number): Promise<string | null> {
   }
 }
 
+async function waitForPort(port: number, timeoutMs: number): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  let announced = false;
+  while (true) {
+    try {
+      Bun.serve({ port, hostname: "127.0.0.1", fetch: () => new Response() }).stop(true);
+      return true;
+    } catch {
+      if (Date.now() > deadline) return false;
+      if (!announced) console.log(`Waiting for port ${port} to be released...`);
+      announced = true;
+      await Bun.sleep(500);
+    }
+  }
+}
+
 // A newer copy (after an update, or a fresh npx run) replaces an older one on the
 // same port. The same or a newer version already running just gets opened.
 const running = await runningVersion(PORT);
@@ -98,6 +115,10 @@ if (running !== null && compareVersions(running, APP_VERSION) < 0) {
     // It may exit before answering.
   }
   for (let i = 0; i < 40 && (await runningVersion(PORT)) !== null; i++) await Bun.sleep(250);
+  // The old copy can stop answering before its port is free: on Windows, processes it
+  // started hold the socket until they exit. Wait for the port rather than moving to the
+  // next one, which the open dashboard isn't watching.
+  if (!(await waitForPort(PORT, 90_000))) console.warn(`Port ${PORT} is still taken after 90 s.`);
 } else if (running !== null) {
   console.log(`🔥 Token Larper is already running at http://localhost:${PORT}`);
   console.log(`🚀 Opening dashboard in your default browser...`);
@@ -231,8 +252,12 @@ function startServer(preferredPort: number) {
         return Response.json({ error: "This copy runs from a git checkout. Update it with git pull." }, { status: 409 });
       }
       try {
-        startUpdate(activePort);
-        return Response.json({ ok: true });
+        const status = await checkForUpdates();
+        if (!status.updateAvailable || !status.latest) {
+          return Response.json({ error: status.error ?? "Already on the latest version." }, { status: 409 });
+        }
+        startUpdate(activePort, status.latest);
+        return Response.json({ ok: true, version: status.latest });
       } catch (error) {
         return Response.json({ error: error instanceof Error ? error.message : "Could not start the update" }, { status: 500 });
       }
@@ -240,6 +265,7 @@ function startServer(preferredPort: number) {
 
     if (url.pathname === "/api/shutdown" && req.method === "POST") {
       setTimeout(() => {
+        stopCcusageRuns();
         stopSystemTray();
         server.stop(true);
         process.exit(0);
@@ -266,13 +292,12 @@ const server = startServer(PORT);
 startSystemTray(server.port ?? PORT);
 void repointStartupIfStale();
 
-process.on("SIGINT", () => {
-  stopSystemTray();
-  process.exit(0);
-});
-process.on("SIGTERM", () => {
-  stopSystemTray();
-  process.exit(0);
-});
+for (const signal of ["SIGINT", "SIGTERM"] as const) {
+  process.on(signal, () => {
+    stopCcusageRuns();
+    stopSystemTray();
+    process.exit(0);
+  });
+}
 
 console.log(`🔥 Token Larper running at http://localhost:${server.port} (System Tray Icon Active)`);

package/src/startup.ts

@@ -42,7 +42,7 @@ function saveSettings(settings: SavedSettings): void {
 }
 
 async function runReg(args: string[]): Promise<{ code: number; output: string; error: string }> {
-  const proc = Bun.spawn(["reg.exe", ...args], { stdout: "pipe", stderr: "pipe" });
+  const proc = Bun.spawn(["reg.exe", ...args], { stdout: "pipe", stderr: "pipe", windowsHide: true });
   const [output, error, code] = await Promise.all([
     new Response(proc.stdout).text(),
     new Response(proc.stderr).text(),

package/src/tray.ts

@@ -444,6 +444,7 @@ export async function startSystemTray(port: number): Promise<void> {
       {
         stdout: "pipe",
         stderr: "ignore",
+        windowsHide: true,
       }
     );
     const out = (await new Response(proc.stdout).text()).trim();
@@ -462,6 +463,7 @@ export function stopSystemTray(): void {
       Bun.spawnSync(["taskkill.exe", "/PID", String(trayPid), "/F"], {
         stdout: "ignore",
         stderr: "ignore",
+        windowsHide: true,
       });
     } catch {
       // ignore

package/src/updates.ts

@@ -48,15 +48,39 @@ export async function checkForUpdates(force = false): Promise<UpdateStatus> {
 }
 
 /**
- * Start the latest version in the background. The new copy sees this server running
- * an older version, asks it to shut down, and takes over the same port (bin/cli.js).
+ * Run a program in the background, independent of this server.
+ *
+ * On Windows every child of this server inherits its listening socket, which keeps the
+ * port taken until the child exits. Start-Process launches the program through the shell
+ * instead, so it inherits nothing, and gives it a hidden console that anything it starts
+ * shares instead of opening windows of their own. Arguments must not contain double quotes.
  */
-export function startUpdate(port: number): void {
-  const child = spawn(process.execPath, ["x", `${PACKAGE}@latest`], {
-    detached: true,
-    stdio: "ignore",
-    windowsHide: true,
-    env: { ...process.env, PORT: String(port), TOKEN_LARPER_NO_BROWSER: "1" },
+export function launchIndependent(program: string, args: string[], env: Record<string, string | undefined>): void {
+  if (process.platform === "win32") {
+    const quote = (value: string) => `'${value.replace(/'/g, "''")}'`;
+    const command = `Start-Process -WindowStyle Hidden -FilePath ${quote(program)} -ArgumentList ${args.map((a) => quote(`"${a}"`)).join(",")}`;
+    // Not detached: a PowerShell without any console fails to start the program.
+    spawn("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", command], {
+      stdio: "ignore",
+      windowsHide: true,
+      env,
+    }).unref();
+    return;
+  }
+  spawn(program, args, { detached: true, stdio: "ignore", env }).unref();
+}
+
+/**
+ * Start the given version in the background. The new copy sees this server running an
+ * older version, asks it to shut down, and takes over the same port (src/server.ts).
+ * The exact version is installed because `@latest` can resolve from bun's cached
+ * package list and bring back the version already running.
+ */
+export function startUpdate(port: number, version: string): void {
+  if (!/^\d+\.\d+\.\d+(?:-[\w.]+)?$/.test(version)) throw new Error(`Unexpected version "${version}"`);
+  launchIndependent(process.execPath, ["x", `${PACKAGE}@${version}`], {
+    ...process.env,
+    PORT: String(port),
+    TOKEN_LARPER_NO_BROWSER: "1",
   });
-  child.unref();
 }