kanna-code 0.2.0 → 0.4.0

package/src/server/cli-runtime.test.ts

@@ -0,0 +1,180 @@
+import { describe, expect, test } from "bun:test"
+import { compareVersions, parseArgs, runCli } from "./cli-runtime"
+
+function createDeps(overrides: Partial<Parameters<typeof runCli>[1]> = {}) {
+  const calls = {
+    startServer: [] as Array<{ port: number; openBrowser: boolean; strictPort: boolean }>,
+    fetchLatestVersion: [] as string[],
+    installLatest: [] as string[],
+    relaunch: [] as Array<{ command: string; args: string[] }>,
+    openUrl: [] as string[],
+    log: [] as string[],
+    warn: [] as string[],
+  }
+
+  const deps: Parameters<typeof runCli>[1] = {
+    version: "0.3.0",
+    startServer: async (options) => {
+      calls.startServer.push(options)
+      return {
+        port: options.port,
+        stop: async () => {},
+      }
+    },
+    fetchLatestVersion: async (packageName) => {
+      calls.fetchLatestVersion.push(packageName)
+      return "0.3.0"
+    },
+    installLatest: (packageName) => {
+      calls.installLatest.push(packageName)
+      return true
+    },
+    relaunch: (command, args) => {
+      calls.relaunch.push({ command, args })
+      return 0
+    },
+    openUrl: (url) => {
+      calls.openUrl.push(url)
+    },
+    log: (message) => {
+      calls.log.push(message)
+    },
+    warn: (message) => {
+      calls.warn.push(message)
+    },
+    ...overrides,
+  }
+
+  return { calls, deps }
+}
+
+describe("parseArgs", () => {
+  test("parses runtime options", () => {
+    expect(parseArgs(["--port", "4000", "--no-open"])).toEqual({
+      kind: "run",
+      options: {
+        port: 4000,
+        openBrowser: false,
+        strictPort: false,
+      },
+    })
+  })
+
+  test("parses strict port mode", () => {
+    expect(parseArgs(["--strict-port"])).toEqual({
+      kind: "run",
+      options: {
+        port: 3210,
+        openBrowser: true,
+        strictPort: true,
+      },
+    })
+  })
+
+  test("returns version and help actions without running startup", () => {
+    expect(parseArgs(["--version"])).toEqual({ kind: "version" })
+    expect(parseArgs(["--help"])).toEqual({ kind: "help" })
+  })
+})
+
+describe("compareVersions", () => {
+  test("orders semver-like versions", () => {
+    expect(compareVersions("0.3.0", "0.3.0")).toBe(0)
+    expect(compareVersions("0.3.0", "0.3.1")).toBe(-1)
+    expect(compareVersions("1.0.0", "0.9.9")).toBe(1)
+  })
+})
+
+describe("runCli", () => {
+  test("skips update checks for --version", async () => {
+    const { calls, deps } = createDeps()
+
+    const result = await runCli(["--version"], deps)
+
+    expect(result).toEqual({ kind: "exited", code: 0 })
+    expect(calls.fetchLatestVersion).toEqual([])
+    expect(calls.startServer).toEqual([])
+    expect(calls.log).toEqual(["0.3.0"])
+  })
+
+  test("starts normally when no newer version exists", async () => {
+    const { calls, deps } = createDeps()
+
+    const result = await runCli(["--port", "4000", "--no-open"], deps)
+
+    expect(result.kind).toBe("started")
+    expect(calls.fetchLatestVersion).toEqual(["kanna-code"])
+    expect(calls.installLatest).toEqual([])
+    expect(calls.relaunch).toEqual([])
+    expect(calls.startServer).toEqual([{ port: 4000, openBrowser: false, strictPort: false }])
+    expect(calls.openUrl).toEqual([])
+  })
+
+  test("installs and relaunches when a newer version is available", async () => {
+    const { calls, deps } = createDeps({
+      fetchLatestVersion: async (packageName) => {
+        calls.fetchLatestVersion.push(packageName)
+        return "0.4.0"
+      },
+    })
+
+    const result = await runCli(["--port", "4000", "--no-open"], deps)
+
+    expect(result).toEqual({ kind: "exited", code: 0 })
+    expect(calls.installLatest).toEqual(["kanna-code"])
+    expect(calls.relaunch).toEqual([{ command: "kanna", args: ["--port", "4000", "--no-open"] }])
+    expect(calls.startServer).toEqual([])
+  })
+
+  test("falls back to current version when install fails", async () => {
+    const { calls, deps } = createDeps({
+      fetchLatestVersion: async (packageName) => {
+        calls.fetchLatestVersion.push(packageName)
+        return "0.4.0"
+      },
+      installLatest: (packageName) => {
+        calls.installLatest.push(packageName)
+        return false
+      },
+    })
+
+    const result = await runCli(["--no-open"], deps)
+
+    expect(result.kind).toBe("started")
+    expect(calls.installLatest).toEqual(["kanna-code"])
+    expect(calls.relaunch).toEqual([])
+    expect(calls.warn).toContain("[kanna] update failed, continuing current version")
+  })
+
+  test("falls back to current version when the registry check fails", async () => {
+    const { calls, deps } = createDeps({
+      fetchLatestVersion: async (packageName) => {
+        calls.fetchLatestVersion.push(packageName)
+        throw new Error("network unavailable")
+      },
+    })
+
+    const result = await runCli(["--no-open"], deps)
+
+    expect(result.kind).toBe("started")
+    expect(calls.installLatest).toEqual([])
+    expect(calls.relaunch).toEqual([])
+    expect(calls.warn).toContain("[kanna] update check failed, continuing current version")
+  })
+
+  test("preserves original argv when relaunching", async () => {
+    const { calls, deps } = createDeps({
+      fetchLatestVersion: async (packageName) => {
+        calls.fetchLatestVersion.push(packageName)
+        return "0.4.0"
+      },
+    })
+
+    await runCli(["--port", "4567", "--no-open"], deps)
+
+    expect(calls.relaunch[0]).toEqual({
+      command: "kanna",
+      args: ["--port", "4567", "--no-open"],
+    })
+  })
+})

package/src/server/cli-runtime.ts

@@ -0,0 +1,274 @@
+import process from "node:process"
+import { spawn, spawnSync } from "node:child_process"
+import { APP_NAME, CLI_COMMAND, getDataDirDisplay, LOG_PREFIX, PACKAGE_NAME } from "../shared/branding"
+import { PROD_SERVER_PORT } from "../shared/ports"
+
+export interface CliOptions {
+  port: number
+  openBrowser: boolean
+  strictPort: boolean
+}
+
+export interface StartedCli {
+  kind: "started"
+  stop: () => Promise<void>
+}
+
+export interface ExitedCli {
+  kind: "exited"
+  code: number
+}
+
+export type CliRunResult = StartedCli | ExitedCli
+
+export interface CliRuntimeDeps {
+  version: string
+  startServer: (options: CliOptions) => Promise<{ port: number; stop: () => Promise<void> }>
+  fetchLatestVersion: (packageName: string) => Promise<string>
+  installLatest: (packageName: string) => boolean
+  relaunch: (command: string, args: string[]) => number | null
+  openUrl: (url: string) => void
+  log: (message: string) => void
+  warn: (message: string) => void
+}
+
+type ParsedArgs =
+  | { kind: "run"; options: CliOptions }
+  | { kind: "help" }
+  | { kind: "version" }
+
+function printHelp() {
+  console.log(`${APP_NAME} — local-only project chat UI
+
+Usage:
+  ${CLI_COMMAND} [options]
+
+Options:
+  --port <number>  Port to listen on (default: ${PROD_SERVER_PORT})
+  --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`)
+}
+
+export function parseArgs(argv: string[]): ParsedArgs {
+  let port = PROD_SERVER_PORT
+  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" }
+    }
+    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 === "--no-open") {
+      openBrowser = false
+      continue
+    }
+    if (arg === "--strict-port") {
+      strictPort = true
+      continue
+    }
+    if (!arg.startsWith("-")) throw new Error(`Unexpected positional argument: ${arg}`)
+  }
+
+  return {
+    kind: "run",
+    options: {
+      port,
+      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)
+
+  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
+  }
+
+  return 0
+}
+
+function normalizeVersion(version: string) {
+  return version
+    .trim()
+    .replace(/^v/i, "")
+    .split("-")[0]
+    .split(".")
+    .map((part) => Number.parseInt(part, 10))
+    .filter((part) => Number.isFinite(part))
+}
+
+async function maybeSelfUpdate(argv: string[], deps: CliRuntimeDeps) {
+  deps.log(`${LOG_PREFIX} checking for updates`)
+
+  let latestVersion: string
+  try {
+    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}`)
+    }
+    return null
+  }
+
+  if (!latestVersion || compareVersions(deps.version, latestVersion) >= 0) {
+    return null
+  }
+
+  deps.log(`${LOG_PREFIX} updating to ${latestVersion}`)
+  if (!deps.installLatest(PACKAGE_NAME)) {
+    deps.warn(`${LOG_PREFIX} update failed, continuing current version`)
+    return null
+  }
+
+  deps.log(`${LOG_PREFIX} restarting into updated version`)
+  const exitCode = deps.relaunch(CLI_COMMAND, argv)
+  if (exitCode === null) {
+    deps.warn(`${LOG_PREFIX} restart failed, continuing current version`)
+    return null
+  }
+
+  return exitCode
+}
+
+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 }
+  }
+
+  const relaunchExitCode = await maybeSelfUpdate(argv, deps)
+  if (relaunchExitCode !== null) {
+    return { kind: "exited", code: relaunchExitCode }
+  }
+
+  const { port, stop } = await deps.startServer(parsedArgs.options)
+  const url = `http://localhost:${port}`
+  const launchUrl = `${url}/projects`
+
+  deps.log(`${LOG_PREFIX} listening on ${url}`)
+  deps.log(`${LOG_PREFIX} data dir: ${getDataDirDisplay()}`)
+
+  if (parsedArgs.options.openBrowser) {
+    deps.openUrl(launchUrl)
+  }
+
+  return {
+    kind: "started",
+    stop,
+  }
+}
+
+function spawnDetached(command: string, args: string[]) {
+  spawn(command, args, { stdio: "ignore", detached: true }).unref()
+}
+
+function hasCommand(command: string) {
+  const result = spawnSync("sh", ["-lc", `command -v ${command}`], { stdio: "ignore" })
+  return result.status === 0
+}
+
+function canOpenMacApp(appName: string) {
+  const result = spawnSync("open", ["-Ra", appName], { stdio: "ignore" })
+  return result.status === 0
+}
+
+export function openUrl(url: string) {
+  const platform = process.platform
+  if (platform === "darwin") {
+    const appCandidates = [
+      "Google Chrome",
+      "Chromium",
+      "Brave Browser",
+      "Microsoft Edge",
+      "Arc",
+    ]
+
+    for (const appName of appCandidates) {
+      if (!canOpenMacApp(appName)) continue
+      spawnDetached("open", ["-a", appName, "--args", `--app=${url}`])
+      console.log(`${LOG_PREFIX} opened in app window via ${appName}`)
+      return
+    }
+
+    spawnDetached("open", [url])
+    console.log(`${LOG_PREFIX} opened in default browser`)
+    return
+  }
+  if (platform === "win32") {
+    const browserCommands = ["chrome", "msedge", "brave", "chromium"]
+    for (const command of browserCommands) {
+      if (!hasCommand(command)) continue
+      spawnDetached(command, [`--app=${url}`])
+      console.log(`${LOG_PREFIX} opened in app window via ${command}`)
+      return
+    }
+
+    spawnDetached("cmd", ["/c", "start", "", url])
+    console.log(`${LOG_PREFIX} opened in default browser`)
+    return
+  }
+
+  const browserCommands = ["google-chrome", "chromium", "brave-browser", "microsoft-edge"]
+  for (const command of browserCommands) {
+    if (!hasCommand(command)) continue
+    spawnDetached(command, [`--app=${url}`])
+    console.log(`${LOG_PREFIX} opened in app window via ${command}`)
+    return
+  }
+
+  spawnDetached("xdg-open", [url])
+  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`)
+  if (!response.ok) {
+    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")
+  }
+
+  return payload.version
+}
+
+export function installLatestPackage(packageName: string) {
+  if (!hasCommand("bun")) return false
+  const result = spawnSync("bun", ["install", "-g", `${packageName}@latest`], { stdio: "inherit" })
+  return result.status === 0
+}
+
+export function relaunchCli(command: string, args: string[]) {
+  const result = spawnSync(command, args, { stdio: "inherit" })
+  if (result.error) return null
+  return result.status ?? 0
+}

package/src/server/cli.ts

@@ -1,141 +1,34 @@
 import process from "node:process"
-import { spawn, spawnSync } from "node:child_process"
-import { APP_NAME, CLI_COMMAND, getDataDirDisplay, LOG_PREFIX } from "../shared/branding"
-import { PROD_SERVER_PORT } from "../shared/ports"
+import {
+  fetchLatestPackageVersion,
+  installLatestPackage,
+  openUrl,
+  relaunchCli,
+  runCli,
+} from "./cli-runtime"
 import { startKannaServer } from "./server"
 
 // Read version from package.json at the package root
 const pkg = await Bun.file(new URL("../../package.json", import.meta.url)).json()
 const VERSION: string = pkg.version ?? "0.0.0"
 
-interface CliOptions {
-  port: number
-  openBrowser: boolean
-}
-
-function printHelp() {
-  console.log(`${APP_NAME} — local-only project chat UI
-
-Usage:
-  ${CLI_COMMAND} [options]
-
-Options:
-  --port <number>  Port to listen on (default: ${PROD_SERVER_PORT})
-  --no-open        Don't open browser automatically
-  --version        Print version and exit
-  --help           Show this help message`)
-}
-
-function parseArgs(argv: string[]): CliOptions {
-  let port = PROD_SERVER_PORT
-  let openBrowser = true
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index]
-    if (arg === "--version" || arg === "-v") {
-      console.log(VERSION)
-      process.exit(0)
-    }
-    if (arg === "--help" || arg === "-h") {
-      printHelp()
-      process.exit(0)
-    }
-    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 === "--no-open") {
-      openBrowser = false
-      continue
-    }
-    if (!arg.startsWith("-")) throw new Error(`Unexpected positional argument: ${arg}`)
-  }
-
-  return {
-    port,
-    openBrowser,
-  }
-}
-
-function spawnDetached(command: string, args: string[]) {
-  spawn(command, args, { stdio: "ignore", detached: true }).unref()
-}
-
-function hasCommand(command: string) {
-  const result = spawnSync("sh", ["-lc", `command -v ${command}`], { stdio: "ignore" })
-  return result.status === 0
-}
-
-function canOpenMacApp(appName: string) {
-  const result = spawnSync("open", ["-Ra", appName], { stdio: "ignore" })
-  return result.status === 0
-}
-
-function openUrl(url: string) {
-  const platform = process.platform
-  if (platform === "darwin") {
-    const appCandidates = [
-      "Google Chrome",
-      "Chromium",
-      "Brave Browser",
-      "Microsoft Edge",
-      "Arc",
-    ]
-
-    for (const appName of appCandidates) {
-      if (!canOpenMacApp(appName)) continue
-      spawnDetached("open", ["-a", appName, "--args", `--app=${url}`])
-      console.log(`${LOG_PREFIX} opened in app window via ${appName}`)
-      return
-    }
-
-    spawnDetached("open", [url])
-    console.log(`${LOG_PREFIX} opened in default browser`)
-    return
-  }
-  if (platform === "win32") {
-    const browserCommands = ["chrome", "msedge", "brave", "chromium"]
-    for (const command of browserCommands) {
-      if (!hasCommand(command)) continue
-      spawnDetached(command, [`--app=${url}`])
-      console.log(`${LOG_PREFIX} opened in app window via ${command}`)
-      return
-    }
-
-    spawnDetached("cmd", ["/c", "start", "", url])
-    console.log(`${LOG_PREFIX} opened in default browser`)
-    return
-  }
-
-  const browserCommands = ["google-chrome", "chromium", "brave-browser", "microsoft-edge"]
-  for (const command of browserCommands) {
-    if (!hasCommand(command)) continue
-    spawnDetached(command, [`--app=${url}`])
-    console.log(`${LOG_PREFIX} opened in app window via ${command}`)
-    return
-  }
-
-  spawnDetached("xdg-open", [url])
-  console.log(`${LOG_PREFIX} opened in default browser`)
-}
-
-const options = parseArgs(process.argv.slice(2))
-const { port, stop } = await startKannaServer(options)
-const url = `http://localhost:${port}`
-const launchUrl = `${url}/projects`
-
-console.log(`${LOG_PREFIX} listening on ${url}`)
-console.log(`${LOG_PREFIX} data dir: ${getDataDirDisplay()}`)
+const result = await runCli(process.argv.slice(2), {
+  version: VERSION,
+  startServer: startKannaServer,
+  fetchLatestVersion: fetchLatestPackageVersion,
+  installLatest: installLatestPackage,
+  relaunch: relaunchCli,
+  openUrl,
+  log: console.log,
+  warn: console.warn,
+})
 
-if (options.openBrowser) {
-  openUrl(launchUrl)
+if (result.kind === "exited") {
+  process.exit(result.code)
 }
 
 const shutdown = async () => {
-  await stop()
+  await result.stop()
   process.exit(0)
 }