kaizenai 0.2.1 → 0.2.2

package/src/server/cli-runtime.ts

@@ -1,6 +1,6 @@
-import process from "node:process"
-import { spawnSync } from "node:child_process"
-import { hasCommand, spawnDetached } from "./process-utils"
+import process from 'node:process';
+import { spawnSync } from 'node:child_process';
+import { hasCommand, spawnDetached } from './process-utils';
 import {
   APP_NAME,
   CLI_COMMAND,
@@ -8,71 +8,83 @@ import {
   getDataDirDisplay,
   LOG_PREFIX,
   PACKAGE_NAME,
-} from "../shared/branding"
-import type { UpdateInstallErrorCode } from "../shared/types"
-import { PROD_SERVER_PORT } from "../shared/ports"
-import { CLI_SUPPRESS_OPEN_ONCE_ENV_VAR } from "./restart"
+} from '../shared/branding';
+import type { UpdateInstallErrorCode } from '../shared/types';
+import { PROD_SERVER_PORT } from '../shared/ports';
+import {
+  CLI_SKIP_STARTUP_UPDATE_ONCE_ENV_VAR,
+  CLI_SUPPRESS_OPEN_ONCE_ENV_VAR,
+  shouldSkipStartupUpdateOnce,
+} from './restart';
 
 export interface CliOptions {
-  port: number
-  host: string
-  openBrowser: boolean
-  strictPort: boolean
+  port: number;
+  host: string;
+  openBrowser: boolean;
+  strictPort: boolean;
 }
 
 export interface CliUpdateOptions {
-  version: string
-  fetchLatestVersion: (packageName: string) => Promise<string>
-  installVersion: (packageName: string, version: string) => UpdateInstallAttemptResult
-  argv: string[]
-  command: string
+  version: string;
+  fetchLatestVersion: (packageName: string) => Promise<string>;
+  installVersion: (
+    packageName: string,
+    version: string
+  ) => UpdateInstallAttemptResult;
+  argv: string[];
+  command: string;
 }
 
 export interface StartedCli {
-  kind: "started"
-  stop: () => Promise<void>
+  kind: 'started';
+  stop: () => Promise<void>;
 }
 
 export interface RestartingCli {
-  kind: "restarting"
-  reason: "startup_update" | "ui_update"
+  kind: 'restarting';
+  reason: 'startup_update' | 'ui_update';
 }
 
 export interface ExitedCli {
-  kind: "exited"
-  code: number
+  kind: 'exited';
+  code: number;
 }
 
-export type CliRunResult = StartedCli | RestartingCli | ExitedCli
+export type CliRunResult = StartedCli | RestartingCli | ExitedCli;
 
 export interface CliRuntimeDeps {
-  version: string
-  bunVersion: string
-  allowSelfUpdate?: boolean
-  startServer: (options: CliOptions & {
-    update: CliUpdateOptions
-    onMigrationProgress?: (message: string) => void
-  }) => Promise<{ port: number; stop: () => Promise<void> }>
-  fetchLatestVersion: (packageName: string) => Promise<string>
-  installVersion: (packageName: string, version: string) => UpdateInstallAttemptResult
-  openUrl: (url: string) => void
-  log: (message: string) => void
-  warn: (message: string) => void
+  version: string;
+  bunVersion: string;
+  allowSelfUpdate?: boolean;
+  startServer: (
+    options: CliOptions & {
+      update: CliUpdateOptions;
+      onMigrationProgress?: (message: string) => void;
+    }
+  ) => Promise<{ port: number; stop: () => Promise<void> }>;
+  fetchLatestVersion: (packageName: string) => Promise<string>;
+  installVersion: (
+    packageName: string,
+    version: string
+  ) => UpdateInstallAttemptResult;
+  openUrl: (url: string) => void;
+  log: (message: string) => void;
+  warn: (message: string) => void;
 }
 
 export interface UpdateInstallAttemptResult {
-  ok: boolean
-  errorCode: UpdateInstallErrorCode | null
-  userTitle: string | null
-  userMessage: string | null
+  ok: boolean;
+  errorCode: UpdateInstallErrorCode | null;
+  userTitle: string | null;
+  userMessage: string | null;
 }
 
 type ParsedArgs =
-  | { kind: "run"; options: CliOptions }
-  | { kind: "help" }
-  | { kind: "version" }
+  | { kind: 'run'; options: CliOptions }
+  | { kind: 'help' }
+  | { kind: 'version' };
 
-const MINIMUM_BUN_VERSION = "1.3.5"
+const MINIMUM_BUN_VERSION = '1.3.5';
 
 function printHelp() {
   console.log(`${APP_NAME} — local-only project chat UI
@@ -87,144 +99,161 @@ Options:
   --strict-port        Fail instead of trying another port
   --no-open            Don't open browser automatically
   --version            Print version and exit
-  --help               Show this help message`)
+  --help               Show this help message`);
 }
 
 export function parseArgs(argv: string[]): ParsedArgs {
-  let port = PROD_SERVER_PORT
-  let host = "127.0.0.1"
-  let openBrowser = true
-  let strictPort = false
+  let port = PROD_SERVER_PORT;
+  let host = '127.0.0.1';
+  let openBrowser = true;
+  let strictPort = false;
 
   for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index]
-    if (arg === "--version" || arg === "-v") {
-      return { kind: "version" }
+    const arg = argv[index];
+    if (arg === '--version' || arg === '-v') {
+      return { kind: 'version' };
     }
-    if (arg === "--help" || arg === "-h") {
-      return { kind: "help" }
+    if (arg === '--help' || arg === '-h') {
+      return { kind: 'help' };
     }
-    if (arg === "--port") {
-      const next = argv[index + 1]
-      if (!next) throw new Error("Missing value for --port")
-      port = Number(next)
-      index += 1
-      continue
+    if (arg === '--port') {
+      const next = argv[index + 1];
+      if (!next) throw new Error('Missing value for --port');
+      port = Number(next);
+      index += 1;
+      continue;
     }
-    if (arg === "--host") {
-      const next = argv[index + 1]
-      if (!next || next.startsWith("-")) throw new Error("Missing value for --host")
-      host = next
-      index += 1
-      continue
+    if (arg === '--host') {
+      const next = argv[index + 1];
+      if (!next || next.startsWith('-'))
+        throw new Error('Missing value for --host');
+      host = next;
+      index += 1;
+      continue;
     }
-    if (arg === "--remote") {
-      host = "0.0.0.0"
-      continue
+    if (arg === '--remote') {
+      host = '0.0.0.0';
+      continue;
     }
-    if (arg === "--no-open") {
-      openBrowser = false
-      continue
+    if (arg === '--no-open') {
+      openBrowser = false;
+      continue;
     }
-    if (arg === "--strict-port") {
-      strictPort = true
-      continue
+    if (arg === '--strict-port') {
+      strictPort = true;
+      continue;
     }
-    if (!arg.startsWith("-")) throw new Error(`Unexpected positional argument: ${arg}`)
+    if (!arg.startsWith('-'))
+      throw new Error(`Unexpected positional argument: ${arg}`);
   }
 
   return {
-    kind: "run",
+    kind: 'run',
     options: {
       port,
       host,
       openBrowser,
       strictPort,
     },
-  }
+  };
 }
 
 export function compareVersions(currentVersion: string, latestVersion: string) {
-  const currentParts = normalizeVersion(currentVersion)
-  const latestParts = normalizeVersion(latestVersion)
-  const length = Math.max(currentParts.length, latestParts.length)
+  const currentParts = normalizeVersion(currentVersion);
+  const latestParts = normalizeVersion(latestVersion);
+  const length = Math.max(currentParts.length, latestParts.length);
 
   for (let index = 0; index < length; index += 1) {
-    const current = currentParts[index] ?? 0
-    const latest = latestParts[index] ?? 0
-    if (current === latest) continue
-    return current < latest ? -1 : 1
+    const current = currentParts[index] ?? 0;
+    const latest = latestParts[index] ?? 0;
+    if (current === latest) continue;
+    return current < latest ? -1 : 1;
   }
 
-  return 0
+  return 0;
 }
 
 function normalizeVersion(version: string) {
   return version
     .trim()
-    .replace(/^v/i, "")
-    .split("-")[0]
-    .split(".")
+    .replace(/^v/i, '')
+    .split('-')[0]
+    .split('.')
     .map((part) => Number.parseInt(part, 10))
-    .filter((part) => Number.isFinite(part))
+    .filter((part) => Number.isFinite(part));
 }
 
 async function maybeSelfUpdate(_argv: string[], deps: CliRuntimeDeps) {
-  if (process.env[DISABLE_SELF_UPDATE_ENV_VAR] === "1") {
-    return null
+  if (process.env[DISABLE_SELF_UPDATE_ENV_VAR] === '1') {
+    return null;
+  }
+
+  if (
+    shouldSkipStartupUpdateOnce(
+      process.env[CLI_SKIP_STARTUP_UPDATE_ONCE_ENV_VAR]
+    )
+  ) {
+    deps.warn(
+      `${LOG_PREFIX} skipping startup update after restart to avoid an update loop`
+    );
+    return null;
   }
 
-  deps.log(`${LOG_PREFIX} checking for updates`)
+  deps.log(`${LOG_PREFIX} checking for updates`);
 
-  let latestVersion: string
+  let latestVersion: string;
   try {
-    latestVersion = await deps.fetchLatestVersion(PACKAGE_NAME)
-  }
-  catch (error) {
-    deps.warn(`${LOG_PREFIX} update check failed, continuing current version`)
+    latestVersion = await deps.fetchLatestVersion(PACKAGE_NAME);
+  } catch (error) {
+    deps.warn(`${LOG_PREFIX} update check failed, continuing current version`);
     if (error instanceof Error && error.message) {
-      deps.warn(`${LOG_PREFIX} ${error.message}`)
+      deps.warn(`${LOG_PREFIX} ${error.message}`);
     }
-    return null
+    return null;
   }
 
   if (!latestVersion || compareVersions(deps.version, latestVersion) >= 0) {
-    return null
+    return null;
   }
 
-  deps.log(`${LOG_PREFIX} installing ${PACKAGE_NAME}@${latestVersion}`)
-  const installResult = deps.installVersion(PACKAGE_NAME, latestVersion)
+  deps.log(`${LOG_PREFIX} installing ${PACKAGE_NAME}@${latestVersion}`);
+  const installResult = deps.installVersion(PACKAGE_NAME, latestVersion);
   if (!installResult.ok) {
-    deps.warn(`${LOG_PREFIX} update failed, continuing current version`)
+    deps.warn(`${LOG_PREFIX} update failed, continuing current version`);
     if (installResult.userMessage) {
-      deps.warn(`${LOG_PREFIX} ${installResult.userMessage}`)
+      deps.warn(`${LOG_PREFIX} ${installResult.userMessage}`);
     }
-    return null
+    return null;
   }
 
-  deps.log(`${LOG_PREFIX} restarting into updated version`)
-  return "startup_update"
+  deps.log(`${LOG_PREFIX} restarting into updated version`);
+  return 'startup_update';
 }
 
-export async function runCli(argv: string[], deps: CliRuntimeDeps): Promise<CliRunResult> {
-  const parsedArgs = parseArgs(argv)
-  if (parsedArgs.kind === "version") {
-    deps.log(deps.version)
-    return { kind: "exited", code: 0 }
+export async function runCli(
+  argv: string[],
+  deps: CliRuntimeDeps
+): Promise<CliRunResult> {
+  const parsedArgs = parseArgs(argv);
+  if (parsedArgs.kind === 'version') {
+    deps.log(deps.version);
+    return { kind: 'exited', code: 0 };
   }
-  if (parsedArgs.kind === "help") {
-    printHelp()
-    return { kind: "exited", code: 0 }
+  if (parsedArgs.kind === 'help') {
+    printHelp();
+    return { kind: 'exited', code: 0 };
   }
   if (compareVersions(deps.bunVersion, MINIMUM_BUN_VERSION) < 0) {
-    deps.warn(`${LOG_PREFIX} Bun ${MINIMUM_BUN_VERSION}+ is required for the embedded terminal. Current Bun: ${deps.bunVersion}`)
-    return { kind: "exited", code: 1 }
+    deps.warn(
+      `${LOG_PREFIX} Bun ${MINIMUM_BUN_VERSION}+ is required for the embedded terminal. Current Bun: ${deps.bunVersion}`
+    );
+    return { kind: 'exited', code: 1 };
   }
 
   if (deps.allowSelfUpdate !== false) {
-    const shouldRestart = await maybeSelfUpdate(argv, deps)
+    const shouldRestart = await maybeSelfUpdate(argv, deps);
     if (shouldRestart !== null) {
-      return { kind: "restarting", reason: shouldRestart }
+      return { kind: 'restarting', reason: shouldRestart };
     }
   }
 
@@ -238,96 +267,109 @@ export async function runCli(argv: string[], deps: CliRuntimeDeps): Promise<CliR
       argv,
       command: CLI_COMMAND,
     },
-  })
-  const bindHost = parsedArgs.options.host
-  const displayHost = bindHost === "127.0.0.1" || bindHost === "0.0.0.0" ? "localhost" : bindHost
-  const launchUrl = `http://${displayHost}:${port}`
+  });
+  const bindHost = parsedArgs.options.host;
+  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} data dir: ${getDataDirDisplay()}`)
+  deps.log(`${LOG_PREFIX} listening on http://${bindHost}:${port}`);
+  deps.log(`${LOG_PREFIX} data dir: ${getDataDirDisplay()}`);
 
-  const suppressOpenBrowser = process.env[CLI_SUPPRESS_OPEN_ONCE_ENV_VAR] === "1"
+  const suppressOpenBrowser =
+    process.env[CLI_SUPPRESS_OPEN_ONCE_ENV_VAR] === '1';
   if (parsedArgs.options.openBrowser && !suppressOpenBrowser) {
-    deps.openUrl(launchUrl)
+    deps.openUrl(launchUrl);
   }
 
   return {
-    kind: "started",
+    kind: 'started',
     stop,
-  }
+  };
 }
 
 export function openUrl(url: string) {
-  const platform = process.platform
-  if (platform === "darwin") {
-    spawnDetached("open", [url])
-  } else if (platform === "win32") {
-    spawnDetached("cmd", ["/c", "start", "", url])
+  const platform = process.platform;
+  if (platform === 'darwin') {
+    spawnDetached('open', [url]);
+  } else if (platform === 'win32') {
+    spawnDetached('cmd', ['/c', 'start', '', url]);
   } else {
-    spawnDetached("xdg-open", [url])
+    spawnDetached('xdg-open', [url]);
   }
-  console.log(`${LOG_PREFIX} opened in default browser`)
+  console.log(`${LOG_PREFIX} opened in default browser`);
 }
 
 export async function fetchLatestPackageVersion(packageName: string) {
-  const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`)
+  const response = await fetch(
+    `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`
+  );
   if (!response.ok) {
-    throw new Error(`registry returned ${response.status}`)
+    throw new Error(`registry returned ${response.status}`);
   }
 
-  const payload = await response.json() as { version?: unknown }
-  if (typeof payload.version !== "string" || !payload.version.trim()) {
-    throw new Error("registry response did not include a version")
+  const payload = (await response.json()) as { version?: unknown };
+  if (typeof payload.version !== 'string' || !payload.version.trim()) {
+    throw new Error('registry response did not include a version');
   }
 
-  return payload.version
+  return payload.version;
 }
 
-export function classifyInstallVersionFailure(output: string): UpdateInstallAttemptResult {
-  const normalizedOutput = output.trim()
-  if (/No version matching .* found|failed to resolve/i.test(normalizedOutput)) {
+export function classifyInstallVersionFailure(
+  output: string
+): UpdateInstallAttemptResult {
+  const normalizedOutput = output.trim();
+  if (
+    /No version matching .* found|failed to resolve/i.test(normalizedOutput)
+  ) {
     return {
       ok: false,
-      errorCode: "version_not_live_yet",
-      userTitle: "Update not live yet",
-      userMessage: "This update is still propagating. Try again in a few minutes.",
-    }
+      errorCode: 'version_not_live_yet',
+      userTitle: 'Update not live yet',
+      userMessage:
+        'This update is still propagating. Try again in a few minutes.',
+    };
   }
 
   return {
     ok: false,
-    errorCode: "install_failed",
-    userTitle: "Update failed",
-    userMessage: "Kaizen could not install the update. Try again later.",
-  }
+    errorCode: 'install_failed',
+    userTitle: 'Update failed',
+    userMessage: 'Kaizen could not install the update. Try again later.',
+  };
 }
 
 export function installPackageVersion(packageName: string, version: string) {
-  if (!hasCommand("bun")) {
+  if (!hasCommand('bun')) {
     return {
       ok: false,
-      errorCode: "command_missing",
-      userTitle: "Bun not found",
-      userMessage: "Kaizen could not find Bun to install the update.",
-    } satisfies UpdateInstallAttemptResult
+      errorCode: 'command_missing',
+      userTitle: 'Bun not found',
+      userMessage: 'Kaizen could not find Bun to install the update.',
+    } satisfies UpdateInstallAttemptResult;
   }
 
-  const result = spawnSync("bun", ["install", "-g", `${packageName}@${version}`], {
-    stdio: ["ignore", "pipe", "pipe"],
-    encoding: "utf8",
-  })
-  const stdout = result.stdout ?? ""
-  const stderr = result.stderr ?? ""
-  if (stdout) process.stdout.write(stdout)
-  if (stderr) process.stderr.write(stderr)
+  const result = spawnSync(
+    'bun',
+    ['install', '-g', `${packageName}@${version}`],
+    {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      encoding: 'utf8',
+    }
+  );
+  const stdout = result.stdout ?? '';
+  const stderr = result.stderr ?? '';
+  if (stdout) process.stdout.write(stdout);
+  if (stderr) process.stderr.write(stderr);
   if (result.status === 0) {
     return {
       ok: true,
       errorCode: null,
       userTitle: null,
       userMessage: null,
-    } satisfies UpdateInstallAttemptResult
+    } satisfies UpdateInstallAttemptResult;
   }
 
-  return classifyInstallVersionFailure(`${stdout}\n${stderr}`)
+  return classifyInstallVersionFailure(`${stdout}\n${stderr}`);
 }

package/src/server/cli-supervisor.ts

@@ -1,81 +1,97 @@
-import process from "node:process"
-import { spawn } from "node:child_process"
-import { CLI_COMMAND, LOG_PREFIX } from "../shared/branding"
+import process from 'node:process';
+import { spawn } from 'node:child_process';
+import { CLI_COMMAND, LOG_PREFIX } from '../shared/branding';
 import {
   CLI_CHILD_ARGS_ENV_VAR,
   CLI_CHILD_COMMAND_ENV_VAR,
   CLI_CHILD_MODE,
   CLI_CHILD_MODE_ENV_VAR,
+  CLI_SKIP_STARTUP_UPDATE_ONCE_ENV_VAR,
   CLI_SUPPRESS_OPEN_ONCE_ENV_VAR,
+  isStartupUpdateRestart,
   isUiUpdateRestart,
   parseChildArgsEnv,
   shouldRestartCliProcess,
-} from "./restart"
+} from './restart';
 
 interface ChildExit {
-  code: number | null
-  signal: NodeJS.Signals | null
+  code: number | null;
+  signal: NodeJS.Signals | null;
 }
 
 function getChildProcessSpec() {
-  const command = process.env[CLI_CHILD_COMMAND_ENV_VAR] || CLI_COMMAND
-  const args = parseChildArgsEnv(process.env[CLI_CHILD_ARGS_ENV_VAR])
-  return { command, args }
+  const command = process.env[CLI_CHILD_COMMAND_ENV_VAR] || CLI_COMMAND;
+  const args = parseChildArgsEnv(process.env[CLI_CHILD_ARGS_ENV_VAR]);
+  return { command, args };
 }
 
 function spawnChild(argv: string[]) {
-  const childProcess = getChildProcessSpec()
-  const suppressOpenThisChild = suppressOpenOnNextChild
-  suppressOpenOnNextChild = false
+  const childProcess = getChildProcessSpec();
+  const suppressOpenThisChild = suppressOpenOnNextChild;
+  const skipStartupUpdateThisChild = skipStartupUpdateOnNextChild;
+  suppressOpenOnNextChild = false;
+  skipStartupUpdateOnNextChild = false;
   return new Promise<ChildExit>((resolve, reject) => {
     const child = spawn(childProcess.command, [...childProcess.args, ...argv], {
-      stdio: "inherit",
+      stdio: 'inherit',
       env: {
         ...process.env,
         [CLI_CHILD_MODE_ENV_VAR]: CLI_CHILD_MODE,
-        ...(suppressOpenThisChild ? { [CLI_SUPPRESS_OPEN_ONCE_ENV_VAR]: "1" } : {}),
+        ...(suppressOpenThisChild
+          ? { [CLI_SUPPRESS_OPEN_ONCE_ENV_VAR]: '1' }
+          : {}),
+        ...(skipStartupUpdateThisChild
+          ? { [CLI_SKIP_STARTUP_UPDATE_ONCE_ENV_VAR]: '1' }
+          : {}),
       },
-    })
+    });
 
     const forwardSignal = (signal: NodeJS.Signals) => {
-      if (child.exitCode !== null) return
-      child.kill(signal)
-    }
+      if (child.exitCode !== null) return;
+      child.kill(signal);
+    };
 
     const onSigint = () => {
-      forwardSignal("SIGINT")
-    }
+      forwardSignal('SIGINT');
+    };
     const onSigterm = () => {
-      forwardSignal("SIGTERM")
-    }
+      forwardSignal('SIGTERM');
+    };
 
-    process.on("SIGINT", onSigint)
-    process.on("SIGTERM", onSigterm)
+    process.on('SIGINT', onSigint);
+    process.on('SIGTERM', onSigterm);
 
-    child.once("error", (error) => {
-      process.off("SIGINT", onSigint)
-      process.off("SIGTERM", onSigterm)
-      reject(error)
-    })
+    child.once('error', (error) => {
+      process.off('SIGINT', onSigint);
+      process.off('SIGTERM', onSigterm);
+      reject(error);
+    });
 
-    child.once("exit", (code, signal) => {
-      process.off("SIGINT", onSigint)
-      process.off("SIGTERM", onSigterm)
-      resolve({ code, signal })
-    })
-  })
+    child.once('exit', (code, signal) => {
+      process.off('SIGINT', onSigint);
+      process.off('SIGTERM', onSigterm);
+      resolve({ code, signal });
+    });
+  });
 }
 
-const argv = process.argv.slice(2)
-let suppressOpenOnNextChild = false
+const argv = process.argv.slice(2);
+let suppressOpenOnNextChild = false;
+let skipStartupUpdateOnNextChild = false;
 
 while (true) {
-  const result = await spawnChild(argv)
+  const result = await spawnChild(argv);
   if (shouldRestartCliProcess(result.code, result.signal)) {
-    suppressOpenOnNextChild = isUiUpdateRestart(result.code, result.signal)
-    console.log(`${LOG_PREFIX} supervisor restarting ${CLI_COMMAND} in the same terminal session`)
-    continue
+    suppressOpenOnNextChild = isUiUpdateRestart(result.code, result.signal);
+    skipStartupUpdateOnNextChild = isStartupUpdateRestart(
+      result.code,
+      result.signal
+    );
+    console.log(
+      `${LOG_PREFIX} supervisor restarting ${CLI_COMMAND} in the same terminal session`
+    );
+    continue;
   }
 
-  process.exit(result.code ?? (result.signal ? 1 : 0))
+  process.exit(result.code ?? (result.signal ? 1 : 0));
 }