kanna-code 0.31.0 → 0.32.0

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

@@ -1,9 +1,33 @@
 import { describe, expect, test } from "bun:test"
-import type { KeybindingsSnapshot, UpdateSnapshot } from "../shared/types"
+import type { KeybindingsSnapshot, LlmProviderSnapshot, UpdateSnapshot } from "../shared/types"
 import { PROTOCOL_VERSION } from "../shared/types"
 import { createEmptyState } from "./events"
 import { createWsRouter } from "./ws-router"
 
+function withSidebarGroupDefaults(group: {
+  groupKey: string
+  localPath: string
+  chats: Array<{
+    _id: string
+    _creationTime: number
+    chatId: string
+    title: string
+    status: "idle" | "starting" | "running" | "waiting_for_user" | "failed"
+    unread: boolean
+    localPath: string
+    provider: "claude" | "codex" | null
+    lastMessageAt?: number
+    hasAutomation: boolean
+  }>
+}) {
+  return {
+    ...group,
+    previewChats: group.chats,
+    olderChats: [],
+    defaultCollapsed: true,
+  }
+}
+
 class FakeWebSocket {
   readonly sent: unknown[] = []
   readonly data = {
@@ -42,6 +66,17 @@ const DEFAULT_UPDATE_SNAPSHOT: UpdateSnapshot = {
   reloadRequestedAt: null,
 }
 
+const DEFAULT_LLM_PROVIDER_SNAPSHOT: LlmProviderSnapshot = {
+  provider: "openai",
+  apiKey: "",
+  model: "",
+  baseUrl: "",
+  resolvedBaseUrl: "https://api.openai.com/v1",
+  enabled: false,
+  warning: null,
+  filePathDisplay: "~/.kanna/llm-provider.json",
+}
+
 describe("ws-router", () => {
   test("acks system.ping without broadcasting snapshots", async () => {
     const router = createWsRouter({
@@ -83,6 +118,94 @@ describe("ws-router", () => {
     ])
   })
 
+  test("reads and writes llm provider settings via commands", async () => {
+    const writes: Array<Pick<LlmProviderSnapshot, "provider" | "apiKey" | "model" | "baseUrl">> = []
+    const router = createWsRouter({
+      store: { state: createEmptyState() } as never,
+      agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set() } as never,
+      terminals: {
+        getSnapshot: () => null,
+        onEvent: () => () => {},
+      } as never,
+      keybindings: {
+        getSnapshot: () => DEFAULT_KEYBINDINGS_SNAPSHOT,
+        onChange: () => () => {},
+      } as never,
+      llmProvider: {
+        read: async () => DEFAULT_LLM_PROVIDER_SNAPSHOT,
+        write: async (value) => {
+          writes.push(value)
+          return {
+            ...DEFAULT_LLM_PROVIDER_SNAPSHOT,
+            ...value,
+            resolvedBaseUrl: value.provider === "custom" ? value.baseUrl : "https://api.openai.com/v1",
+            enabled: Boolean(value.apiKey && value.model),
+          }
+        },
+      },
+      refreshDiscovery: async () => [],
+      getDiscoveredProjects: () => [],
+      machineDisplayName: "Local Machine",
+      updateManager: null,
+    })
+    const ws = new FakeWebSocket()
+
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "llm-read-1",
+        command: { type: "settings.readLlmProvider" },
+      })
+    )
+
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "llm-write-1",
+        command: {
+          type: "settings.writeLlmProvider",
+          provider: "custom",
+          apiKey: "test-key",
+          model: "gpt-test",
+          baseUrl: "https://example.com/v1",
+        },
+      })
+    )
+
+    expect(ws.sent).toEqual([
+      {
+        v: PROTOCOL_VERSION,
+        type: "ack",
+        id: "llm-read-1",
+        result: DEFAULT_LLM_PROVIDER_SNAPSHOT,
+      },
+      {
+        v: PROTOCOL_VERSION,
+        type: "ack",
+        id: "llm-write-1",
+        result: {
+          ...DEFAULT_LLM_PROVIDER_SNAPSHOT,
+          provider: "custom",
+          apiKey: "test-key",
+          model: "gpt-test",
+          baseUrl: "https://example.com/v1",
+          resolvedBaseUrl: "https://example.com/v1",
+          enabled: true,
+        },
+      },
+    ])
+    expect(writes).toEqual([{
+      provider: "custom",
+      apiKey: "test-key",
+      model: "gpt-test",
+      baseUrl: "https://example.com/v1",
+    }])
+  })
+
   test("acks terminal.input without rebroadcasting terminal snapshots", async () => {
     const router = createWsRouter({
       store: { state: createEmptyState() } as never,
@@ -183,6 +306,54 @@ describe("ws-router", () => {
     })
   })
 
+  test("reuses one sidebar derivation across sockets in the same broadcast pass", async () => {
+    const state = createEmptyState()
+    state.projectsById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Project",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+
+    let activeStatusCalls = 0
+    const router = createWsRouter({
+      store: { state } as never,
+      agent: {
+        getActiveStatuses: () => {
+          activeStatusCalls += 1
+          return new Map()
+        },
+        getDrainingChatIds: () => new Set(),
+      } as never,
+      terminals: {
+        getSnapshot: () => null,
+        onEvent: () => () => {},
+      } as never,
+      keybindings: {
+        getSnapshot: () => DEFAULT_KEYBINDINGS_SNAPSHOT,
+        onChange: () => () => {},
+      } as never,
+      refreshDiscovery: async () => [],
+      getDiscoveredProjects: () => [],
+      machineDisplayName: "Local Machine",
+      updateManager: null,
+    })
+
+    const wsA = new FakeWebSocket()
+    const wsB = new FakeWebSocket()
+    router.handleOpen(wsA as never)
+    router.handleOpen(wsB as never)
+    wsA.data.subscriptions.set("sidebar-a", { type: "sidebar" })
+    wsB.data.subscriptions.set("sidebar-b", { type: "sidebar" })
+
+    await router.broadcastSnapshots()
+
+    expect(activeStatusCalls).toBe(1)
+    expect(wsA.sent).toHaveLength(1)
+    expect(wsB.sent).toHaveLength(1)
+  })
+
   test("subscribes to project git snapshots independently from chat snapshots", async () => {
     const state = createEmptyState()
     state.projectsById.set("project-1", {
@@ -625,7 +796,7 @@ describe("ws-router", () => {
       snapshot: {
         type: "sidebar",
         data: {
-          projectGroups: [{
+          projectGroups: [withSidebarGroupDefaults({
             groupKey: "project-1",
             localPath: "/tmp/project",
             chats: [{
@@ -637,10 +808,9 @@ describe("ws-router", () => {
               unread: false,
               localPath: "/tmp/project",
               provider: null,
-              lastMessageAt: undefined,
               hasAutomation: false,
             }],
-          }],
+          })],
         },
       },
     })
@@ -651,7 +821,7 @@ describe("ws-router", () => {
       snapshot: {
         type: "sidebar",
         data: {
-          projectGroups: [{
+          projectGroups: [withSidebarGroupDefaults({
             groupKey: "project-1",
             localPath: "/tmp/project",
             chats: [{
@@ -663,10 +833,102 @@ describe("ws-router", () => {
               unread: false,
               localPath: "/tmp/project",
               provider: null,
-              lastMessageAt: undefined,
               hasAutomation: false,
             }],
-          }],
+          })],
+        },
+      },
+    })
+  })
+
+  test("reorders sidebar project groups on the server and rebroadcasts the snapshot", async () => {
+    const state = createEmptyState()
+    state.projectsById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project-1",
+      title: "Project 1",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+    state.projectsById.set("project-2", {
+      id: "project-2",
+      localPath: "/tmp/project-2",
+      title: "Project 2",
+      createdAt: 2,
+      updatedAt: 2,
+    })
+
+    const setSidebarProjectOrderCalls: string[][] = []
+    const router = createWsRouter({
+      store: {
+        state,
+        async setSidebarProjectOrder(projectIds: string[]) {
+          setSidebarProjectOrderCalls.push(projectIds)
+          state.sidebarProjectOrder = [...projectIds]
+        },
+      } as never,
+      agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set() } as never,
+      terminals: {
+        getSnapshot: () => null,
+        onEvent: () => () => {},
+      } as never,
+      keybindings: {
+        getSnapshot: () => DEFAULT_KEYBINDINGS_SNAPSHOT,
+        onChange: () => () => {},
+      } as never,
+      refreshDiscovery: async () => [],
+      getDiscoveredProjects: () => [],
+      machineDisplayName: "Local Machine",
+      updateManager: null,
+    })
+    const ws = new FakeWebSocket()
+    router.handleOpen(ws as never)
+
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "subscribe",
+        id: "sidebar-sub-1",
+        topic: { type: "sidebar" },
+      })
+    )
+
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "sidebar-reorder-1",
+        command: { type: "sidebar.reorderProjectGroups", projectIds: ["project-1", "project-2"] },
+      })
+    )
+
+    expect(setSidebarProjectOrderCalls).toEqual([["project-1", "project-2"]])
+    expect(ws.sent.at(-2)).toEqual({
+      v: PROTOCOL_VERSION,
+      type: "ack",
+      id: "sidebar-reorder-1",
+    })
+    expect(ws.sent.at(-1)).toEqual({
+      v: PROTOCOL_VERSION,
+      type: "snapshot",
+      id: "sidebar-sub-1",
+      snapshot: {
+        type: "sidebar",
+        data: {
+          projectGroups: [
+            withSidebarGroupDefaults({
+              groupKey: "project-1",
+              localPath: "/tmp/project-1",
+              chats: [],
+            }),
+            withSidebarGroupDefaults({
+              groupKey: "project-2",
+              localPath: "/tmp/project-2",
+              chats: [],
+            }),
+          ],
         },
       },
     })
@@ -741,9 +1003,11 @@ describe("ws-router", () => {
         type: "sidebar",
         data: {
           projectGroups: [{
-            groupKey: "project-1",
-            localPath: "/tmp/project",
-            chats: [],
+            ...withSidebarGroupDefaults({
+              groupKey: "project-1",
+              localPath: "/tmp/project",
+              chats: [],
+            }),
           }],
         },
       },

package/src/server/ws-router.ts

@@ -12,6 +12,7 @@ import { ensureProjectDirectory } from "./paths"
 import { TerminalManager } from "./terminal-manager"
 import type { UpdateManager } from "./update-manager"
 import { deriveChatSnapshot, deriveLocalProjectsSnapshot, deriveSidebarData } from "./read-models"
+import type { LlmProviderSnapshot } from "../shared/types"
 
 const DEFAULT_CHAT_RECENT_LIMIT = 200
 
@@ -96,6 +97,10 @@ interface CreateWsRouterArgs {
   agent: AgentCoordinator
   terminals: TerminalManager
   keybindings: KeybindingsManager
+  llmProvider?: {
+    read: () => Promise<LlmProviderSnapshot>
+    write: (value: Pick<LlmProviderSnapshot, "provider" | "apiKey" | "model" | "baseUrl">) => Promise<LlmProviderSnapshot>
+  }
   refreshDiscovery: () => Promise<DiscoveredProject[]>
   getDiscoveredProjects: () => DiscoveredProject[]
   machineDisplayName: string
@@ -112,6 +117,13 @@ interface SnapshotBroadcastFilter {
   terminalIds?: Set<string>
 }
 
+interface SnapshotComputationCache {
+  sidebar?: {
+    data: ReturnType<typeof deriveSidebarData>
+    signature: string
+  }
+}
+
 function send(ws: ServerWebSocket<ClientState>, message: ServerEnvelope) {
   const payload = JSON.stringify(message)
   ws.send(payload)
@@ -132,6 +144,7 @@ export function createWsRouter({
   agent,
   terminals,
   keybindings,
+  llmProvider,
   refreshDiscovery,
   getDiscoveredProjects,
   machineDisplayName,
@@ -160,6 +173,37 @@ export function createWsRouter({
     ignoreFile: async () => ({ snapshotChanged: false }),
     readPatch: async () => ({ patch: "" }),
   }
+  const resolvedLlmProvider = llmProvider ?? {
+    read: async () => ({
+      provider: "openai" as const,
+      apiKey: "",
+      model: "gpt-5.4-mini",
+      baseUrl: "",
+      resolvedBaseUrl: "https://api.openai.com/v1",
+      enabled: false,
+      warning: null,
+      filePathDisplay: "~/.kanna/llm-provider.json",
+    }),
+    write: async ({ provider, apiKey, model, baseUrl }: {
+      provider: "openai" | "openrouter" | "custom"
+      apiKey: string
+      model: string
+      baseUrl: string
+    }) => ({
+      provider,
+      apiKey,
+      model,
+      baseUrl,
+      resolvedBaseUrl: provider === "openrouter"
+        ? "https://openrouter.ai/api/v1"
+        : provider === "custom"
+          ? baseUrl
+          : "https://api.openai.com/v1",
+      enabled: false,
+      warning: null,
+      filePathDisplay: "~/.kanna/llm-provider.json",
+    }),
+  }
 
   function getProtectedChatIds() {
     const activeStatuses = agent.getActiveStatuses()
@@ -241,28 +285,50 @@ export function createWsRouter({
     return true
   }
 
-  function createEnvelope(id: string, topic: SubscriptionTopic): ServerEnvelope {
+  function getSidebarSnapshotCacheEntry(cache?: SnapshotComputationCache) {
+    if (cache?.sidebar) {
+      return cache.sidebar
+    }
+
+    const startedAt = performance.now()
+    const data = deriveSidebarData(store.state, agent.getActiveStatuses())
+    if (isSendToStartingProfilingEnabled()) {
+      const totalChats = data.projectGroups.reduce((count, group) => count + group.chats.length, 0)
+      console.log("[kanna/send->starting][server]", JSON.stringify({
+        stage: "ws.sidebar_snapshot_built",
+        elapsedMs: Number((performance.now() - startedAt).toFixed(1)),
+        projectGroupCount: data.projectGroups.length,
+        chatCount: totalChats,
+        totalChatCount: store.state.chatsById.size,
+        totalProjectCount: store.state.projectsById.size,
+      }))
+    }
+
+    const sidebar = {
+      data,
+      signature: JSON.stringify({
+        type: "sidebar" as const,
+        data,
+      }),
+    }
+
+    if (cache) {
+      cache.sidebar = sidebar
+    }
+
+    return sidebar
+  }
+
+  function createEnvelope(id: string, topic: SubscriptionTopic, cache?: SnapshotComputationCache): ServerEnvelope {
     if (topic.type === "sidebar") {
-      const startedAt = performance.now()
-      const data = deriveSidebarData(store.state, agent.getActiveStatuses())
-      if (isSendToStartingProfilingEnabled()) {
-        const totalChats = data.projectGroups.reduce((count, group) => count + group.chats.length, 0)
-        console.log("[kanna/send->starting][server]", JSON.stringify({
-          stage: "ws.sidebar_snapshot_built",
-          elapsedMs: Number((performance.now() - startedAt).toFixed(1)),
-          projectGroupCount: data.projectGroups.length,
-          chatCount: totalChats,
-          totalChatCount: store.state.chatsById.size,
-          totalProjectCount: store.state.projectsById.size,
-        }))
-      }
+      const sidebar = getSidebarSnapshotCacheEntry(cache)
       return {
         v: PROTOCOL_VERSION,
         type: "snapshot",
         id,
         snapshot: {
           type: "sidebar",
-          data,
+          data: sidebar.data,
         },
       }
     }
@@ -360,7 +426,7 @@ export function createWsRouter({
 
   async function pushSnapshots(
     ws: ServerWebSocket<ClientState>,
-    options?: { skipPrune?: boolean; filter?: SnapshotBroadcastFilter }
+    options?: { skipPrune?: boolean; filter?: SnapshotBroadcastFilter; cache?: SnapshotComputationCache }
   ) {
     const pushStartedAt = performance.now()
     if (!options?.skipPrune) {
@@ -374,11 +440,13 @@ export function createWsRouter({
         continue
       }
       const envelopeStartedAt = performance.now()
-      const envelope = createEnvelope(id, topic)
+      const envelope = createEnvelope(id, topic, options?.cache)
       const createdAt = performance.now()
       if (envelope.type !== "snapshot") continue
-      const signature = JSON.stringify(envelope.snapshot)
-      const signatureReadyAt = performance.now()
+      const signature = topic.type === "sidebar"
+        ? getSidebarSnapshotCacheEntry(options?.cache).signature
+        : JSON.stringify(envelope.snapshot)
+      const signatureReadyAt = topic.type === "sidebar" ? createdAt : performance.now()
       if (snapshotSignatures.get(id) === signature) {
         skippedCount += 1
         continue
@@ -420,9 +488,10 @@ export function createWsRouter({
   async function broadcastSnapshots() {
     const startedAt = performance.now()
     let socketCount = 0
+    const cache: SnapshotComputationCache = {}
     for (const ws of sockets) {
       socketCount += 1
-      await pushSnapshots(ws, { skipPrune: true })
+      await pushSnapshots(ws, { skipPrune: true, cache })
     }
     if (isSendToStartingProfilingEnabled()) {
       console.log("[kanna/send->starting][server]", JSON.stringify({
@@ -439,9 +508,10 @@ export function createWsRouter({
   async function broadcastFilteredSnapshots(filter: SnapshotBroadcastFilter) {
     const startedAt = performance.now()
     let socketCount = 0
+    const cache: SnapshotComputationCache = {}
     for (const ws of sockets) {
       socketCount += 1
-      await pushSnapshots(ws, { skipPrune: true, filter })
+      await pushSnapshots(ws, { skipPrune: true, filter, cache })
     }
     if (isSendToStartingProfilingEnabled()) {
       console.log("[kanna/send->starting][server]", JSON.stringify({
@@ -646,6 +716,20 @@ export function createWsRouter({
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: snapshot })
           return
         }
+        case "settings.readLlmProvider": {
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: await resolvedLlmProvider.read() })
+          return
+        }
+        case "settings.writeLlmProvider": {
+          const snapshot = await resolvedLlmProvider.write({
+            provider: command.provider,
+            apiKey: command.apiKey,
+            model: command.model,
+            baseUrl: command.baseUrl,
+          })
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: snapshot })
+          return
+        }
         case "project.open": {
           await ensureProjectDirectory(command.localPath)
           const project = await store.openProject(command.localPath)
@@ -673,6 +757,12 @@ export function createWsRouter({
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
           break
         }
+        case "sidebar.reorderProjectGroups": {
+          await store.setSidebarProjectOrder(command.projectIds)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          await broadcastFilteredSnapshots({ includeSidebar: true })
+          return
+        }
         case "project.readDiffPatch": {
           const project = store.getProject(command.projectId)
           if (!project) {

package/src/shared/branding.ts

@@ -55,6 +55,14 @@ export function getKeybindingsFilePathDisplay(env: RuntimeEnv = getRuntimeEnv())
   return `${getDataRootDirDisplay(env)}/keybindings.json`
 }
 
+export function getLlmProviderFilePath(homeDir: string, env: RuntimeEnv = getRuntimeEnv()) {
+  return `${getDataRootDir(homeDir, env)}/llm-provider.json`
+}
+
+export function getLlmProviderFilePathDisplay(env: RuntimeEnv = getRuntimeEnv()) {
+  return `${getDataRootDirDisplay(env)}/llm-provider.json`
+}
+
 export function getCliInvocation(arg?: string) {
   return arg ? `${CLI_COMMAND} ${arg}` : CLI_COMMAND
 }

package/src/shared/protocol.ts

@@ -6,6 +6,7 @@ import type {
   ChatSnapshot,
   DiffCommitMode,
   KeybindingsSnapshot,
+  LlmProviderSnapshot,
   LocalProjectsSnapshot,
   ModelOptions,
   SidebarData,
@@ -50,12 +51,21 @@ export type ClientCommand =
   | { type: "project.open"; localPath: string }
   | { type: "project.create"; localPath: string; title: string }
   | { type: "project.remove"; projectId: string }
+  | { type: "sidebar.reorderProjectGroups"; projectIds: string[] }
   | { type: "project.readDiffPatch"; projectId: string; path: string }
   | { type: "system.ping" }
   | { type: "update.check"; force?: boolean }
   | { type: "update.install" }
   | { type: "settings.readKeybindings" }
   | { type: "settings.writeKeybindings"; bindings: KeybindingsSnapshot["bindings"] }
+  | { type: "settings.readLlmProvider" }
+  | {
+      type: "settings.writeLlmProvider"
+      provider: LlmProviderSnapshot["provider"]
+      apiKey: string
+      model: string
+      baseUrl: string
+    }
   | {
       type: "system.openExternal"
       localPath: string
@@ -189,6 +199,7 @@ export type ServerSnapshot =
   | { type: "local-projects"; data: LocalProjectsSnapshot }
   | { type: "update"; data: UpdateSnapshot }
   | { type: "keybindings"; data: KeybindingsSnapshot }
+  | { type: "llm-provider"; data: LlmProviderSnapshot }
   | { type: "chat"; data: ChatSnapshot | null }
   | { type: "project-git"; data: ChatDiffSnapshot | null }
   | { type: "terminal"; data: TerminalSnapshot | null }

package/src/shared/types.ts

@@ -2,6 +2,9 @@ export const STORE_VERSION = 2 as const
 export const PROTOCOL_VERSION = 1 as const
 
 export type AgentProvider = "claude" | "codex"
+export type LlmProviderKind = "openai" | "openrouter" | "custom"
+export const DEFAULT_OPENAI_SDK_MODEL = "gpt-5.4-mini"
+export const DEFAULT_OPENROUTER_SDK_MODEL = "moonshotai/kimi-k2.5:nitro"
 
 export type AttachmentKind = "image" | "file"
 
@@ -224,6 +227,9 @@ export interface SidebarProjectGroup {
   groupKey: string
   localPath: string
   chats: SidebarChatRow[]
+  previewChats: SidebarChatRow[]
+  olderChats: SidebarChatRow[]
+  defaultCollapsed: boolean
 }
 
 export interface SidebarData {
@@ -246,6 +252,24 @@ export interface LocalProjectsSnapshot {
   projects: LocalProjectSummary[]
 }
 
+export interface LlmProviderFile {
+  provider?: LlmProviderKind
+  apiKey?: string
+  model?: string
+  baseUrl?: string | null
+}
+
+export interface LlmProviderSnapshot {
+  provider: LlmProviderKind
+  apiKey: string
+  model: string
+  baseUrl: string
+  resolvedBaseUrl: string
+  enabled: boolean
+  warning: string | null
+  filePathDisplay: string
+}
+
 export type UpdateStatus =
   | "idle"
   | "checking"