kaizenai 0.4.0 → 0.6.0

package/dist/server/cli.js

@@ -1,14 +1,14 @@
 // @bun
 // src/server/cli.ts
 import { existsSync as existsSync10 } from "fs";
-import process9 from "process";
+import process10 from "process";
+import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "kaizenai",
   type: "module",
-  version: "0.4.0",
+  version: "0.6.0",
   description: "Local web UI for coding agents",
-  license: "MIT",
   keywords: [
     "claude",
     "claude-code",
@@ -44,15 +44,15 @@ var package_default = {
     bun: ">=1.3.5"
   },
   scripts: {
-    build: "vite build && bun run ./scripts/build-server.ts",
+    build: "vite build && bun ./scripts/build-server.ts",
     check: "tsc --noEmit && bun run build",
-    dev: "bun run ./scripts/dev.ts",
+    dev: "bun ./scripts/dev.ts",
     "dev:client": "vite --host 0.0.0.0 --port 5174",
-    "dev:server": "bun run ./scripts/dev-server.ts --no-open --port 5175",
+    "dev:server": "bun ./scripts/dev-server.ts --no-open --port 5175",
     fmt: "prettier package.json README.md --check",
     "install:dev": "bun install && bun run build && bun install -g .",
     lint: "tsc --noEmit",
-    start: "bun run ./dist/server/cli.js",
+    start: "bun ./dist/server/cli.js",
     test: "bun test",
     typecheck: "tsc --noEmit",
     prepublishOnly: "bun run build"
@@ -68,6 +68,7 @@ var package_default = {
     "@xterm/xterm": "^6.0.0",
     "default-shell": "^2.2.0",
     "puppeteer-core": "^24.40.0",
+    qrcode: "^1.5.4",
     "react-resizable-panels": "^4.7.3",
     sonner: "^2.0.7"
   },
@@ -159,8 +160,8 @@ function getProviderSettingsFilePath(homeDir, env = getRuntimeEnv()) {
 }
 
 // src/server/cli-runtime.ts
-import process2 from "process";
-import { spawnSync as spawnSync2 } from "child_process";
+import process3 from "process";
+import { spawnSync as spawnSync3 } from "child_process";
 
 // src/server/process-utils.ts
 import { spawn, spawnSync } from "child_process";
@@ -185,6 +186,277 @@ function canOpenMacApp(appName) {
 
 // src/shared/ports.ts
 var PROD_SERVER_PORT = 3210;
+var DEV_CLIENT_PORT = 5174;
+
+// src/server/remote-access.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { isIP } from "net";
+import QRCode from "qrcode";
+var TAILSCALE_COMMAND = "tailscale";
+var HTTPS_PORT = 443;
+var COMMAND_TIMEOUT_MS = 5000;
+function normalizeTailscaleHostname(hostname) {
+  if (!hostname)
+    return null;
+  const normalized = hostname.trim().replace(/\.+$/, "");
+  return normalized || null;
+}
+function selectPreferredTailscaleHost(status) {
+  const dnsName = normalizeTailscaleHostname(status.Self?.DNSName);
+  if (dnsName)
+    return dnsName;
+  const ip = status.Self?.TailscaleIPs?.find((candidate) => candidate.trim().length > 0)?.trim();
+  return ip || null;
+}
+function buildRemoteBaseUrl(host, port, protocol = "http") {
+  const url = new URL(`${protocol}://${host}`);
+  if (protocol === "https" && port !== HTTPS_PORT || protocol === "http" && port !== 80) {
+    url.port = String(port);
+  }
+  return url.toString().replace(/\/$/, "");
+}
+function buildHandoffUrl(remoteBaseUrl) {
+  return new URL("/open", `${remoteBaseUrl}/`).toString();
+}
+function buildRemoteSetupUrl(baseUrl, localPort) {
+  return buildRemoteSetupUrlWithOptions(baseUrl, localPort, {});
+}
+function buildRemoteSetupUrlWithOptions(baseUrl, localPort, options) {
+  const url = new URL("/remote-setup", `${baseUrl}/`);
+  url.searchParams.set("localPort", String(localPort));
+  if (options.setupReason) {
+    url.searchParams.set("reason", options.setupReason);
+  }
+  if (options.setupCommand) {
+    url.searchParams.set("setupCommand", options.setupCommand);
+  }
+  return url.toString();
+}
+function createRemoteAccessWarning(reason) {
+  if (reason === "missing") {
+    return "remote mode is available, but Tailscale is not installed. Install Tailscale to print a stable handoff QR code.";
+  }
+  if (reason === "disconnected") {
+    return "remote mode bound all interfaces, but Tailscale is not connected. Run `tailscale up` to enable QR handoff.";
+  }
+  if (reason === "https_requires_dns") {
+    return "Tailscale HTTPS handoff requires this machine\u2019s MagicDNS name. Falling back to HTTP because only a Tailscale IP was available.";
+  }
+  if (reason === "serve_unavailable") {
+    return "Tailscale HTTPS Serve was unavailable, so Kaizen fell back to an HTTP handoff URL.";
+  }
+  if (reason === "serve_not_enabled") {
+    return "Tailscale HTTPS Serve is not enabled on this tailnet, so Kaizen fell back to an HTTP handoff URL.";
+  }
+  if (reason === "serve_conflict") {
+    return "Tailscale HTTPS Serve is already configured for another local service on this machine, so Kaizen fell back to an HTTP handoff URL.";
+  }
+  if (reason === "serve_permission_denied") {
+    return "Kaizen could not enable Tailscale HTTPS Serve because this user is not allowed to change Tailscale Serve config yet.";
+  }
+  if (reason === "serve_failed") {
+    return "Kaizen could not enable Tailscale HTTPS Serve and fell back to an HTTP handoff URL.";
+  }
+  return "remote mode bound all interfaces, but Kaizen could not resolve this machine\u2019s Tailscale address.";
+}
+function readTailscaleStatus() {
+  const result = spawnSync2(TAILSCALE_COMMAND, ["status", "--json"], {
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf8",
+    timeout: COMMAND_TIMEOUT_MS
+  });
+  if (result.status !== 0) {
+    return null;
+  }
+  try {
+    return JSON.parse(result.stdout);
+  } catch {
+    return null;
+  }
+}
+function readTailscaleServeStatus() {
+  const result = spawnSync2(TAILSCALE_COMMAND, ["serve", "status", "--json"], {
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf8",
+    timeout: COMMAND_TIMEOUT_MS
+  });
+  if (result.status !== 0) {
+    return null;
+  }
+  try {
+    return JSON.parse(result.stdout);
+  } catch {
+    return null;
+  }
+}
+function enableTailscaleServeHttps(targetUrl) {
+  const result = spawnSync2(TAILSCALE_COMMAND, ["serve", "--bg", "--yes", "--https", String(HTTPS_PORT), targetUrl], {
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf8",
+    timeout: COMMAND_TIMEOUT_MS
+  });
+  return {
+    ok: result.status === 0,
+    output: `${result.stdout ?? ""}
+${result.stderr ?? ""}`.trim()
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isEmptyTailscaleServeStatus(status) {
+  const topLevelValues = Object.values(status);
+  if (topLevelValues.length === 0)
+    return true;
+  return topLevelValues.every((value) => isRecord(value) && Object.keys(value).length === 0);
+}
+function buildServeTargetCandidates(localUrl, port) {
+  return [
+    localUrl,
+    `http://127.0.0.1:${String(port)}`,
+    `http://localhost:${String(port)}`,
+    `127.0.0.1:${String(port)}`,
+    `localhost:${String(port)}`,
+    String(port)
+  ];
+}
+function isKaizenServeConfig(status, localUrl, port, runtimeProfile) {
+  const serialized = JSON.stringify(status);
+  const currentTargets = buildServeTargetCandidates(localUrl, port);
+  if (currentTargets.some((candidate) => serialized.includes(candidate))) {
+    return true;
+  }
+  if (runtimeProfile !== "dev") {
+    const defaultDevTargets = [
+      `http://127.0.0.1:${String(DEV_CLIENT_PORT)}`,
+      `http://localhost:${String(DEV_CLIENT_PORT)}`,
+      `127.0.0.1:${String(DEV_CLIENT_PORT)}`,
+      `localhost:${String(DEV_CLIENT_PORT)}`
+    ];
+    return defaultDevTargets.some((candidate) => serialized.includes(candidate));
+  }
+  return false;
+}
+function canUseTailscaleHttps(host) {
+  return isIP(host) === 0 && host.includes(".");
+}
+function createServeOperatorSetupCommand() {
+  return "sudo tailscale set --operator=$USER";
+}
+function createDefaultRemoteAccessDeps() {
+  return {
+    hasCommand,
+    readTailscaleStatus,
+    readTailscaleServeStatus,
+    enableTailscaleServeHttps
+  };
+}
+async function resolveRemoteAccessInfo(options, deps = createDefaultRemoteAccessDeps()) {
+  const fallback = {
+    localUrl: options.localUrl,
+    remoteBaseUrl: null,
+    handoffUrl: null,
+    warning: null,
+    setupCommand: null,
+    setupReason: null
+  };
+  if (!deps.hasCommand(TAILSCALE_COMMAND)) {
+    return {
+      ...fallback,
+      warning: createRemoteAccessWarning("missing")
+    };
+  }
+  const status = deps.readTailscaleStatus();
+  if (!status) {
+    return {
+      ...fallback,
+      warning: createRemoteAccessWarning("unavailable")
+    };
+  }
+  if (status.BackendState && status.BackendState !== "Running") {
+    return {
+      ...fallback,
+      warning: createRemoteAccessWarning("disconnected")
+    };
+  }
+  const host = selectPreferredTailscaleHost(status);
+  if (!host) {
+    return {
+      ...fallback,
+      warning: createRemoteAccessWarning("unavailable")
+    };
+  }
+  let warning = null;
+  let remoteBaseUrl;
+  let setupCommand = null;
+  let setupReason = null;
+  const runtimeProfile = options.runtimeProfile ?? getRuntimeProfile();
+  if (canUseTailscaleHttps(host)) {
+    const serveStatus = deps.readTailscaleServeStatus();
+    if (!serveStatus) {
+      warning = createRemoteAccessWarning("serve_unavailable");
+      remoteBaseUrl = buildRemoteBaseUrl(host, options.port);
+    } else if (!isEmptyTailscaleServeStatus(serveStatus) && !isKaizenServeConfig(serveStatus, options.localUrl, options.port, runtimeProfile)) {
+      warning = createRemoteAccessWarning("serve_conflict");
+      remoteBaseUrl = buildRemoteBaseUrl(host, options.port);
+    } else {
+      const serveResult = deps.enableTailscaleServeHttps(`http://127.0.0.1:${String(options.port)}`);
+      if (serveResult.ok) {
+        remoteBaseUrl = buildRemoteBaseUrl(host, HTTPS_PORT, "https");
+      } else {
+        const output = serveResult.output.toLowerCase();
+        if (output.includes("serve config denied") || output.includes("to not require root") || output.includes("set --operator")) {
+          warning = createRemoteAccessWarning("serve_permission_denied");
+          setupCommand = createServeOperatorSetupCommand();
+          setupReason = "serve_permission_denied";
+        } else {
+          warning = createRemoteAccessWarning(output.includes("serve is not enabled on your tailnet") ? "serve_not_enabled" : "serve_failed");
+        }
+        remoteBaseUrl = buildRemoteBaseUrl(host, options.port);
+      }
+    }
+  } else {
+    warning = createRemoteAccessWarning("https_requires_dns");
+    remoteBaseUrl = buildRemoteBaseUrl(host, options.port);
+  }
+  return {
+    ...fallback,
+    remoteBaseUrl,
+    handoffUrl: buildHandoffUrl(remoteBaseUrl),
+    warning,
+    setupCommand,
+    setupReason
+  };
+}
+async function renderTerminalQrCode(url) {
+  return QRCode.toString(url, {
+    type: "terminal",
+    small: true,
+    margin: 1
+  });
+}
+
+// src/server/terminal-output.ts
+import process2 from "process";
+var ANSI_RESET = "\x1B[0m";
+var ANSI_BOLD = "\x1B[1m";
+var ANSI_CYAN = "\x1B[36m";
+var ANSI_YELLOW = "\x1B[33m";
+function shouldUseAnsiColor() {
+  return process2.stdout.isTTY === true || process2.stderr.isTTY === true;
+}
+function formatTerminalHighlight(label, value) {
+  if (!shouldUseAnsiColor()) {
+    return `${label}${value}`;
+  }
+  return `${ANSI_BOLD}${ANSI_CYAN}${label}${ANSI_RESET}${value}`;
+}
+function formatTerminalWarning(message) {
+  if (!shouldUseAnsiColor()) {
+    return message;
+  }
+  return `${ANSI_BOLD}${ANSI_YELLOW}${message}${ANSI_RESET}`;
+}
 
 // src/server/restart.ts
 var CLI_CHILD_MODE_ENV_VAR = "KAIZEN_CLI_MODE";
@@ -241,6 +513,7 @@ function parseChildArgsEnv(value) {
 
 // src/server/cli-runtime.ts
 var MINIMUM_BUN_VERSION = "1.3.5";
+var SUPPRESS_REMOTE_STARTUP_OUTPUT_ENV_VAR = "KAIZEN_SUPPRESS_REMOTE_STARTUP_OUTPUT";
 function printHelp() {
   console.log(`${APP_NAME} \u2014 local-only project chat UI
 
@@ -250,7 +523,7 @@ Usage:
 Options:
   --port <number>      Port to listen on (default: ${PROD_SERVER_PORT})
   --host <host>        Bind to a specific host or IP
-  --remote             Shortcut for --host 0.0.0.0
+  --remote             Share to your Tailscale devices and print a QR handoff
   --strict-port        Fail instead of trying another port
   --no-open            Don't open browser automatically
   --version            Print version and exit
@@ -261,6 +534,7 @@ function parseArgs(argv) {
   let host = "127.0.0.1";
   let openBrowser = true;
   let strictPort = false;
+  let remoteMode = false;
   for (let index = 0;index < argv.length; index += 1) {
     const arg = argv[index];
     if (arg === "--version" || arg === "-v") {
@@ -287,6 +561,7 @@ function parseArgs(argv) {
     }
     if (arg === "--remote") {
       host = "0.0.0.0";
+      remoteMode = true;
       continue;
     }
     if (arg === "--no-open") {
@@ -306,7 +581,8 @@ function parseArgs(argv) {
       port,
       host,
       openBrowser,
-      strictPort
+      strictPort,
+      remoteMode
     }
   };
 }
@@ -323,14 +599,25 @@ function compareVersions(currentVersion, latestVersion) {
   }
   return 0;
 }
+function isNpxRuntimePath(value) {
+  return /(^|[\\/])_npx([\\/]|$)/.test(value);
+}
+function createUnsupportedNpxInstallResult() {
+  return {
+    ok: false,
+    errorCode: "install_failed",
+    userTitle: "Update unavailable in npx",
+    userMessage: "Kaizen cannot self-update while running from npx. Rerun `npx kaizenai` to get the latest version, or install it globally with `npm install -g kaizenai`."
+  };
+}
 function normalizeVersion(version) {
   return version.trim().replace(/^v/i, "").split("-")[0].split(".").map((part) => Number.parseInt(part, 10)).filter((part) => Number.isFinite(part));
 }
 async function maybeSelfUpdate(_argv, deps) {
-  if (process2.env[DISABLE_SELF_UPDATE_ENV_VAR] === "1") {
+  if (process3.env[DISABLE_SELF_UPDATE_ENV_VAR] === "1") {
     return null;
   }
-  if (shouldSkipStartupUpdateOnce(process2.env[CLI_SKIP_STARTUP_UPDATE_ONCE_ENV_VAR])) {
+  if (shouldSkipStartupUpdateOnce(process3.env[CLI_SKIP_STARTUP_UPDATE_ONCE_ENV_VAR])) {
     deps.warn(`${LOG_PREFIX} skipping startup update after restart to avoid an update loop`);
     return null;
   }
@@ -395,8 +682,34 @@ async function runCli(argv, deps) {
   const displayHost = bindHost === "127.0.0.1" || bindHost === "0.0.0.0" ? "localhost" : bindHost;
   const launchUrl = `http://${displayHost}:${port}`;
   deps.log(`${LOG_PREFIX} listening on http://${bindHost}:${port}`);
+  deps.log(`${LOG_PREFIX} local URL: ${launchUrl}`);
   deps.log(`${LOG_PREFIX} data dir: ${getDataDirDisplay()}`);
-  const suppressOpenBrowser = process2.env[CLI_SUPPRESS_OPEN_ONCE_ENV_VAR] === "1";
+  if (parsedArgs.options.remoteMode && process3.env[SUPPRESS_REMOTE_STARTUP_OUTPUT_ENV_VAR] !== "1") {
+    const remoteAccess = await deps.resolveRemoteAccessInfo({
+      localUrl: launchUrl,
+      port,
+      runtimeProfile: getRuntimeProfile()
+    });
+    deps.log(formatTerminalHighlight(`${LOG_PREFIX} remote setup help: `, buildRemoteSetupUrlWithOptions(launchUrl, port, {
+      setupReason: remoteAccess.setupReason,
+      setupCommand: remoteAccess.setupCommand
+    })));
+    if (remoteAccess.warning) {
+      deps.warn(formatTerminalWarning(`${LOG_PREFIX} ${remoteAccess.warning}`));
+      if (remoteAccess.setupCommand) {
+        deps.warn(formatTerminalHighlight(`${LOG_PREFIX} one-time Tailscale fix: `, remoteAccess.setupCommand));
+      }
+    }
+    if (remoteAccess.remoteBaseUrl && remoteAccess.handoffUrl) {
+      deps.log(`${LOG_PREFIX} Tailscale URL: ${remoteAccess.remoteBaseUrl}`);
+      deps.log(`${LOG_PREFIX} handoff URL: ${remoteAccess.handoffUrl}`);
+      deps.log(`${LOG_PREFIX} scan to open on another Tailscale device:`);
+      deps.log((await deps.renderTerminalQrCode(remoteAccess.handoffUrl)).trimEnd());
+    }
+  } else {
+    deps.log(formatTerminalHighlight(`${LOG_PREFIX} remote setup help: `, buildRemoteSetupUrl(launchUrl, port)));
+  }
+  const suppressOpenBrowser = process3.env[CLI_SUPPRESS_OPEN_ONCE_ENV_VAR] === "1";
   if (parsedArgs.options.openBrowser && !suppressOpenBrowser) {
     deps.openUrl(launchUrl);
   }
@@ -406,7 +719,7 @@ async function runCli(argv, deps) {
   };
 }
 function openUrl(url) {
-  const platform = process2.platform;
+  const platform = process3.platform;
   if (platform === "darwin") {
     spawnDetached("open", [url]);
   } else if (platform === "win32") {
@@ -453,16 +766,16 @@ function installPackageVersion(packageName, version) {
       userMessage: "Kaizen could not find Bun to install the update."
     };
   }
-  const result = spawnSync2("bun", ["install", "-g", `${packageName}@${version}`], {
+  const result = spawnSync3("bun", ["install", "-g", `${packageName}@${version}`], {
     stdio: ["ignore", "pipe", "pipe"],
     encoding: "utf8"
   });
   const stdout = result.stdout ?? "";
   const stderr = result.stderr ?? "";
   if (stdout)
-    process2.stdout.write(stdout);
+    process3.stdout.write(stdout);
   if (stderr)
-    process2.stderr.write(stderr);
+    process3.stderr.write(stderr);
   if (result.status === 0) {
     return {
       ok: true,
@@ -500,6 +813,11 @@ var CODEX_REASONING_OPTIONS = [
   { id: "high", label: "High" },
   { id: "xhigh", label: "XHigh" }
 ];
+var CLAUDE_CONTEXT_WINDOW_FALLBACKS = {
+  sonnet: 1e6,
+  opus: 1e6,
+  haiku: 200000
+};
 var GEMINI_THINKING_OPTIONS = [
   { id: "off", label: "Off" },
   { id: "standard", label: "Standard" },
@@ -1085,6 +1403,7 @@ class EventStore {
     await this.ensureFile(this.turnsLogPath);
     await this.loadSnapshot();
     await this.replayLogs();
+    await this.repairDuplicateSessionTokens();
     this.hydrateProjectWorktrees();
     await this.reconcileAllProjectFeatureState();
     if (!await this.hasLegacyTranscriptData() && await this.shouldCompact()) {
@@ -1552,6 +1871,29 @@ class EventStore {
     }
     return entries;
   }
+  async repairDuplicateSessionTokens() {
+    const chatsBySessionKey = new Map;
+    for (const chat of this.state.chatsById.values()) {
+      if (chat.deletedAt)
+        continue;
+      const sessionKey = this.getChatPersistenceKey(chat);
+      if (!sessionKey)
+        continue;
+      const existing = chatsBySessionKey.get(sessionKey) ?? [];
+      existing.push(chat);
+      chatsBySessionKey.set(sessionKey, existing);
+    }
+    for (const chats of chatsBySessionKey.values()) {
+      if (chats.length < 2)
+        continue;
+      const [keeper, ...duplicates] = [...chats].sort((left, right) => right.updatedAt - left.updatedAt || (right.lastMessageAt ?? 0) - (left.lastMessageAt ?? 0) || right.createdAt - left.createdAt);
+      for (const duplicate of duplicates) {
+        if (!duplicate.sessionToken)
+          continue;
+        await this.setSessionToken(duplicate.id, null);
+      }
+    }
+  }
   async openProject(localPath, title) {
     const identity = resolveProjectRepositoryIdentity(localPath);
     const worktreePaths = identity.isGitRepo ? resolveProjectWorktreePaths(identity.worktreePath) : [identity.worktreePath];
@@ -2019,15 +2361,33 @@ class EventStore {
     const chat = this.requireChat(chatId);
     if (chat.sessionToken === sessionToken)
       return;
-    const event = {
+    const affectedProjectIds = new Set([chat.projectId]);
+    if (sessionToken && chat.provider) {
+      for (const candidate of this.state.chatsById.values()) {
+        if (candidate.id === chatId || candidate.deletedAt)
+          continue;
+        if (candidate.provider !== chat.provider || candidate.sessionToken !== sessionToken)
+          continue;
+        affectedProjectIds.add(candidate.projectId);
+        await this.append(this.turnsLogPath, {
+          v: STORE_VERSION,
+          type: "session_token_set",
+          timestamp: Date.now(),
+          chatId: candidate.id,
+          sessionToken: null
+        });
+      }
+    }
+    await this.append(this.turnsLogPath, {
       v: STORE_VERSION,
       type: "session_token_set",
       timestamp: Date.now(),
       chatId,
       sessionToken
-    };
-    await this.append(this.turnsLogPath, event);
-    await this.syncProjectFeatureState(chat.projectId);
+    });
+    for (const projectId of affectedProjectIds) {
+      await this.syncProjectFeatureState(projectId);
+    }
   }
   async reconcileProjectFeatureState(projectId) {
     const project = this.getProject(projectId);
@@ -2391,7 +2751,9 @@ class EventStore {
 }
 
 // src/server/agent.ts
-import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
+import {
+  query as query2
+} from "@anthropic-ai/claude-agent-sdk";
 
 // src/shared/tools.ts
 function normalizeToolCall(args) {
@@ -3169,7 +3531,7 @@ class CodexAppServerManager {
   }
   async startSession(args) {
     const existing = this.sessions.get(args.chatId);
-    if (existing && !existing.closed && existing.cwd === args.cwd) {
+    if (existing && !existing.closed && existing.cwd === args.cwd && existing.sessionToken === args.sessionToken) {
       return;
     }
     if (existing) {
@@ -5576,7 +5938,7 @@ function codexServiceTierFromModelOptions(modelOptions) {
 import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir4 } from "os";
 import path7 from "path";
-import process3 from "process";
+import process4 from "process";
 
 // src/server/usage/base-provider-usage.ts
 import { existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
@@ -5672,6 +6034,69 @@ function usageWarnings(args) {
   }
   return warnings;
 }
+function relevantMessagesForCurrentContext(messages) {
+  let lastContextClearedIndex = -1;
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    if (messages[index]?.kind === "context_cleared") {
+      lastContextClearedIndex = index;
+      break;
+    }
+  }
+  return lastContextClearedIndex >= 0 ? messages.slice(lastContextClearedIndex + 1) : messages;
+}
+function estimateTokenCountFromText(text) {
+  if (!text)
+    return 0;
+  const trimmed = text.trim();
+  if (!trimmed)
+    return 0;
+  return Math.ceil(trimmed.length / 4);
+}
+function estimateTokenCountFromUnknown(value) {
+  if (typeof value === "string") {
+    return estimateTokenCountFromText(value);
+  }
+  try {
+    return estimateTokenCountFromText(JSON.stringify(value));
+  } catch {
+    return 0;
+  }
+}
+function estimateCurrentThreadTokens(messages) {
+  let total = 0;
+  for (const entry of relevantMessagesForCurrentContext(messages)) {
+    switch (entry.kind) {
+      case "user_prompt":
+        total += estimateTokenCountFromText(entry.content);
+        if (entry.attachments?.length) {
+          total += entry.attachments.length * 256;
+        }
+        break;
+      case "assistant_text":
+        total += estimateTokenCountFromText(entry.text);
+        break;
+      case "compact_summary":
+        total += estimateTokenCountFromText(entry.summary);
+        break;
+      case "result":
+        total += estimateTokenCountFromText(entry.result);
+        break;
+      case "tool_call":
+        total += estimateTokenCountFromText(entry.tool.toolName);
+        total += estimateTokenCountFromUnknown(entry.tool.input);
+        break;
+      case "tool_result":
+        total += estimateTokenCountFromUnknown(entry.content);
+        break;
+      case "status":
+        total += estimateTokenCountFromText(entry.status);
+        break;
+      default:
+        break;
+    }
+  }
+  return total;
+}
 function buildSnapshot(args) {
   const contextUsedPercent = args.threadTokens !== null && args.contextWindowTokens && args.contextWindowTokens > 0 ? toPercent(args.threadTokens / args.contextWindowTokens * 100) : null;
   const snapshot = {
@@ -5706,6 +6131,65 @@ function buildSnapshot(args) {
   ].some((value) => value !== null);
   return hasAnyData ? snapshot : null;
 }
+function usageTotals(usage) {
+  const inputTokens = toNumber(usage.input_tokens) ?? 0;
+  const outputTokens = toNumber(usage.output_tokens) ?? 0;
+  const cachedInputTokens = (toNumber(usage.cache_read_input_tokens) ?? 0) + (toNumber(usage.cache_creation_input_tokens) ?? 0);
+  const reasoningOutputTokens = toNumber(usage.reasoning_output_tokens) ?? 0;
+  return {
+    inputTokens,
+    outputTokens,
+    cachedInputTokens,
+    reasoningOutputTokens,
+    totalTokens: inputTokens + outputTokens + cachedInputTokens + reasoningOutputTokens
+  };
+}
+function mergeUsageSnapshots(reconstructed, live) {
+  if (!reconstructed)
+    return live;
+  if (!live)
+    return reconstructed;
+  const merged = {
+    ...reconstructed,
+    ...live,
+    provider: live.provider,
+    threadTokens: live.threadTokens ?? reconstructed.threadTokens,
+    contextWindowTokens: live.contextWindowTokens ?? reconstructed.contextWindowTokens,
+    contextUsedPercent: live.contextUsedPercent ?? reconstructed.contextUsedPercent,
+    lastTurnTokens: live.lastTurnTokens ?? reconstructed.lastTurnTokens,
+    inputTokens: live.inputTokens ?? reconstructed.inputTokens,
+    outputTokens: live.outputTokens ?? reconstructed.outputTokens,
+    cachedInputTokens: live.cachedInputTokens ?? reconstructed.cachedInputTokens,
+    reasoningOutputTokens: live.reasoningOutputTokens ?? reconstructed.reasoningOutputTokens,
+    sessionLimitUsedPercent: live.sessionLimitUsedPercent ?? reconstructed.sessionLimitUsedPercent,
+    rateLimitResetAt: live.rateLimitResetAt ?? reconstructed.rateLimitResetAt,
+    source: live.source === "live" ? "live" : reconstructed.source,
+    updatedAt: live.updatedAt ?? reconstructed.updatedAt,
+    warnings: []
+  };
+  merged.warnings = usageWarnings({
+    contextUsedPercent: merged.contextUsedPercent,
+    sessionLimitUsedPercent: merged.sessionLimitUsedPercent,
+    updatedAt: merged.updatedAt
+  });
+  return merged;
+}
+function applyThreadEstimate(snapshot, messages) {
+  const estimatedThreadTokens = estimateCurrentThreadTokens(messages);
+  if (!snapshot)
+    return null;
+  const contextUsedPercent = snapshot.contextWindowTokens && snapshot.contextWindowTokens > 0 ? toPercent(estimatedThreadTokens / snapshot.contextWindowTokens * 100) : null;
+  return {
+    ...snapshot,
+    threadTokens: estimatedThreadTokens,
+    contextUsedPercent,
+    warnings: usageWarnings({
+      contextUsedPercent,
+      sessionLimitUsedPercent: snapshot.sessionLimitUsedPercent,
+      updatedAt: snapshot.updatedAt
+    })
+  };
+}
 function deriveAvailability(updatedAt) {
   if (updatedAt === null)
     return "available";
@@ -5773,6 +6257,77 @@ function unavailableEntry(provider) {
 // src/server/usage/claude-usage.ts
 var PROVIDER_CACHE_TTL_MS = 30000;
 var PROVIDER_USAGE_REQUEST_MIN_INTERVAL_MS = 30 * 60 * 1000;
+function extractClaudeUsageRecord(entry) {
+  if (!entry.debugRaw)
+    return null;
+  const raw = parseJsonLine3(entry.debugRaw);
+  if (!raw)
+    return null;
+  const type = raw.type;
+  if (type !== "assistant" && type !== "result")
+    return null;
+  if (type === "assistant") {
+    const message = asRecord3(raw.message);
+    const usage2 = asRecord3(message?.usage);
+    if (!usage2)
+      return null;
+    const usageTotalsRecord2 = usageTotals(usage2);
+    return {
+      key: typeof raw.uuid === "string" ? raw.uuid : entry.messageId ?? entry._id,
+      updatedAt: entry.createdAt,
+      totals: usageTotalsRecord2,
+      contextWindowTokens: null
+    };
+  }
+  const usage = asRecord3(raw.usage);
+  const modelUsage = asRecord3(raw.modelUsage);
+  const firstModel = modelUsage ? Object.values(modelUsage).map((value) => asRecord3(value)).find(Boolean) ?? null : null;
+  if (!usage && !firstModel)
+    return null;
+  const usageTotalsRecord = usage ? usageTotals(usage) : {
+    inputTokens: toNumber(firstModel?.inputTokens) ?? 0,
+    outputTokens: toNumber(firstModel?.outputTokens) ?? 0,
+    cachedInputTokens: (toNumber(firstModel?.cacheReadInputTokens) ?? 0) + (toNumber(firstModel?.cacheCreationInputTokens) ?? 0),
+    reasoningOutputTokens: 0,
+    totalTokens: (toNumber(firstModel?.inputTokens) ?? 0) + (toNumber(firstModel?.outputTokens) ?? 0) + (toNumber(firstModel?.cacheReadInputTokens) ?? 0) + (toNumber(firstModel?.cacheCreationInputTokens) ?? 0)
+  };
+  return {
+    key: typeof raw.uuid === "string" ? raw.uuid : entry.messageId ?? entry._id,
+    updatedAt: entry.createdAt,
+    totals: usageTotalsRecord,
+    contextWindowTokens: toNumber(firstModel?.contextWindow)
+  };
+}
+function reconstructClaudeUsage(messages, liveRateLimit) {
+  const relevantMessages = relevantMessagesForCurrentContext(messages);
+  const deduped = new Map;
+  for (const entry of relevantMessages) {
+    const usageRecord = extractClaudeUsageRecord(entry);
+    if (!usageRecord)
+      continue;
+    deduped.set(usageRecord.key, usageRecord);
+  }
+  const latest = [...deduped.values()].filter((value) => Boolean(value)).sort((a, b) => b.updatedAt - a.updatedAt)[0];
+  if (!latest && liveRateLimit?.percent == null) {
+    return null;
+  }
+  const latestModel = [...relevantMessages].reverse().find((entry) => entry.kind === "system_init" && entry.provider === "claude");
+  const fallbackContextWindow = latestModel ? CLAUDE_CONTEXT_WINDOW_FALLBACKS[latestModel.model.toLowerCase()] ?? null : null;
+  return buildSnapshot({
+    provider: "claude",
+    threadTokens: estimateCurrentThreadTokens(messages),
+    contextWindowTokens: latest?.contextWindowTokens ?? fallbackContextWindow,
+    lastTurnTokens: latest?.totals.totalTokens ?? null,
+    inputTokens: latest?.totals.inputTokens ?? null,
+    outputTokens: latest?.totals.outputTokens ?? null,
+    cachedInputTokens: latest?.totals.cachedInputTokens ?? null,
+    reasoningOutputTokens: latest?.totals.reasoningOutputTokens ?? null,
+    sessionLimitUsedPercent: liveRateLimit?.percent ?? null,
+    rateLimitResetAt: liveRateLimit?.resetsAt ?? null,
+    source: latest ? "reconstructed" : "live",
+    updatedAt: latest?.updatedAt ?? null
+  });
+}
 function createClaudeRateLimitSnapshot(percent, resetsAt) {
   return buildSnapshot({
     provider: "claude",
@@ -5915,7 +6470,7 @@ function collectClaudeUsageScreen(args) {
     stderr: "pipe",
     cwd: args?.cwd,
     env: {
-      ...process3.env,
+      ...process4.env,
       ...args?.cwd ? { CLAUDE_USAGE_CWD: args.cwd } : {},
       CLAUDE_USAGE_CONTINUE: args?.continueSession ? "1" : "0"
     }
@@ -5924,7 +6479,7 @@ function collectClaudeUsageScreen(args) {
 }
 function isRunningPid(pid) {
   try {
-    process3.kill(pid, 0);
+    process4.kill(pid, 0);
     return true;
   } catch {
     return false;
@@ -6272,7 +6827,7 @@ import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync
 import { mkdtempSync as mkdtempSync2, rmSync as rmSync2 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
 import path10 from "path";
-import process5 from "process";
+import process6 from "process";
 import puppeteer from "puppeteer-core";
 
 // src/server/usage/cursor-cookies.ts
@@ -6281,7 +6836,7 @@ import { copyFileSync, existsSync as existsSync5, mkdtempSync, readdirSync as re
 import { createDecipheriv, pbkdf2Sync } from "crypto";
 import { homedir as homedir6, tmpdir as tmpdir2 } from "os";
 import path9 from "path";
-import process4 from "process";
+import process5 from "process";
 var CHROME_EPOCH_OFFSET_MS = Date.UTC(1601, 0, 1);
 var CURSOR_SESSION_COOKIE_NAME = "WorkosCursorSessionToken";
 function normalizeCookieDomain(domain) {
@@ -6578,7 +7133,7 @@ function decryptChromiumCookieValue(encryptedValue, key, platform) {
     return null;
   }
 }
-function bootstrapCursorSessionFromBrowser(platform = process4.platform) {
+function bootstrapCursorSessionFromBrowser(platform = process5.platform) {
   if (platform !== "linux" && platform !== "darwin")
     return null;
   for (const source of discoverChromiumCookieSources(platform)) {
@@ -6912,7 +7467,7 @@ class CursorUsage extends BaseProviderUsage {
       return null;
     }
   }
-  async refresh(platform = process5.platform, force = false) {
+  async refresh(platform = process6.platform, force = false) {
     const now = Date.now();
     const persistedEntry = this.loadPersistedEntry();
     const lastRequestedAt = persistedEntry?.lastRequestedAt ?? this.readLastRequestedAt(this.provider);
@@ -6977,7 +7532,7 @@ class CursorUsage extends BaseProviderUsage {
     this.persistUsageEntry(entry);
     return entry;
   }
-  async importFromCurl(curlCommand, platform = process5.platform) {
+  async importFromCurl(curlCommand, platform = process6.platform) {
     const imported = importCursorSessionFromCurl(curlCommand);
     if (!imported) {
       return cursorStatusEntry({
@@ -6995,7 +7550,7 @@ class CursorUsage extends BaseProviderUsage {
     this.persistSession(session);
     return this.refresh(platform);
   }
-  async signInWithBrowser(platform = process5.platform) {
+  async signInWithBrowser(platform = process6.platform) {
     const executablePath = resolveBrowserExecutable(platform);
     if (!executablePath) {
       return cursorStatusEntry({
@@ -7068,13 +7623,13 @@ function getCursorUsage(dataDir) {
   }
   return _instances3.get(dataDir);
 }
-async function refreshCursorUsage(dataDir, platform = process5.platform, force = false) {
+async function refreshCursorUsage(dataDir, platform = process6.platform, force = false) {
   return getCursorUsage(dataDir).refresh(platform, force);
 }
-async function importCursorUsageFromCurl(dataDir, curlCommand, platform = process5.platform) {
+async function importCursorUsageFromCurl(dataDir, curlCommand, platform = process6.platform) {
   return getCursorUsage(dataDir).importFromCurl(curlCommand, platform);
 }
-async function signInToCursorWithBrowser(dataDir, platform = process5.platform) {
+async function signInToCursorWithBrowser(dataDir, platform = process6.platform) {
   return getCursorUsage(dataDir).signInWithBrowser(platform);
 }
 
@@ -7222,10 +7777,21 @@ function formatRecoveredAskUserQuestionFollowUp(tool, result) {
   ].join(`
 `);
 }
-function planModeFollowUp(result) {
+function planModeFollowUp(result, plan) {
   let text = "";
   if (result.confirmed) {
-    text = result.message ? `Proceed with the approved plan. Additional guidance: ${result.message}` : "Proceed with the approved plan.";
+    const trimmedPlan = plan?.trim();
+    const sections = [
+      trimmedPlan ? "Proceed with the approved plan below." : "Proceed with the approved plan."
+    ];
+    if (trimmedPlan) {
+      sections.push("", "Approved plan:", trimmedPlan);
+    }
+    if (result.message) {
+      sections.push("", `Additional guidance: ${result.message}`);
+    }
+    text = sections.join(`
+`);
   } else {
     text = result.message ? `Revise the plan using this feedback: ${result.message}` : "Revise the plan using this feedback.";
   }
@@ -7321,7 +7887,14 @@ function normalizeClaudeStreamMessage(message) {
     ];
   }
   if (message.type === "system" && message.subtype === "status" && typeof message.status === "string") {
-    return [timestamped3({ kind: "status", messageId, status: message.status, debugRaw })];
+    return [
+      timestamped3({
+        kind: "status",
+        messageId,
+        status: message.status,
+        debugRaw
+      })
+    ];
   }
   if (message.type === "system" && message.subtype === "compact_boundary") {
     return [timestamped3({ kind: "compact_boundary", messageId, debugRaw })];
@@ -7330,7 +7903,14 @@ function normalizeClaudeStreamMessage(message) {
     return [timestamped3({ kind: "context_cleared", messageId, debugRaw })];
   }
   if (message.type === "user" && message.message?.role === "user" && typeof message.message.content === "string" && message.message.content.startsWith("This session is being continued")) {
-    return [timestamped3({ kind: "compact_summary", messageId, summary: message.message.content, debugRaw })];
+    return [
+      timestamped3({
+        kind: "compact_summary",
+        messageId,
+        summary: message.message.content,
+        debugRaw
+      })
+    ];
   }
   return [];
 }
@@ -7968,7 +8548,7 @@ class AgentCoordinator {
         await this.store.setSessionToken(command.chatId, null);
         await this.store.appendMessage(command.chatId, timestamped3({ kind: "context_cleared" }));
       }
-      const followUp = planModeFollowUp(result);
+      const followUp = planModeFollowUp(result, recoveredPending.input.plan);
       const messageEntry = timestamped3({
         kind: "user_prompt",
         content: followUp.content
@@ -8016,7 +8596,7 @@ class AgentCoordinator {
         await this.store.appendMessage(command.chatId, timestamped3({ kind: "context_cleared" }));
       }
       if (shouldUseSyntheticPlanFollowUp(active.provider, pending.tool)) {
-        active.postToolFollowUp = planModeFollowUp(result);
+        active.postToolFollowUp = planModeFollowUp(result, pending.tool.input.plan);
       }
     }
     pending.resolve(command.result);
@@ -9702,17 +10282,17 @@ function formatDisplayPath3(filePath) {
 
 // src/server/machine-name.ts
 import { hostname } from "os";
-import process6 from "process";
-import { spawnSync as spawnSync3 } from "child_process";
+import process7 from "process";
+import { spawnSync as spawnSync4 } from "child_process";
 function runAndRead(command, args) {
-  const result = spawnSync3(command, args, { encoding: "utf8" });
+  const result = spawnSync4(command, args, { encoding: "utf8" });
   if (result.status !== 0)
     return null;
   const value = result.stdout.trim();
   return value || null;
 }
 function getMachineDisplayName() {
-  if (process6.platform === "darwin") {
+  if (process7.platform === "darwin") {
     const computerName = runAndRead("scutil", ["--get", "ComputerName"]);
     if (computerName) {
       return computerName;
@@ -9724,15 +10304,15 @@ function getMachineDisplayName() {
 
 // src/server/terminal-manager.ts
 import path16 from "path";
-import process7 from "process";
+import process8 from "process";
 import defaultShell, { detectDefaultShell } from "default-shell";
 import { Terminal } from "@xterm/headless";
 import { SerializeAddon } from "@xterm/addon-serialize";
 var DEFAULT_COLS = 80;
 var DEFAULT_ROWS = 24;
-var DEFAULT_SCROLLBACK = 1000;
+var DEFAULT_SCROLLBACK = 1e4;
 var MIN_SCROLLBACK = 500;
-var MAX_SCROLLBACK = 5000;
+var MAX_SCROLLBACK = 50000;
 var FOCUS_IN_SEQUENCE = "\x1B[I";
 var FOCUS_OUT_SEQUENCE = "\x1B[O";
 var MODE_SEQUENCE_TAIL_LENGTH = 16;
@@ -9752,14 +10332,14 @@ function resolveShell() {
   } catch {
     if (defaultShell)
       return defaultShell;
-    if (process7.platform === "win32") {
-      return process7.env.ComSpec || "cmd.exe";
+    if (process8.platform === "win32") {
+      return process8.env.ComSpec || "cmd.exe";
     }
-    return process7.env.SHELL || "/bin/sh";
+    return process8.env.SHELL || "/bin/sh";
   }
 }
 function resolveShellArgs(shellPath) {
-  if (process7.platform === "win32") {
+  if (process8.platform === "win32") {
     return [];
   }
   const shellName = path16.basename(shellPath);
@@ -9770,7 +10350,7 @@ function resolveShellArgs(shellPath) {
 }
 function createTerminalEnv() {
   return {
-    ...process7.env,
+    ...process8.env,
     TERM: "xterm-256color",
     COLORTERM: "truecolor"
   };
@@ -9795,9 +10375,9 @@ function killTerminalProcessTree(subprocess) {
   const pid = subprocess.pid;
   if (typeof pid !== "number")
     return;
-  if (process7.platform !== "win32") {
+  if (process8.platform !== "win32") {
     try {
-      process7.kill(-pid, "SIGKILL");
+      process8.kill(-pid, "SIGKILL");
       return;
     } catch {}
   }
@@ -9811,9 +10391,9 @@ function signalTerminalProcessGroup(subprocess, signal) {
   const pid = subprocess.pid;
   if (typeof pid !== "number")
     return false;
-  if (process7.platform !== "win32") {
+  if (process8.platform !== "win32") {
     try {
-      process7.kill(-pid, signal);
+      process8.kill(-pid, signal);
       return true;
     } catch {}
   }
@@ -9835,7 +10415,7 @@ class TerminalManager {
     };
   }
   createTerminal(args) {
-    if (process7.platform === "win32") {
+    if (process8.platform === "win32") {
       throw new Error("Embedded terminal is currently supported on macOS/Linux only.");
     }
     if (typeof Bun.Terminal !== "function") {
@@ -9857,7 +10437,12 @@ class TerminalManager {
     const rows = normalizeTerminalDimension(args.rows, DEFAULT_ROWS);
     const scrollback = clampScrollback(args.scrollback);
     const title = path16.basename(shell) || "shell";
-    const headless = new Terminal({ cols, rows, scrollback, allowProposedApi: true });
+    const headless = new Terminal({
+      cols,
+      rows,
+      scrollback,
+      allowProposedApi: true
+    });
     const serializeAddon = new SerializeAddon;
     headless.loadAddon(serializeAddon);
     const session = {
@@ -10002,7 +10587,9 @@ class TerminalManager {
       cols: session.cols,
       rows: session.rows,
       scrollback: session.scrollback,
-      serializedState: session.serializeAddon.serialize({ scrollback: session.scrollback }),
+      serializedState: session.serializeAddon.serialize({
+        scrollback: session.scrollback
+      }),
       status: session.status,
       exitCode: session.exitCode
     };
@@ -10605,14 +11192,14 @@ function isClientEnvelope(value) {
 // src/server/external-open.ts
 import { stat as stat2 } from "fs/promises";
 import path18 from "path";
-import process8 from "process";
+import process9 from "process";
 var DEFAULT_EDITOR_SETTINGS = {
   preset: "cursor",
   commandTemplate: "cursor {path}"
 };
 async function openExternal(command) {
   const resolvedPath = resolveLocalPath(command.localPath);
-  const platform = process8.platform;
+  const platform = process9.platform;
   const info = command.action === "open_editor" || command.action === "open_finder" ? await stat2(resolvedPath).catch(() => null) : null;
   if (command.action === "open_editor") {
     if (!info) {
@@ -10682,7 +11269,7 @@ async function openExternal(command) {
   }
 }
 async function openUrl2(command) {
-  const platform = process8.platform;
+  const platform = process9.platform;
   if (platform === "darwin") {
     spawnDetached("open", [command.url]);
     return;
@@ -11347,6 +11934,25 @@ function deriveChatSnapshot(state, activeStatuses, chatId, getMessages, pendingT
   };
 }
 
+// src/server/usage/chat-usage.ts
+function resolveChatUsage({
+  chat,
+  messages,
+  liveUsage,
+  codexSessionsDir
+}) {
+  if (!chat?.provider)
+    return liveUsage;
+  if (chat.provider === "claude") {
+    return mergeUsageSnapshots(reconstructClaudeUsage(messages), liveUsage);
+  }
+  if (chat.provider === "codex") {
+    const reconstructed = chat.sessionToken ? applyThreadEstimate(reconstructCodexUsageFromFile(chat.sessionToken, codexSessionsDir), messages) : null;
+    return mergeUsageSnapshots(reconstructed, liveUsage);
+  }
+  return liveUsage;
+}
+
 // src/server/ws-router.ts
 var PROVIDER_USAGE_POLL_INTERVAL_MS = 30 * 60 * 1000;
 var PROVIDER_USAGE_POLL_MAX_INTERVAL_MS = 31 * 60 * 1000;
@@ -11375,7 +11981,8 @@ function createWsRouter({
       await refreshCursorUsage(store.dataDir, undefined, force).then(() => {});
     }
   },
-  openUrlCommand = openUrl2
+  openUrlCommand = openUrl2,
+  resolveChatUsageForSnapshot = resolveChatUsage
 }) {
   const sockets = new Set;
   let providerUsageRefreshInFlight = null;
@@ -11490,7 +12097,13 @@ function createWsRouter({
       snapshot: {
         type: "chat",
         data: (() => {
-          return deriveChatSnapshot(store.state, agent.getActiveStatuses(), topic.chatId, (chatId) => store.getMessages(chatId), agent.getChatPendingTool(topic.chatId), agent.getLiveUsage(topic.chatId), providerSettings?.getSnapshot().settings ?? DEFAULT_PROVIDER_SETTINGS);
+          const chat = store.getChat(topic.chatId);
+          const messages = store.getMessages(topic.chatId);
+          return deriveChatSnapshot(store.state, agent.getActiveStatuses(), topic.chatId, () => messages, agent.getChatPendingTool(topic.chatId), resolveChatUsageForSnapshot({
+            chat,
+            messages,
+            liveUsage: agent.getLiveUsage(topic.chatId)
+          }), providerSettings?.getSnapshot().settings ?? DEFAULT_PROVIDER_SETTINGS);
         })()
       }
     };
@@ -12319,12 +12932,14 @@ async function serveStatic(distDir, pathname) {
 
 // src/server/cli.ts
 var packageRootUrl = new URL("../../", import.meta.url);
+var packageRootPath = fileURLToPath(packageRootUrl);
 var pkg = await Bun.file(new URL("package.json", packageRootUrl)).json();
 var VERSION = pkg.version ?? "0.0.0";
-var ALLOW_SELF_UPDATE = !existsSync10(new URL(".git", packageRootUrl));
-var argv = process9.argv.slice(2);
+var IS_NPX_RUNTIME = isNpxRuntimePath(packageRootPath);
+var ALLOW_SELF_UPDATE = !existsSync10(new URL(".git", packageRootUrl)) && !IS_NPX_RUNTIME;
+var argv = process10.argv.slice(2);
 var resolveExitAction = null;
-var WEB_ONLY_MODE = shouldRunWebOnlyMode(process9.env[CLI_WEB_ONLY_MODE_ENV_VAR]);
+var WEB_ONLY_MODE = shouldRunWebOnlyMode(process10.env[CLI_WEB_ONLY_MODE_ENV_VAR]);
 var result = await runCli(argv, {
   version: VERSION,
   bunVersion: Bun.version,
@@ -12345,27 +12960,29 @@ var result = await runCli(argv, {
     return started;
   },
   fetchLatestVersion: fetchLatestPackageVersion,
-  installVersion: installPackageVersion,
+  installVersion: IS_NPX_RUNTIME ? () => createUnsupportedNpxInstallResult() : installPackageVersion,
   openUrl,
+  resolveRemoteAccessInfo,
+  renderTerminalQrCode,
   log: console.log,
   warn: console.warn
 });
 if (result.kind === "exited") {
-  process9.exit(result.code);
+  process10.exit(result.code);
 }
 if (result.kind === "restarting") {
-  process9.exit(result.reason === "startup_update" ? CLI_STARTUP_UPDATE_RESTART_EXIT_CODE : CLI_UI_UPDATE_RESTART_EXIT_CODE);
+  process10.exit(result.reason === "startup_update" ? CLI_STARTUP_UPDATE_RESTART_EXIT_CODE : CLI_UI_UPDATE_RESTART_EXIT_CODE);
 }
 var exitAction = await new Promise((resolve2) => {
   resolveExitAction = resolve2;
   const shutdown = () => {
     resolve2("exit");
   };
-  process9.once("SIGINT", shutdown);
-  process9.once("SIGTERM", shutdown);
+  process10.once("SIGINT", shutdown);
+  process10.once("SIGTERM", shutdown);
 });
 await result.stop();
 if (exitAction === "ui_restart") {
   console.log(`${LOG_PREFIX} current process stopped, handing restart back to supervisor`);
 }
-process9.exit(exitAction === "ui_restart" ? CLI_UI_UPDATE_RESTART_EXIT_CODE : 0);
+process10.exit(exitAction === "ui_restart" ? CLI_UI_UPDATE_RESTART_EXIT_CODE : 0);