kanna-code 0.11.0 → 0.13.0

package/src/server/restart.ts

@@ -0,0 +1,24 @@
+export const CLI_CHILD_MODE_ENV_VAR = "KANNA_CLI_MODE"
+export const CLI_CHILD_MODE = "child"
+export const CLI_RESTART_EXIT_CODE = 75
+export const CLI_CHILD_COMMAND_ENV_VAR = "KANNA_CLI_CHILD_COMMAND"
+export const CLI_CHILD_ARGS_ENV_VAR = "KANNA_CLI_CHILD_ARGS"
+
+export function shouldRestartCliProcess(code: number | null, signal: NodeJS.Signals | null) {
+  return signal === null && code === CLI_RESTART_EXIT_CODE
+}
+
+export function parseChildArgsEnv(value: string | undefined) {
+  if (!value) return []
+
+  try {
+    const parsed = JSON.parse(value) as unknown
+    if (!Array.isArray(parsed) || !parsed.every((entry) => typeof entry === "string")) {
+      throw new Error("child args must be an array of strings")
+    }
+    return parsed
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    throw new Error(`Invalid ${CLI_CHILD_ARGS_ENV_VAR}: ${message}`)
+  }
+}

package/src/server/server.ts

@@ -1,16 +1,22 @@
 import path from "node:path"
-import { APP_NAME } from "../shared/branding"
+import { APP_NAME, getRuntimeProfile } from "../shared/branding"
 import { EventStore } from "./event-store"
 import { AgentCoordinator } from "./agent"
 import { discoverProjects, type DiscoveredProject } from "./discovery"
 import { KeybindingsManager } from "./keybindings"
 import { getMachineDisplayName } from "./machine-name"
 import { TerminalManager } from "./terminal-manager"
+import { UpdateManager } from "./update-manager"
 import { createWsRouter, type ClientState } from "./ws-router"
 
 export interface StartKannaServerOptions {
   port?: number
   strictPort?: boolean
+  update?: {
+    version: string
+    fetchLatestVersion: (packageName: string) => Promise<string>
+    installLatest: (packageName: string) => boolean
+  }
 }
 
 export async function startKannaServer(options: StartKannaServerOptions = {}) {
@@ -33,6 +39,14 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   const terminals = new TerminalManager()
   const keybindings = new KeybindingsManager()
   await keybindings.initialize()
+  const updateManager = options.update
+    ? new UpdateManager({
+        currentVersion: options.update.version,
+        fetchLatestVersion: options.update.fetchLatestVersion,
+        installLatest: options.update.installLatest,
+        devMode: getRuntimeProfile() === "dev",
+      })
+    : null
   const agent = new AgentCoordinator({
     store,
     onStateChange: () => {
@@ -47,6 +61,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
     refreshDiscovery,
     getDiscoveredProjects: () => discoveredProjects,
     machineDisplayName,
+    updateManager,
   })
 
   const distDir = path.join(import.meta.dir, "..", "..", "dist", "client")
@@ -114,6 +129,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   return {
     port: actualPort,
     store,
+    updateManager,
     stop: shutdown,
   }
 }

package/src/server/update-manager.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from "bun:test"
+import { UpdateManager } from "./update-manager"
+
+describe("UpdateManager", () => {
+  test("detects available updates", async () => {
+    const manager = new UpdateManager({
+      currentVersion: "0.12.0",
+      fetchLatestVersion: async () => "0.13.0",
+      installLatest: () => true,
+    })
+
+    const snapshot = await manager.checkForUpdates({ force: true })
+
+    expect(snapshot.status).toBe("available")
+    expect(snapshot.updateAvailable).toBe(true)
+    expect(snapshot.latestVersion).toBe("0.13.0")
+    expect(snapshot.installAction).toBe("restart")
+  })
+
+  test("bypasses cache when force is true", async () => {
+    let calls = 0
+    const manager = new UpdateManager({
+      currentVersion: "0.12.0",
+      fetchLatestVersion: async () => {
+        calls += 1
+        return calls === 1 ? "0.12.1" : "0.13.0"
+      },
+      installLatest: () => true,
+    })
+
+    await manager.checkForUpdates()
+    await manager.checkForUpdates({ force: true })
+
+    expect(calls).toBe(2)
+    expect(manager.getSnapshot().latestVersion).toBe("0.13.0")
+  })
+
+  test("surfaces install failures without clearing the running version", async () => {
+    const manager = new UpdateManager({
+      currentVersion: "0.12.0",
+      fetchLatestVersion: async () => "0.13.0",
+      installLatest: () => false,
+    })
+
+    const result = await manager.installUpdate()
+
+    expect(result).toEqual({ ok: false, action: "restart" })
+    expect(manager.getSnapshot().status).toBe("error")
+    expect(manager.getSnapshot().currentVersion).toBe("0.12.0")
+  })
+
+  test("always exposes an available reload action in dev mode", async () => {
+    const manager = new UpdateManager({
+      currentVersion: "0.12.0",
+      fetchLatestVersion: async () => "9.9.9",
+      installLatest: () => true,
+      devMode: true,
+    })
+
+    expect(manager.getSnapshot()).toMatchObject({
+      status: "available",
+      updateAvailable: true,
+      installAction: "restart",
+    })
+
+    const result = await manager.installUpdate()
+    expect(result).toEqual({ ok: true, action: "restart" })
+    expect(manager.getSnapshot().status).toBe("restart_pending")
+  })
+})

package/src/server/update-manager.ts

@@ -0,0 +1,204 @@
+import type { UpdateSnapshot } from "../shared/types"
+import { PACKAGE_NAME } from "../shared/branding"
+import { compareVersions } from "./cli-runtime"
+
+const UPDATE_CACHE_TTL_MS = 5 * 60 * 1000
+
+export interface UpdateManagerDeps {
+  currentVersion: string
+  fetchLatestVersion: (packageName: string) => Promise<string>
+  installLatest: (packageName: string) => boolean
+  devMode?: boolean
+}
+
+export interface UpdateInstallResult {
+  ok: boolean
+  action: "restart" | "reload"
+}
+
+export class UpdateManager {
+  private readonly deps: UpdateManagerDeps
+  private readonly listeners = new Set<(snapshot: UpdateSnapshot) => void>()
+  private snapshot: UpdateSnapshot
+  private checkPromise: Promise<UpdateSnapshot> | null = null
+  private installPromise: Promise<UpdateInstallResult> | null = null
+
+  constructor(deps: UpdateManagerDeps) {
+    this.deps = deps
+    this.snapshot = {
+      currentVersion: deps.currentVersion,
+      latestVersion: deps.devMode ? `${deps.currentVersion}-dev` : null,
+      status: deps.devMode ? "available" : "idle",
+      updateAvailable: Boolean(deps.devMode),
+      lastCheckedAt: deps.devMode ? Date.now() : null,
+      error: null,
+      installAction: "restart",
+    }
+  }
+
+  getSnapshot() {
+    return this.snapshot
+  }
+
+  onChange(listener: (snapshot: UpdateSnapshot) => void) {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  async checkForUpdates(options: { force?: boolean } = {}) {
+    if (this.deps.devMode) {
+      return this.snapshot
+    }
+
+    if (this.snapshot.status === "updating" || this.snapshot.status === "restart_pending") {
+      return this.snapshot
+    }
+
+    if (this.checkPromise) {
+      return this.checkPromise
+    }
+
+    if (!options.force && this.snapshot.lastCheckedAt && Date.now() - this.snapshot.lastCheckedAt < UPDATE_CACHE_TTL_MS) {
+      return this.snapshot
+    }
+
+    this.setSnapshot({
+      ...this.snapshot,
+      status: "checking",
+      error: null,
+    })
+
+    const checkPromise = this.runCheck()
+    this.checkPromise = checkPromise
+
+    try {
+      return await checkPromise
+    } finally {
+      if (this.checkPromise === checkPromise) {
+        this.checkPromise = null
+      }
+    }
+  }
+
+  async installUpdate(): Promise<UpdateInstallResult> {
+    if (this.deps.devMode) {
+      this.setSnapshot({
+        ...this.snapshot,
+        status: "updating",
+        error: null,
+      })
+
+      this.setSnapshot({
+        ...this.snapshot,
+        status: "restart_pending",
+        updateAvailable: false,
+        error: null,
+      })
+
+      return {
+        ok: true,
+        action: "restart",
+      }
+    }
+
+    if (this.snapshot.status === "updating" || this.snapshot.status === "restart_pending") {
+      return {
+        ok: this.snapshot.updateAvailable,
+        action: "restart",
+      }
+    }
+
+    if (this.installPromise) {
+      return this.installPromise
+    }
+
+    const installPromise = this.runInstall()
+    this.installPromise = installPromise
+
+    try {
+      return await installPromise
+    } finally {
+      if (this.installPromise === installPromise) {
+        this.installPromise = null
+      }
+    }
+  }
+
+  private async runCheck() {
+    try {
+      const latestVersion = await this.deps.fetchLatestVersion(PACKAGE_NAME)
+      const updateAvailable = compareVersions(this.snapshot.currentVersion, latestVersion) < 0
+      const nextSnapshot: UpdateSnapshot = {
+        ...this.snapshot,
+        latestVersion,
+        updateAvailable,
+        status: updateAvailable ? "available" : "up_to_date",
+        lastCheckedAt: Date.now(),
+        error: null,
+      }
+      this.setSnapshot(nextSnapshot)
+      return nextSnapshot
+    } catch (error) {
+      const nextSnapshot: UpdateSnapshot = {
+        ...this.snapshot,
+        status: "error",
+        lastCheckedAt: Date.now(),
+        error: error instanceof Error ? error.message : String(error),
+      }
+      this.setSnapshot(nextSnapshot)
+      return nextSnapshot
+    }
+  }
+
+  private async runInstall(): Promise<UpdateInstallResult> {
+    if (!this.snapshot.updateAvailable) {
+      const snapshot = await this.checkForUpdates({ force: true })
+      if (!snapshot.updateAvailable) {
+        return {
+          ok: false,
+          action: "restart",
+        }
+      }
+    }
+
+    this.setSnapshot({
+      ...this.snapshot,
+      status: "updating",
+      error: null,
+    })
+
+    const installed = this.deps.installLatest(PACKAGE_NAME)
+    if (!installed) {
+      this.setSnapshot({
+        ...this.snapshot,
+        status: "error",
+        error: "Unable to install the latest version.",
+      })
+      return {
+        ok: false,
+        action: "restart",
+      }
+    }
+
+    this.setSnapshot({
+      ...this.snapshot,
+      currentVersion: this.snapshot.latestVersion ?? this.snapshot.currentVersion,
+      status: "restart_pending",
+      updateAvailable: false,
+      error: null,
+    })
+    return {
+      ok: true,
+      action: "restart",
+    }
+  }
+
+  private setSnapshot(snapshot: UpdateSnapshot) {
+    this.snapshot = snapshot
+    for (const listener of this.listeners) {
+      listener(snapshot)
+    }
+  }
+}

package/src/server/ws-router.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import type { KeybindingsSnapshot } from "../shared/types"
+import type { KeybindingsSnapshot, UpdateSnapshot } from "../shared/types"
 import { PROTOCOL_VERSION } from "../shared/types"
 import { createEmptyState } from "./events"
 import { createWsRouter } from "./ws-router"
@@ -27,6 +27,16 @@ const DEFAULT_KEYBINDINGS_SNAPSHOT: KeybindingsSnapshot = {
   filePathDisplay: "~/.kanna/keybindings.json",
 }
 
+const DEFAULT_UPDATE_SNAPSHOT: UpdateSnapshot = {
+  currentVersion: "0.12.0",
+  latestVersion: null,
+  status: "idle",
+  updateAvailable: false,
+  lastCheckedAt: null,
+  error: null,
+  installAction: "restart",
+}
+
 describe("ws-router", () => {
   test("acks system.ping without broadcasting snapshots", () => {
     const router = createWsRouter({
@@ -43,6 +53,7 @@ describe("ws-router", () => {
       refreshDiscovery: async () => [],
       getDiscoveredProjects: () => [],
       machineDisplayName: "Local Machine",
+      updateManager: null,
     })
     const ws = new FakeWebSocket()
 
@@ -82,6 +93,7 @@ describe("ws-router", () => {
       refreshDiscovery: async () => [],
       getDiscoveredProjects: () => [],
       machineDisplayName: "Local Machine",
+      updateManager: null,
     })
     const ws = new FakeWebSocket()
 
@@ -124,6 +136,7 @@ describe("ws-router", () => {
       refreshDiscovery: async () => [],
       getDiscoveredProjects: () => [],
       machineDisplayName: "Local Machine",
+      updateManager: null,
     })
     const ws = new FakeWebSocket()
 
@@ -188,6 +201,7 @@ describe("ws-router", () => {
       refreshDiscovery: async () => [],
       getDiscoveredProjects: () => [],
       machineDisplayName: "Local Machine",
+      updateManager: null,
     })
     const ws = new FakeWebSocket()
 
@@ -235,17 +249,107 @@ describe("ws-router", () => {
       v: PROTOCOL_VERSION,
       type: "ack",
       id: "keybindings-write-1",
-        result: {
-          bindings: {
-            toggleEmbeddedTerminal: ["cmd+k"],
-            toggleRightSidebar: ["ctrl+shift+b"],
-            openInFinder: ["cmd+shift+g"],
-            openInEditor: ["cmd+shift+p"],
-            addSplitTerminal: ["cmd+alt+j"],
-          },
-          warning: null,
-          filePathDisplay: "~/.kanna/keybindings.json",
+      result: {
+        bindings: {
+          toggleEmbeddedTerminal: ["cmd+k"],
+          toggleRightSidebar: ["ctrl+shift+b"],
+          openInFinder: ["cmd+shift+g"],
+          openInEditor: ["cmd+shift+p"],
+          addSplitTerminal: ["cmd+alt+j"],
+        },
+        warning: null,
+        filePathDisplay: "~/.kanna/keybindings.json",
+      },
+    })
+  })
+
+  test("subscribes to update snapshots and handles update.check commands", async () => {
+    const updateManager = {
+      snapshot: { ...DEFAULT_UPDATE_SNAPSHOT },
+      getSnapshot() {
+        return this.snapshot
+      },
+      onChange: () => () => {},
+      async checkForUpdates({ force }: { force?: boolean }) {
+        this.snapshot = {
+          ...this.snapshot,
+          latestVersion: force ? "0.13.0" : "0.12.1",
+          status: "available",
+          updateAvailable: true,
+          lastCheckedAt: 123,
+        }
+        return this.snapshot
+      },
+      async installUpdate() {
+        return true
+      },
+    }
+
+    const router = createWsRouter({
+      store: { state: createEmptyState() } as never,
+      agent: { getActiveStatuses: () => new Map() } as never,
+      terminals: {
+        getSnapshot: () => null,
+        onEvent: () => () => {},
+      } as never,
+      keybindings: {
+        getSnapshot: () => DEFAULT_KEYBINDINGS_SNAPSHOT,
+        onChange: () => () => {},
+      } as never,
+      refreshDiscovery: async () => [],
+      getDiscoveredProjects: () => [],
+      machineDisplayName: "Local Machine",
+      updateManager: updateManager as never,
+    })
+    const ws = new FakeWebSocket()
+
+    router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "subscribe",
+        id: "update-sub-1",
+        topic: { type: "update" },
+      })
+    )
+
+    expect(ws.sent[0]).toEqual({
+      v: PROTOCOL_VERSION,
+      type: "snapshot",
+      id: "update-sub-1",
+      snapshot: {
+        type: "update",
+        data: DEFAULT_UPDATE_SNAPSHOT,
+      },
+    })
+
+    router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "update-check-1",
+        command: {
+          type: "update.check",
+          force: true,
         },
       })
+    )
+
+    await Promise.resolve()
+    expect(ws.sent[1]).toEqual({
+      v: PROTOCOL_VERSION,
+      type: "ack",
+      id: "update-check-1",
+      result: {
+        currentVersion: "0.12.0",
+        latestVersion: "0.13.0",
+        status: "available",
+        updateAvailable: true,
+        lastCheckedAt: 123,
+        error: null,
+        installAction: "restart",
+      },
+    })
   })
 })

package/src/server/ws-router.ts

@@ -9,6 +9,7 @@ import { openExternal } from "./external-open"
 import { KeybindingsManager } from "./keybindings"
 import { ensureProjectDirectory } from "./paths"
 import { TerminalManager } from "./terminal-manager"
+import type { UpdateManager } from "./update-manager"
 import { deriveChatSnapshot, deriveLocalProjectsSnapshot, deriveSidebarData } from "./read-models"
 
 export interface ClientState {
@@ -23,6 +24,7 @@ interface CreateWsRouterArgs {
   refreshDiscovery: () => Promise<DiscoveredProject[]>
   getDiscoveredProjects: () => DiscoveredProject[]
   machineDisplayName: string
+  updateManager: UpdateManager | null
 }
 
 function send(ws: ServerWebSocket<ClientState>, message: ServerEnvelope) {
@@ -37,6 +39,7 @@ export function createWsRouter({
   refreshDiscovery,
   getDiscoveredProjects,
   machineDisplayName,
+  updateManager,
 }: CreateWsRouterArgs) {
   const sockets = new Set<ServerWebSocket<ClientState>>()
 
@@ -80,6 +83,26 @@ export function createWsRouter({
       }
     }
 
+    if (topic.type === "update") {
+      return {
+        v: PROTOCOL_VERSION,
+        type: "snapshot",
+        id,
+        snapshot: {
+          type: "update",
+          data: updateManager?.getSnapshot() ?? {
+            currentVersion: "unknown",
+            latestVersion: null,
+            status: "idle",
+            updateAvailable: false,
+            lastCheckedAt: null,
+            error: null,
+            installAction: "restart",
+          },
+        },
+      }
+    }
+
     if (topic.type === "terminal") {
       return {
         v: PROTOCOL_VERSION,
@@ -151,6 +174,15 @@ export function createWsRouter({
     }
   })
 
+  const disposeUpdateEvents = updateManager?.onChange(() => {
+    for (const ws of sockets) {
+      for (const [id, topic] of ws.data.subscriptions.entries()) {
+        if (topic.type !== "update") continue
+        send(ws, createEnvelope(id, topic))
+      }
+    }
+  }) ?? (() => {})
+
   async function handleCommand(ws: ServerWebSocket<ClientState>, message: Extract<ClientEnvelope, { type: "command" }>) {
     const { command, id } = message
     try {
@@ -159,6 +191,34 @@ export function createWsRouter({
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
           return
         }
+        case "update.check": {
+          const snapshot = updateManager
+            ? await updateManager.checkForUpdates({ force: command.force })
+            : {
+                currentVersion: "unknown",
+                latestVersion: null,
+                status: "error",
+                updateAvailable: false,
+                lastCheckedAt: Date.now(),
+                error: "Update manager unavailable.",
+                installAction: "restart",
+              }
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: snapshot })
+          return
+        }
+        case "update.install": {
+          if (!updateManager) {
+            throw new Error("Update manager unavailable.")
+          }
+          const result = await updateManager.installUpdate()
+          send(ws, {
+            v: PROTOCOL_VERSION,
+            type: "ack",
+            id,
+            result,
+          })
+          return
+        }
         case "settings.readKeybindings": {
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: keybindings.getSnapshot() })
           return
@@ -316,6 +376,7 @@ export function createWsRouter({
     dispose() {
       disposeTerminalEvents()
       disposeKeybindingEvents()
+      disposeUpdateEvents()
     },
   }
 }

package/src/shared/protocol.ts

@@ -5,6 +5,7 @@ import type {
   LocalProjectsSnapshot,
   ModelOptions,
   SidebarData,
+  UpdateSnapshot,
 } from "./types"
 
 export type EditorPreset = "cursor" | "vscode" | "windsurf" | "custom"
@@ -17,6 +18,7 @@ export interface EditorOpenSettings {
 export type SubscriptionTopic =
   | { type: "sidebar" }
   | { type: "local-projects" }
+  | { type: "update" }
   | { type: "keybindings" }
   | { type: "chat"; chatId: string }
   | { type: "terminal"; terminalId: string }
@@ -44,6 +46,8 @@ export type ClientCommand =
   | { type: "project.create"; localPath: string; title: string }
   | { type: "project.remove"; projectId: string }
   | { type: "system.ping" }
+  | { type: "update.check"; force?: boolean }
+  | { type: "update.install" }
   | { type: "settings.readKeybindings" }
   | { type: "settings.writeKeybindings"; bindings: KeybindingsSnapshot["bindings"] }
   | {
@@ -83,6 +87,7 @@ export type ClientEnvelope =
 export type ServerSnapshot =
   | { type: "sidebar"; data: SidebarData }
   | { type: "local-projects"; data: LocalProjectsSnapshot }
+  | { type: "update"; data: UpdateSnapshot }
   | { type: "keybindings"; data: KeybindingsSnapshot }
   | { type: "chat"; data: ChatSnapshot | null }
   | { type: "terminal"; data: TerminalSnapshot | null }

package/src/shared/types.ts

@@ -167,6 +167,25 @@ export interface LocalProjectsSnapshot {
   projects: LocalProjectSummary[]
 }
 
+export type UpdateStatus =
+  | "idle"
+  | "checking"
+  | "available"
+  | "up_to_date"
+  | "updating"
+  | "restart_pending"
+  | "error"
+
+export interface UpdateSnapshot {
+  currentVersion: string
+  latestVersion: string | null
+  status: UpdateStatus
+  updateAvailable: boolean
+  lastCheckedAt: number | null
+  error: string | null
+  installAction: "restart" | "reload"
+}
+
 export type KeybindingAction =
   | "toggleEmbeddedTerminal"
   | "toggleRightSidebar"