kanna-code 0.18.0 → 0.19.0

package/src/server/quick-response.ts

@@ -1,4 +1,6 @@
 import { query } from "@anthropic-ai/claude-agent-sdk"
+import { homedir } from "node:os"
+import { getDataRootDir } from "../shared/branding"
 import { CodexAppServerManager } from "./codex-app-server"
 
 const CLAUDE_STRUCTURED_TIMEOUT_MS = 5_000
@@ -24,6 +26,20 @@ interface QuickResponseAdapterArgs {
   runCodexStructured?: (args: Omit<StructuredQuickResponseArgs<unknown>, "parse">) => Promise<unknown | null>
 }
 
+export interface StructuredQuickResponseFailure {
+  provider: "claude" | "codex"
+  reason: string
+}
+
+export interface StructuredQuickResponseResult<T> {
+  value: T | null
+  failures: StructuredQuickResponseFailure[]
+}
+
+export function getQuickResponseWorkspace(env: Record<string, string | undefined> = process.env) {
+  return getDataRootDir(homedir(), env)
+}
+
 function parseJsonText(value: string): unknown | null {
   const trimmed = value.trim()
   if (!trimmed) return null
@@ -45,10 +61,35 @@ function parseJsonText(value: string): unknown | null {
   return null
 }
 
-async function runClaudeStructured(args: Omit<StructuredQuickResponseArgs<unknown>, "parse">): Promise<unknown | null> {
+function structuredOutputFromSdkMessage(message: unknown): unknown | null {
+  if (!message || typeof message !== "object") return null
+
+  const record = message as Record<string, unknown>
+  if (record.type === "result") {
+    return record.structured_output ?? null
+  }
+
+  const assistantMessage = record.message
+  if (!assistantMessage || typeof assistantMessage !== "object") return null
+  const content = (assistantMessage as { content?: unknown }).content
+  if (!Array.isArray(content)) return null
+
+  for (const item of content) {
+    if (!item || typeof item !== "object") continue
+    const toolUse = item as Record<string, unknown>
+    if (toolUse.type === "tool_use" && toolUse.name === "StructuredOutput") {
+      return toolUse.input ?? null
+    }
+  }
+
+  return null
+}
+
+export async function runClaudeStructured(args: Omit<StructuredQuickResponseArgs<unknown>, "parse">): Promise<unknown | null> {
   const q = query({
     prompt: args.prompt,
     options: {
+      cwd: args.cwd,
       model: "haiku",
       tools: [],
       systemPrompt: "",
@@ -66,8 +107,9 @@ async function runClaudeStructured(args: Omit<StructuredQuickResponseArgs<unknow
     const result = await Promise.race<unknown | null>([
       (async () => {
         for await (const message of q) {
-          if ("result" in message) {
-            return (message as Record<string, unknown>).structured_output ?? null
+          const structuredOutput = structuredOutputFromSdkMessage(message)
+          if (structuredOutput !== null) {
+            return structuredOutput
           }
         }
         return null
@@ -91,12 +133,13 @@ async function runClaudeStructured(args: Omit<StructuredQuickResponseArgs<unknow
   }
 }
 
-async function runCodexStructured(
+export async function runCodexStructured(
   codexManager: CodexAppServerManager,
   args: Omit<StructuredQuickResponseArgs<unknown>, "parse">
 ): Promise<unknown | null> {
   const response = await codexManager.generateStructured({
     cwd: args.cwd,
+    model: "gpt-5.4-mini",
     prompt: `${args.prompt}\n\nReturn JSON only that matches this schema:\n${JSON.stringify(args.schema, null, 2)}`,
   })
   if (typeof response !== "string") return null
@@ -115,17 +158,45 @@ export class QuickResponseAdapter {
       runCodexStructured(this.codexManager, structuredArgs))
   }
   async generateStructured<T>(args: StructuredQuickResponseArgs<T>): Promise<T | null> {
+    const result = await this.generateStructuredWithDiagnostics(args)
+    return result.value
+  }
+
+  async generateStructuredWithDiagnostics<T>(args: StructuredQuickResponseArgs<T>): Promise<StructuredQuickResponseResult<T>> {
     const request = {
-      cwd: args.cwd,
+      cwd: getQuickResponseWorkspace(),
       task: args.task,
       prompt: args.prompt,
       schema: args.schema,
     }
 
+    const failures: StructuredQuickResponseFailure[] = []
     const claudeResult = await this.tryProvider("claude", args.task, args.parse, () => this.runClaudeStructured(request))
-    if (claudeResult !== null) return claudeResult
+    if (claudeResult.value !== null) {
+      return {
+        value: claudeResult.value,
+        failures,
+      }
+    }
+    if (claudeResult.failure) {
+      failures.push(claudeResult.failure)
+    }
+
+    const codexResult = await this.tryProvider("codex", args.task, args.parse, () => this.runCodexStructured(request))
+    if (codexResult.value !== null) {
+      return {
+        value: codexResult.value,
+        failures,
+      }
+    }
+    if (codexResult.failure) {
+      failures.push(codexResult.failure)
+    }
 
-    return await this.tryProvider("codex", args.task, args.parse, () => this.runCodexStructured(request))
+    return {
+      value: null,
+      failures,
+    }
   }
 
   private async tryProvider<T>(
@@ -133,21 +204,43 @@ export class QuickResponseAdapter {
     task: string,
     parse: (value: unknown) => T | null,
     run: () => Promise<unknown | null>
-  ): Promise<T | null> {
+  ): Promise<{ value: T | null; failure: StructuredQuickResponseFailure | null }> {
     try {
       const result = await run()
       if (result === null) {
-        return null
+        return {
+          value: null,
+          failure: {
+            provider,
+            reason: `${provider} returned no result for ${task}`,
+          },
+        }
       }
-  
+
       const parsed = parse(result)
       if (parsed === null) {
-        return null
+        return {
+          value: null,
+          failure: {
+            provider,
+            reason: `${provider} returned invalid structured output for ${task}`,
+          },
+        }
+      }
+
+      return {
+        value: parsed,
+        failure: null,
       }
-  
-      return parsed
     } catch (error) {
-      return null
+      const message = error instanceof Error ? error.message : String(error)
+      return {
+        value: null,
+        failure: {
+          provider,
+          reason: `${provider} failed ${task}: ${message}`,
+        },
+      }
     }
   }
 }

package/src/server/read-models.test.ts

@@ -19,6 +19,7 @@ describe("read models", () => {
       title: "Chat",
       createdAt: 1,
       updatedAt: 1,
+      unread: true,
       provider: "codex",
       planMode: false,
       sessionToken: "thread-1",
@@ -27,6 +28,7 @@ describe("read models", () => {
 
     const sidebar = deriveSidebarData(state, new Map())
     expect(sidebar.projectGroups[0]?.chats[0]?.provider).toBe("codex")
+    expect(sidebar.projectGroups[0]?.chats[0]?.unread).toBe(true)
   })
 
   test("includes available providers in chat snapshots", () => {
@@ -45,6 +47,7 @@ describe("read models", () => {
       title: "Chat",
       createdAt: 1,
       updatedAt: 1,
+      unread: false,
       provider: "claude",
       planMode: true,
       sessionToken: "session-1",
@@ -77,6 +80,7 @@ describe("read models", () => {
       title: "Chat",
       createdAt: 1,
       updatedAt: 75,
+      unread: false,
       provider: "codex",
       planMode: false,
       sessionToken: null,

package/src/server/read-models.ts

@@ -35,6 +35,7 @@ export function deriveSidebarData(
         chatId: chat.id,
         title: chat.title,
         status: deriveStatus(chat, activeStatuses.get(chat.id)),
+        unread: chat.unread,
         localPath: project.localPath,
         provider: chat.provider,
         lastMessageAt: chat.lastMessageAt,

package/src/server/title-generation.live.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test"
+import { CodexAppServerManager } from "./codex-app-server"
+import { fallbackTitleFromMessage, generateTitleForChatDetailed } from "./generate-title"
+import { QuickResponseAdapter, runClaudeStructured, runCodexStructured } from "./quick-response"
+
+const shouldRunLiveTests = process.env.KANNA_RUN_LIVE_TITLE_TESTS === "1"
+const LIVE_MESSAGE = "Please help me debug a websocket reconnection issue in a Bun server app"
+
+if (shouldRunLiveTests) {
+  describe("live title generation", () => {
+    test("generates a title with Claude", async () => {
+      const adapter = new QuickResponseAdapter({
+        runClaudeStructured,
+        runCodexStructured: async () => {
+          throw new Error("Codex fallback should not be used in the Claude live title test")
+        },
+      })
+
+      const result = await generateTitleForChatDetailed(LIVE_MESSAGE, process.cwd(), adapter)
+
+      expect(result.usedFallback).toBe(false)
+      expect(result.failureMessage).toBeNull()
+      expect(typeof result.title).toBe("string")
+      expect(result.title).not.toBe(fallbackTitleFromMessage(LIVE_MESSAGE))
+    }, 15_000)
+
+    test("generates a title with Codex", async () => {
+      const codexManager = new CodexAppServerManager()
+      const adapter = new QuickResponseAdapter({
+        runClaudeStructured: async () => {
+          throw new Error("Claude should not be used in the Codex live title test")
+        },
+        runCodexStructured: async (args) => runCodexStructured(codexManager, args),
+      })
+
+      const result = await generateTitleForChatDetailed(LIVE_MESSAGE, process.cwd(), adapter)
+
+      expect(result.usedFallback).toBe(false)
+      expect(result.failureMessage).toBeNull()
+      expect(typeof result.title).toBe("string")
+      expect(result.title).not.toBe(fallbackTitleFromMessage(LIVE_MESSAGE))
+    }, 15_000)
+  })
+}

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

@@ -176,6 +176,187 @@ describe("ws-router", () => {
     })
   })
 
+  test("marks chats read and rebroadcasts sidebar snapshots", async () => {
+    const state = createEmptyState()
+    state.projectsById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Project",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+    state.projectIdsByPath.set("/tmp/project", "project-1")
+    state.chatsById.set("chat-1", {
+      id: "chat-1",
+      projectId: "project-1",
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      unread: true,
+      provider: null,
+      planMode: false,
+      sessionToken: null,
+      lastTurnOutcome: null,
+    })
+
+    const store = {
+      state,
+      async setChatReadState(chatId: string, unread: boolean) {
+        const chat = state.chatsById.get(chatId)
+        if (!chat) throw new Error("Chat not found")
+        chat.unread = unread
+      },
+    }
+
+    const router = createWsRouter({
+      store: store 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: null,
+    })
+    const wsA = new FakeWebSocket()
+    const wsB = new FakeWebSocket()
+
+    router.handleOpen(wsA as never)
+    router.handleOpen(wsB as never)
+
+    router.handleMessage(
+      wsA as never,
+      JSON.stringify({
+        v: 1,
+        type: "subscribe",
+        id: "sidebar-a",
+        topic: { type: "sidebar" },
+      })
+    )
+    router.handleMessage(
+      wsB as never,
+      JSON.stringify({
+        v: 1,
+        type: "subscribe",
+        id: "sidebar-b",
+        topic: { type: "sidebar" },
+      })
+    )
+
+    router.handleMessage(
+      wsA as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "mark-read-1",
+        command: { type: "chat.markRead", chatId: "chat-1" },
+      })
+    )
+
+    await Promise.resolve()
+
+    expect(wsA.sent.at(-2)).toEqual({
+      v: PROTOCOL_VERSION,
+      type: "ack",
+      id: "mark-read-1",
+    })
+    expect(wsA.sent.at(-1)).toEqual({
+      v: PROTOCOL_VERSION,
+      type: "snapshot",
+      id: "sidebar-a",
+      snapshot: {
+        type: "sidebar",
+        data: {
+          projectGroups: [{
+            groupKey: "project-1",
+            localPath: "/tmp/project",
+            chats: [{
+              _id: "chat-1",
+              _creationTime: 1,
+              chatId: "chat-1",
+              title: "Chat",
+              status: "idle",
+              unread: false,
+              localPath: "/tmp/project",
+              provider: null,
+              lastMessageAt: undefined,
+              hasAutomation: false,
+            }],
+          }],
+        },
+      },
+    })
+    expect(wsB.sent.at(-1)).toEqual({
+      v: PROTOCOL_VERSION,
+      type: "snapshot",
+      id: "sidebar-b",
+      snapshot: {
+        type: "sidebar",
+        data: {
+          projectGroups: [{
+            groupKey: "project-1",
+            localPath: "/tmp/project",
+            chats: [{
+              _id: "chat-1",
+              _creationTime: 1,
+              chatId: "chat-1",
+              title: "Chat",
+              status: "idle",
+              unread: false,
+              localPath: "/tmp/project",
+              provider: null,
+              lastMessageAt: undefined,
+              hasAutomation: false,
+            }],
+          }],
+        },
+      },
+    })
+  })
+
+  test("broadcasts background title-generation errors to connected clients", () => {
+    let reportBackgroundError: ((message: string) => void) | null | undefined
+    const router = createWsRouter({
+      store: { state: createEmptyState() } as never,
+      agent: {
+        getActiveStatuses: () => new Map(),
+        setBackgroundErrorReporter: (reporter: ((message: string) => void) | null) => {
+          reportBackgroundError = reporter
+        },
+      } 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)
+
+    reportBackgroundError?.("[title-generation] chat chat-1 failed")
+
+    expect(ws.sent).toEqual([
+      {
+        v: PROTOCOL_VERSION,
+        type: "error",
+        message: "[title-generation] chat chat-1 failed",
+      },
+    ])
+  })
+
   test("subscribes to keybindings snapshots and writes keybindings through the router", async () => {
     const initialSnapshot: KeybindingsSnapshot = DEFAULT_KEYBINDINGS_SNAPSHOT
     const keybindings = {

package/src/server/ws-router.ts

@@ -138,6 +138,16 @@ export function createWsRouter({
     }
   }
 
+  function broadcastError(message: string) {
+    for (const ws of sockets) {
+      send(ws, {
+        v: PROTOCOL_VERSION,
+        type: "error",
+        message,
+      })
+    }
+  }
+
   function pushTerminalSnapshot(terminalId: string) {
     for (const ws of sockets) {
       for (const [id, topic] of ws.data.subscriptions.entries()) {
@@ -183,6 +193,8 @@ export function createWsRouter({
     }
   }) ?? (() => {})
 
+  agent.setBackgroundErrorReporter?.(broadcastError)
+
   async function handleCommand(ws: ServerWebSocket<ClientState>, message: Extract<ClientEnvelope, { type: "command" }>) {
     const { command, id } = message
     try {
@@ -275,6 +287,11 @@ export function createWsRouter({
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
           break
         }
+        case "chat.markRead": {
+          await store.setChatReadState(command.chatId, false)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          break
+        }
         case "chat.send": {
           const result = await agent.send(command)
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
@@ -374,6 +391,7 @@ export function createWsRouter({
       void handleCommand(ws, parsed)
     },
     dispose() {
+      agent.setBackgroundErrorReporter?.(null)
       disposeTerminalEvents()
       disposeKeybindingEvents()
       disposeUpdateEvents()

package/src/shared/protocol.ts

@@ -62,6 +62,7 @@ export type ClientCommand =
   | { type: "chat.create"; projectId: string }
   | { type: "chat.rename"; chatId: string; title: string }
   | { type: "chat.delete"; chatId: string }
+  | { type: "chat.markRead"; chatId: string }
   | {
       type: "chat.send"
       chatId?: string

package/src/shared/types.ts

@@ -192,6 +192,7 @@ export interface SidebarChatRow {
   chatId: string
   title: string
   status: KannaStatus
+  unread: boolean
   localPath: string
   provider: AgentProvider | null
   lastMessageAt?: number