kanna-code 0.17.0 → 0.19.0

package/src/server/quick-response.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
-import { generateTitleForChat } from "./generate-title"
-import { QuickResponseAdapter } from "./quick-response"
+import { fallbackTitleFromMessage, generateTitleForChat, generateTitleForChatDetailed } from "./generate-title"
+import { getQuickResponseWorkspace, QuickResponseAdapter } from "./quick-response"
 
 describe("QuickResponseAdapter", () => {
   test("returns the Claude structured result when it validates", async () => {
@@ -85,6 +85,83 @@ describe("QuickResponseAdapter", () => {
 
     expect(result).toBe("Codex title")
   })
+
+  test("uses the Kanna app data root as the quick-response workspace", async () => {
+    const previousProfile = process.env.KANNA_RUNTIME_PROFILE
+    process.env.KANNA_RUNTIME_PROFILE = "dev"
+
+    try {
+      let claudeCwd = ""
+      const adapter = new QuickResponseAdapter({
+        runClaudeStructured: async (args) => {
+          claudeCwd = args.cwd
+          return { title: "Claude title" }
+        },
+      })
+
+      await adapter.generateStructured({
+        cwd: "/tmp/project",
+        task: "title generation",
+        prompt: "Generate a title",
+        schema: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+          },
+          required: ["title"],
+          additionalProperties: false,
+        },
+        parse: (value) => {
+          const output = value && typeof value === "object" ? value as { title?: unknown } : {}
+          return typeof output.title === "string" ? output.title : null
+        },
+      })
+
+      expect(claudeCwd).toBe(getQuickResponseWorkspace(process.env))
+      expect(claudeCwd.endsWith("/.kanna-dev")).toBe(true)
+    } finally {
+      if (previousProfile === undefined) {
+        delete process.env.KANNA_RUNTIME_PROFILE
+      } else {
+        process.env.KANNA_RUNTIME_PROFILE = previousProfile
+      }
+    }
+  })
+
+  test("uses gpt-5.4-mini for Codex title generation fallback", async () => {
+    const requests: Array<{ cwd: string; prompt: string; model?: string }> = []
+    const adapter = new QuickResponseAdapter({
+      codexManager: {
+        async generateStructured(args: { cwd: string; prompt: string; model?: string }) {
+          requests.push(args)
+          return "{\"title\":\"Codex title\"}"
+        },
+      } as never,
+      runClaudeStructured: async () => null,
+    })
+
+    const result = await adapter.generateStructured({
+      cwd: "/tmp/project",
+      task: "title generation",
+      prompt: "Generate a title",
+      schema: {
+        type: "object",
+        properties: {
+          title: { type: "string" },
+        },
+        required: ["title"],
+        additionalProperties: false,
+      },
+      parse: (value) => {
+        const output = value && typeof value === "object" ? value as { title?: unknown } : {}
+        return typeof output.title === "string" ? output.title : null
+      },
+    })
+
+    expect(result).toBe("Codex title")
+    expect(requests).toHaveLength(1)
+    expect(requests[0]?.model).toBe("gpt-5.4-mini")
+  })
 })
 
 describe("generateTitleForChat", () => {
@@ -110,6 +187,52 @@ describe("generateTitleForChat", () => {
       })
     )
 
-    expect(title).toBeNull()
+    expect(title).toBe("hello")
+  })
+
+  test("falls back to the first 35 characters of the message with ellipsis", async () => {
+    const title = await generateTitleForChat(
+      "This message is definitely longer than thirty five characters",
+      "/tmp/project",
+      new QuickResponseAdapter({
+        runClaudeStructured: async () => {
+          throw new Error("Not authenticated")
+        },
+        runCodexStructured: async () => null,
+      })
+    )
+
+    expect(title).toBe("This message is definitely longer t...")
+  })
+
+  test("returns fallback metadata when providers fail", async () => {
+    const result = await generateTitleForChatDetailed(
+      "hello there",
+      "/tmp/project",
+      new QuickResponseAdapter({
+        runClaudeStructured: async () => {
+          throw new Error("Not authenticated")
+        },
+        runCodexStructured: async () => {
+          throw new Error("Codex unavailable")
+        },
+      })
+    )
+
+    expect(result).toEqual({
+      title: "hello there",
+      usedFallback: true,
+      failureMessage: "claude failed conversation title generation: Not authenticated; codex failed conversation title generation: Codex unavailable",
+    })
+  })
+})
+
+describe("fallbackTitleFromMessage", () => {
+  test("normalizes whitespace", () => {
+    expect(fallbackTitleFromMessage("  hello\n   world  ")).toBe("hello world")
+  })
+
+  test("returns null for blank input", () => {
+    expect(fallbackTitleFromMessage("   \n  ")).toBeNull()
   })
 })

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/server.ts

@@ -1,5 +1,7 @@
 import path from "node:path"
+import { stat } from "node:fs/promises"
 import { APP_NAME, getRuntimeProfile } from "../shared/branding"
+import type { ChatAttachment } from "../shared/types"
 import { EventStore } from "./event-store"
 import { AgentCoordinator } from "./agent"
 import { discoverProjects, type DiscoveredProject } from "./discovery"
@@ -9,6 +11,45 @@ import { TerminalManager } from "./terminal-manager"
 import { UpdateManager } from "./update-manager"
 import type { UpdateInstallAttemptResult } from "./cli-runtime"
 import { createWsRouter, type ClientState } from "./ws-router"
+import { deleteProjectUpload, inferAttachmentContentType, persistProjectUpload } from "./uploads"
+import { getProjectUploadDir } from "./paths"
+
+const MAX_UPLOAD_FILES = 10
+const MAX_UPLOAD_SIZE_BYTES = 25 * 1024 * 1024
+
+export async function persistUploadedFiles(args: {
+  projectId: string
+  localPath: string
+  files: File[]
+  persistUpload?: typeof persistProjectUpload
+}): Promise<ChatAttachment[]> {
+  const persistUpload = args.persistUpload ?? persistProjectUpload
+  const attachments: ChatAttachment[] = []
+
+  try {
+    for (const file of args.files) {
+      const bytes = new Uint8Array(await file.arrayBuffer())
+      const attachment = await persistUpload({
+        projectId: args.projectId,
+        localPath: args.localPath,
+        fileName: file.name,
+        bytes,
+        fallbackMimeType: file.type || undefined,
+      })
+      attachments.push(attachment)
+    }
+  } catch (error) {
+    await Promise.allSettled(
+      attachments.map((attachment) => deleteProjectUpload({
+        localPath: args.localPath,
+        storedName: path.basename(attachment.absolutePath),
+      }))
+    )
+    throw error
+  }
+
+  return attachments
+}
 
 export interface StartKannaServerOptions {
   port?: number
@@ -79,7 +120,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
       server = Bun.serve<ClientState>({
         port: actualPort,
         hostname,
-        fetch(req, serverInstance) {
+        async fetch(req, serverInstance) {
           const url = new URL(req.url)
 
           if (url.pathname === "/ws") {
@@ -95,6 +136,21 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
             return Response.json({ ok: true, port: actualPort })
           }
 
+          const uploadResponse = await handleProjectUpload(req, url, store)
+          if (uploadResponse) {
+            return uploadResponse
+          }
+
+          const deleteUploadResponse = await handleProjectUploadDelete(req, url, store)
+          if (deleteUploadResponse) {
+            return deleteUploadResponse
+          }
+
+          const attachmentContentResponse = await handleAttachmentContent(req, url, store)
+          if (attachmentContentResponse) {
+            return attachmentContentResponse
+          }
+
           return serveStatic(distDir, url.pathname)
         },
         websocket: {
@@ -140,6 +196,127 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   }
 }
 
+async function handleProjectUpload(req: Request, url: URL, store: EventStore) {
+  if (req.method !== "POST") {
+    return null
+  }
+
+  const match = url.pathname.match(/^\/api\/projects\/([^/]+)\/uploads$/)
+  if (!match) {
+    return null
+  }
+
+  const project = store.getProject(match[1])
+  if (!project) {
+    return Response.json({ error: "Project not found" }, { status: 404 })
+  }
+
+  const formData = await req.formData()
+  const files = formData
+    .getAll("files")
+    .filter((value): value is File => value instanceof File)
+
+  if (files.length === 0) {
+    return Response.json({ error: "No files uploaded" }, { status: 400 })
+  }
+
+  if (files.length > MAX_UPLOAD_FILES) {
+    return Response.json({ error: `You can upload up to ${MAX_UPLOAD_FILES} files at a time.` }, { status: 400 })
+  }
+
+  for (const file of files) {
+    if (file.size > MAX_UPLOAD_SIZE_BYTES) {
+      return Response.json(
+        { error: `File "${file.name}" exceeds the ${Math.floor(MAX_UPLOAD_SIZE_BYTES / (1024 * 1024))} MB limit.` },
+        { status: 413 }
+      )
+    }
+  }
+
+  try {
+    const attachments = await persistUploadedFiles({
+      projectId: project.id,
+      localPath: project.localPath,
+      files,
+    })
+    return Response.json({ attachments })
+  } catch (error) {
+    console.error("[uploads] Upload failed:", error)
+    return Response.json({ error: "Upload failed" }, { status: 500 })
+  }
+}
+
+async function handleAttachmentContent(req: Request, url: URL, store: EventStore) {
+  const match = url.pathname.match(/^\/api\/projects\/([^/]+)\/uploads\/([^/]+)\/content$/)
+  if (!match) {
+    return null
+  }
+
+  if (req.method !== "GET") {
+    return new Response(null, {
+      status: 405,
+      headers: {
+        Allow: "GET",
+      },
+    })
+  }
+
+  const project = store.getProject(match[1])
+  if (!project) {
+    return Response.json({ error: "Project not found" }, { status: 404 })
+  }
+
+  const storedName = decodeURIComponent(match[2])
+  if (!storedName || storedName.includes("/") || storedName.includes("\\") || storedName === "." || storedName === "..") {
+    return Response.json({ error: "Invalid attachment path" }, { status: 400 })
+  }
+
+  const filePath = path.join(getProjectUploadDir(project.localPath), storedName)
+  const file = Bun.file(filePath)
+  try {
+    const info = await stat(filePath)
+    if (!info.isFile()) {
+      return Response.json({ error: "Attachment not found" }, { status: 404 })
+    }
+  } catch {
+    return Response.json({ error: "Attachment not found" }, { status: 404 })
+  }
+
+  return new Response(file, {
+    headers: {
+      "Content-Type": inferAttachmentContentType(storedName, file.type),
+    },
+  })
+}
+
+async function handleProjectUploadDelete(req: Request, url: URL, store: EventStore) {
+  if (req.method !== "DELETE") {
+    return null
+  }
+
+  const match = url.pathname.match(/^\/api\/projects\/([^/]+)\/uploads\/([^/]+)$/)
+  if (!match) {
+    return null
+  }
+
+  const project = store.getProject(match[1])
+  if (!project) {
+    return Response.json({ error: "Project not found" }, { status: 404 })
+  }
+
+  const storedName = decodeURIComponent(match[2])
+  if (!storedName || storedName.includes("/") || storedName.includes("\\") || storedName === "." || storedName === "..") {
+    return Response.json({ error: "Invalid attachment path" }, { status: 400 })
+  }
+
+  const deleted = await deleteProjectUpload({
+    localPath: project.localPath,
+    storedName,
+  })
+
+  return Response.json({ ok: deleted })
+}
+
 async function serveStatic(distDir: string, pathname: string) {
   const requestedPath = pathname === "/" ? "/index.html" : pathname
   const filePath = path.join(distDir, requestedPath)

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