kanna-code 0.3.0 → 0.4.0

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)
 }
 

package/src/server/codex-app-server.test.ts

@@ -1186,6 +1186,104 @@ describe("CodexAppServerManager", () => {
     })
   })
 
+  test("infers multi-select Codex questions from prompt text and returns multiple answers", async () => {
+    const process = new FakeCodexProcess((message, child) => {
+      if (message.method === "initialize") {
+        child.writeServerMessage({ id: message.id, result: { userAgent: "codex-test" } })
+      } else if (message.method === "thread/start") {
+        child.writeServerMessage({
+          id: message.id,
+          result: { thread: { id: "thread-1" }, model: "gpt-5.4", reasoningEffort: "high" },
+        })
+      } else if (message.method === "turn/start") {
+        child.writeServerMessage({
+          id: message.id,
+          result: { turn: { id: "turn-1", status: "inProgress", error: null } },
+        })
+        child.writeServerMessage({
+          id: "req-1",
+          method: "item/tool/requestUserInput",
+          params: {
+            threadId: "thread-1",
+            turnId: "turn-1",
+            itemId: "ask-1",
+            questions: [
+              {
+                id: "runtimes",
+                header: "Runtime",
+                question: "Select all runtimes that apply",
+                isOther: true,
+                isSecret: false,
+                options: [
+                  { label: "bun", description: null },
+                  { label: "node", description: null },
+                ],
+              },
+            ],
+          },
+        })
+        child.writeServerMessage({
+          method: "turn/completed",
+          params: {
+            threadId: "thread-1",
+            turn: { id: "turn-1", status: "completed", error: null },
+          },
+        })
+      }
+    })
+
+    const manager = new CodexAppServerManager({
+      spawnProcess: () => process as never,
+    })
+
+    await manager.startSession({
+      chatId: "chat-1",
+      cwd: "/tmp/project",
+      model: "gpt-5.4",
+      sessionToken: null,
+    })
+
+    const turn = await manager.startTurn({
+      chatId: "chat-1",
+      model: "gpt-5.4",
+      content: "ask me",
+      planMode: false,
+      onToolRequest: async ({ tool }) => {
+        expect(tool.toolKind).toBe("ask_user_question")
+        if (tool.toolKind !== "ask_user_question") {
+          return {}
+        }
+
+        expect(tool.input.questions[0]?.multiSelect).toBe(true)
+
+        return {
+          questions: [{
+            id: "runtimes",
+            question: "Select all runtimes that apply",
+            multiSelect: true,
+          }],
+          answers: {
+            runtimes: ["bun", "node"],
+          },
+        }
+      },
+    })
+
+    await collectStream(turn.stream)
+
+    const response = process.messages.find((message: any) => message.id === "req-1")
+    expect(response).toEqual({
+      id: "req-1",
+      result: {
+        answers: {
+          runtimes: {
+            answers: ["bun", "node"],
+          },
+        },
+      },
+    })
+  })
+
   test("sends approval decisions back to the app-server", async () => {
     const process = new FakeCodexProcess((message, child) => {
       if (message.method === "initialize") {
@@ -1307,6 +1405,94 @@ describe("CodexAppServerManager", () => {
     })
   })
 
+  test("interrupt clears a pending exit-plan wait so a new turn can start immediately", async () => {
+    let resolveToolRequest!: (value: unknown) => void
+
+    const process = new FakeCodexProcess((message, child) => {
+      if (message.method === "initialize") {
+        child.writeServerMessage({ id: message.id, result: { userAgent: "codex-test" } })
+      } else if (message.method === "thread/start") {
+        child.writeServerMessage({
+          id: message.id,
+          result: { thread: { id: "thread-1" }, model: "gpt-5.4", reasoningEffort: "high" },
+        })
+      } else if (message.method === "turn/start") {
+        if (message.params.input[0]?.text === "make a plan") {
+          child.writeServerMessage({
+            id: message.id,
+            result: { turn: { id: "turn-plan", status: "completed", error: null } },
+          })
+          child.writeServerMessage({
+            method: "turn/plan/updated",
+            params: {
+              threadId: "thread-1",
+              turnId: "turn-plan",
+              explanation: "Plan the work",
+              plan: [{ step: "Inspect repo", status: "completed" }],
+            },
+          })
+          child.writeServerMessage({
+            method: "turn/completed",
+            params: {
+              threadId: "thread-1",
+              turn: { id: "turn-plan", status: "completed", error: null },
+            },
+          })
+        } else {
+          child.writeServerMessage({
+            id: message.id,
+            result: { turn: { id: "turn-next", status: "completed", error: null } },
+          })
+          child.writeServerMessage({
+            method: "turn/completed",
+            params: {
+              threadId: "thread-1",
+              turn: { id: "turn-next", status: "completed", error: null },
+            },
+          })
+        }
+      }
+    })
+
+    const manager = new CodexAppServerManager({
+      spawnProcess: () => process as never,
+    })
+
+    await manager.startSession({
+      chatId: "chat-1",
+      cwd: "/tmp/project",
+      model: "gpt-5.4",
+      sessionToken: null,
+    })
+
+    const turn = await manager.startTurn({
+      chatId: "chat-1",
+      model: "gpt-5.4",
+      content: "make a plan",
+      planMode: true,
+      onToolRequest: async () => await new Promise((resolve) => {
+        resolveToolRequest = resolve
+      }),
+    })
+
+    const iterator = turn.stream[Symbol.asyncIterator]()
+    await iterator.next()
+    await iterator.next()
+    await iterator.next()
+    await turn.interrupt()
+
+    const nextTurn = await manager.startTurn({
+      chatId: "chat-1",
+      model: "gpt-5.4",
+      content: "continue",
+      planMode: false,
+      onToolRequest: async () => ({}),
+    })
+
+    await collectStream(nextTurn.stream)
+    resolveToolRequest({})
+  })
+
   test("emits an error result when the app-server exits mid-turn", async () => {
     const process = new FakeCodexProcess((message, child) => {
       if (message.method === "initialize") {

package/src/server/codex-app-server.ts

@@ -30,6 +30,7 @@ import {
   type ThreadStartParams,
   type ThreadStartResponse,
   type ToolRequestUserInputParams,
+  type ToolRequestUserInputQuestion,
   type ToolRequestUserInputResponse,
   type TurnPlanStep,
   type TurnPlanUpdatedNotification,
@@ -174,6 +175,13 @@ function isRecoverableResumeError(error: unknown): boolean {
   )
 }
 
+const MULTI_SELECT_HINT_PATTERN = /\b(all that apply|select all|choose all|pick all|select multiple|choose multiple|pick multiple|multiple selections?|multiple choice|more than one|one or more)\b/i
+
+function inferQuestionAllowsMultiple(question: ToolRequestUserInputQuestion): boolean {
+  const combinedText = [question.header, question.question].filter(Boolean).join(" ")
+  return MULTI_SELECT_HINT_PATTERN.test(combinedText)
+}
+
 function toAskUserQuestionItems(params: ToolRequestUserInputParams): AskUserQuestionItem[] {
   return params.questions.map((question) => ({
     id: question.id,
@@ -183,7 +191,7 @@ function toAskUserQuestionItems(params: ToolRequestUserInputParams): AskUserQues
       label: option.label,
       description: option.description ?? undefined,
     })),
-    multiSelect: false,
+    multiSelect: inferQuestionAllowsMultiple(question),
   }))
 }
 
@@ -782,7 +790,14 @@ export class CodexAppServerManager {
       stream: queue,
       interrupt: async () => {
         const pendingTurn = context.pendingTurn
-        if (!pendingTurn?.turnId || !context.sessionToken) return
+        if (!pendingTurn) return
+
+        context.pendingTurn = null
+        pendingTurn.resolved = true
+        pendingTurn.queue.finish()
+
+        if (!pendingTurn.turnId || !context.sessionToken) return
+
         await this.sendRequest(context, "turn/interrupt", {
           threadId: context.sessionToken,
           turnId: pendingTurn.turnId,