kaizenai 0.5.0 → 0.6.0

package/dist/server/cli.js

@@ -1,12 +1,13 @@
 // @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.5.0",
+  version: "0.6.0",
   description: "Local web UI for coding agents",
   keywords: [
     "claude",
@@ -43,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"
@@ -67,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"
   },
@@ -158,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";
@@ -184,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";
@@ -240,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
 
@@ -249,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
@@ -260,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") {
@@ -286,6 +561,7 @@ function parseArgs(argv) {
     }
     if (arg === "--remote") {
       host = "0.0.0.0";
+      remoteMode = true;
       continue;
     }
     if (arg === "--no-open") {
@@ -305,7 +581,8 @@ function parseArgs(argv) {
       port,
       host,
       openBrowser,
-      strictPort
+      strictPort,
+      remoteMode
     }
   };
 }
@@ -322,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;
   }
@@ -394,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);
   }
@@ -405,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") {
@@ -452,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,
@@ -2437,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) {
@@ -5622,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";
@@ -6154,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"
     }
@@ -6163,7 +6479,7 @@ function collectClaudeUsageScreen(args) {
 }
 function isRunningPid(pid) {
   try {
-    process3.kill(pid, 0);
+    process4.kill(pid, 0);
     return true;
   } catch {
     return false;
@@ -6511,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
@@ -6520,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) {
@@ -6817,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)) {
@@ -7151,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);
@@ -7216,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({
@@ -7234,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({
@@ -7307,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);
 }
 
@@ -7461,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.";
   }
@@ -7560,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 })];
@@ -7569,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 [];
 }
@@ -8207,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
@@ -8255,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);
@@ -9941,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;
@@ -9963,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;
@@ -9991,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);
@@ -10009,7 +10350,7 @@ function resolveShellArgs(shellPath) {
 }
 function createTerminalEnv() {
   return {
-    ...process7.env,
+    ...process8.env,
     TERM: "xterm-256color",
     COLORTERM: "truecolor"
   };
@@ -10034,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 {}
   }
@@ -10050,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 {}
   }
@@ -10074,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") {
@@ -10096,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 = {
@@ -10241,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
     };
@@ -10844,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) {
@@ -10921,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;
@@ -12584,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,
@@ -12610,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);