kanna-code 0.17.0 → 0.19.0

package/src/server/uploads.test.ts

@@ -0,0 +1,282 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtemp, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { deleteProjectUpload, inferAttachmentContentType, persistProjectUpload } from "./uploads"
+import { getProjectUploadDir } from "./paths"
+import { persistUploadedFiles, startKannaServer } from "./server"
+
+const PNG_BASE64 =
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+yF9sAAAAASUVORK5CYII="
+
+const tempDirs: string[] = []
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })))
+})
+
+describe("uploads", () => {
+  test("stores uploads in .kanna/uploads and keeps duplicate filenames", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-upload-test-"))
+    tempDirs.push(projectDir)
+
+    const first = await persistProjectUpload({
+      projectId: "project-1",
+      localPath: projectDir,
+      fileName: "notes.txt",
+      bytes: new TextEncoder().encode("hello"),
+      fallbackMimeType: "text/plain",
+    })
+    const second = await persistProjectUpload({
+      projectId: "project-1",
+      localPath: projectDir,
+      fileName: "notes.txt",
+      bytes: new TextEncoder().encode("world"),
+      fallbackMimeType: "text/plain",
+    })
+
+    expect(first.absolutePath).toBe(path.join(projectDir, ".kanna/uploads/notes.txt"))
+    expect(first.relativePath).toBe("./.kanna/uploads/notes.txt")
+    expect(first.contentUrl).toBe("/api/projects/project-1/uploads/notes.txt/content")
+    expect(second.absolutePath).toBe(path.join(projectDir, ".kanna/uploads/notes-1.txt"))
+    expect(second.relativePath).toBe("./.kanna/uploads/notes-1.txt")
+    expect(second.contentUrl).toBe("/api/projects/project-1/uploads/notes-1.txt/content")
+    expect(await Bun.file(path.join(projectDir, ".kanna/uploads/notes.txt")).text()).toBe("hello")
+    expect(await Bun.file(path.join(projectDir, ".kanna/uploads/notes-1.txt")).text()).toBe("world")
+  })
+
+  test("stores concurrent same-name uploads without overwriting existing content", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-upload-concurrent-"))
+    tempDirs.push(projectDir)
+
+    const attachments = await Promise.all([
+      persistProjectUpload({
+        projectId: "project-1",
+        localPath: projectDir,
+        fileName: "notes.txt",
+        bytes: new TextEncoder().encode("first"),
+        fallbackMimeType: "text/plain",
+      }),
+      persistProjectUpload({
+        projectId: "project-1",
+        localPath: projectDir,
+        fileName: "notes.txt",
+        bytes: new TextEncoder().encode("second"),
+        fallbackMimeType: "text/plain",
+      }),
+      persistProjectUpload({
+        projectId: "project-1",
+        localPath: projectDir,
+        fileName: "notes.txt",
+        bytes: new TextEncoder().encode("third"),
+        fallbackMimeType: "text/plain",
+      }),
+    ])
+
+    const storedNames = attachments.map((attachment) => path.basename(attachment.absolutePath)).sort()
+    expect(storedNames).toEqual(["notes-1.txt", "notes-2.txt", "notes.txt"])
+
+    const contents = await Promise.all(attachments.map((attachment) => Bun.file(attachment.absolutePath).text()))
+    expect(new Set(contents)).toEqual(new Set(["first", "second", "third"]))
+  })
+
+  test("detects image uploads and returns absolute plus project-relative paths", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-upload-image-"))
+    tempDirs.push(projectDir)
+
+    const attachment = await persistProjectUpload({
+      projectId: "project-2",
+      localPath: projectDir,
+      fileName: "pixel.png",
+      bytes: Buffer.from(PNG_BASE64, "base64"),
+    })
+
+    expect(attachment.kind).toBe("image")
+    expect(attachment.mimeType).toBe("image/png")
+    expect(getProjectUploadDir(projectDir)).toBe(path.join(projectDir, ".kanna", "uploads"))
+    expect(attachment.absolutePath).toBe(path.join(projectDir, ".kanna/uploads/pixel.png"))
+    expect(attachment.relativePath).toBe("./.kanna/uploads/pixel.png")
+    expect(attachment.contentUrl).toBe("/api/projects/project-2/uploads/pixel.png/content")
+  })
+
+  test("serves uploaded attachment content through the project content URL", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-"))
+    tempDirs.push(projectDir)
+
+    const server = await startKannaServer({ port: 4310, strictPort: true })
+
+    try {
+      const project = await server.store.openProject(projectDir, "Project")
+      const attachment = await persistProjectUpload({
+        projectId: project.id,
+        localPath: projectDir,
+        fileName: "hello.txt",
+        bytes: new TextEncoder().encode("hello from upload"),
+        fallbackMimeType: "text/plain",
+      })
+
+      const response = await fetch(`http://localhost:${server.port}${attachment.contentUrl}`)
+      expect(response.status).toBe(200)
+      expect(response.headers.get("content-type")).toBe("text/plain; charset=utf-8")
+      expect(await response.text()).toBe("hello from upload")
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("serves TypeScript uploads as text content", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-typescript-"))
+    tempDirs.push(projectDir)
+
+    const server = await startKannaServer({ port: 4314, strictPort: true })
+
+    try {
+      const project = await server.store.openProject(projectDir, "Project")
+      const attachment = await persistProjectUpload({
+        projectId: project.id,
+        localPath: projectDir,
+        fileName: "main.ts",
+        bytes: new TextEncoder().encode("export const value = 1\n"),
+        fallbackMimeType: "video/mp2t",
+      })
+
+      const response = await fetch(`http://localhost:${server.port}${attachment.contentUrl}`)
+      expect(response.status).toBe(200)
+      expect(response.headers.get("content-type")).toBe("text/plain; charset=utf-8")
+      expect(await response.text()).toContain("export const value = 1")
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("rejects non-GET requests for attachment content", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-content-method-"))
+    tempDirs.push(projectDir)
+
+    const server = await startKannaServer({ port: 4312, strictPort: true })
+
+    try {
+      const project = await server.store.openProject(projectDir, "Project")
+      const attachment = await persistProjectUpload({
+        projectId: project.id,
+        localPath: projectDir,
+        fileName: "hello.txt",
+        bytes: new TextEncoder().encode("hello from upload"),
+        fallbackMimeType: "text/plain",
+      })
+
+      const response = await fetch(`http://localhost:${server.port}${attachment.contentUrl}`, { method: "POST" })
+      expect(response.status).toBe(405)
+      expect(response.headers.get("allow")).toBe("GET")
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("rejects oversized uploads before reading them into memory", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-oversize-"))
+    tempDirs.push(projectDir)
+
+    const server = await startKannaServer({ port: 4313, strictPort: true })
+
+    try {
+      const project = await server.store.openProject(projectDir, "Project")
+      const formData = new FormData()
+      formData.append("files", new File([new Uint8Array(25 * 1024 * 1024 + 1)], "big.bin", { type: "application/octet-stream" }))
+
+      const response = await fetch(`http://localhost:${server.port}/api/projects/${project.id}/uploads`, {
+        method: "POST",
+        body: formData,
+      })
+
+      expect(response.status).toBe(413)
+      expect(await response.json()).toEqual({
+        error: "File \"big.bin\" exceeds the 25 MB limit.",
+      })
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("cleans up already-persisted files when a later file in the batch fails", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-cleanup-"))
+    tempDirs.push(projectDir)
+
+    const files = [
+      new File(["first"], "first.txt", { type: "text/plain" }),
+      new File(["second"], "second.txt", { type: "text/plain" }),
+    ]
+
+    await expect(
+      persistUploadedFiles({
+        projectId: "project-4",
+        localPath: projectDir,
+        files,
+        persistUpload: async (args) => {
+          if (args.fileName === "second.txt") {
+            throw new Error("disk full")
+          }
+
+          return persistProjectUpload(args)
+        },
+      })
+    ).rejects.toThrow("disk full")
+
+    expect(await Bun.file(path.join(projectDir, ".kanna/uploads/first.txt")).exists()).toBe(false)
+    expect(await Bun.file(path.join(projectDir, ".kanna/uploads/second.txt")).exists()).toBe(false)
+  })
+
+  test("deletes uploaded attachments from the project uploads directory", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-upload-delete-"))
+    tempDirs.push(projectDir)
+
+    const attachment = await persistProjectUpload({
+      projectId: "project-3",
+      localPath: projectDir,
+      fileName: "delete-me.txt",
+      bytes: new TextEncoder().encode("bye"),
+      fallbackMimeType: "text/plain",
+    })
+
+    const deleted = await deleteProjectUpload({
+      localPath: projectDir,
+      storedName: "delete-me.txt",
+    })
+
+    expect(deleted).toBe(true)
+    expect(await Bun.file(attachment.absolutePath).exists()).toBe(false)
+  })
+
+  test("deletes uploaded attachment content through the project delete URL", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-delete-"))
+    tempDirs.push(projectDir)
+
+    const server = await startKannaServer({ port: 4311, strictPort: true })
+
+    try {
+      const project = await server.store.openProject(projectDir, "Project")
+      const attachment = await persistProjectUpload({
+        projectId: project.id,
+        localPath: projectDir,
+        fileName: "bye.txt",
+        bytes: new TextEncoder().encode("delete over http"),
+        fallbackMimeType: "text/plain",
+      })
+
+      const deleteUrl = `http://localhost:${server.port}${attachment.contentUrl.replace(/\/content$/, "")}`
+      const response = await fetch(deleteUrl, { method: "DELETE" })
+      expect(response.status).toBe(200)
+      expect(await response.json()).toEqual({ ok: true })
+      expect(await Bun.file(attachment.absolutePath).exists()).toBe(false)
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("infers text-friendly content types for previewable source files", () => {
+    expect(inferAttachmentContentType("notes.txt")).toBe("text/plain; charset=utf-8")
+    expect(inferAttachmentContentType("README.md")).toBe("text/markdown; charset=utf-8")
+    expect(inferAttachmentContentType("main.ts", "video/mp2t")).toBe("text/plain; charset=utf-8")
+    expect(inferAttachmentContentType("archive.zip", "application/zip")).toBe("application/zip")
+  })
+})

package/src/server/uploads.ts

@@ -0,0 +1,127 @@
+import { randomUUID } from "node:crypto"
+import { mkdir, open, rm } from "node:fs/promises"
+import path from "node:path"
+import { fileTypeFromBuffer } from "file-type"
+import type { ChatAttachment } from "../shared/types"
+import { getProjectUploadDir } from "./paths"
+
+const DEFAULT_BINARY_MIME_TYPE = "application/octet-stream"
+const IMAGE_MIME_PREFIX = "image/"
+const TEXT_PLAIN_CONTENT_TYPE = "text/plain; charset=utf-8"
+
+const TEXT_CONTENT_TYPE_BY_EXTENSION = new Map<string, string>([
+  [".csv", "text/csv; charset=utf-8"],
+  [".json", "application/json; charset=utf-8"],
+  [".jsonc", TEXT_PLAIN_CONTENT_TYPE],
+  [".md", "text/markdown; charset=utf-8"],
+  [".tsv", "text/tab-separated-values; charset=utf-8"],
+])
+
+const TEXT_LIKE_EXTENSIONS = new Set([
+  ".c", ".cc", ".cfg", ".conf", ".cpp", ".cs", ".css", ".env", ".go", ".graphql", ".h", ".hpp", ".html",
+  ".ini", ".java", ".js", ".jsx", ".kt", ".lua", ".mjs", ".php", ".pl", ".properties", ".py", ".rb", ".rs",
+  ".scss", ".sh", ".sql", ".swift", ".toml", ".ts", ".tsx", ".txt", ".vue", ".xml", ".yaml", ".yml", ".zsh",
+])
+
+function sanitizeFileName(fileName: string) {
+  const baseName = path.basename(fileName).trim()
+  const cleaned = baseName.replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "")
+  return cleaned || "upload"
+}
+
+function getUploadCandidateNames(originalName: string) {
+  const sanitizedName = sanitizeFileName(originalName)
+  const parsed = path.parse(sanitizedName)
+  const extension = parsed.ext
+  const name = parsed.name || "upload"
+
+  return {
+    first: sanitizedName,
+    withCounter(counter: number) {
+      return `${name}-${counter}${extension}`
+    },
+  }
+}
+
+export async function persistProjectUpload(args: {
+  projectId: string
+  localPath: string
+  fileName: string
+  bytes: Uint8Array
+  fallbackMimeType?: string
+}): Promise<ChatAttachment> {
+  const uploadDir = getProjectUploadDir(args.localPath)
+  await mkdir(uploadDir, { recursive: true })
+
+  const detectedType = await fileTypeFromBuffer(args.bytes)
+  const mimeType = detectedType?.mime ?? args.fallbackMimeType ?? DEFAULT_BINARY_MIME_TYPE
+  const candidates = getUploadCandidateNames(args.fileName)
+
+  let storedName = candidates.first
+  let absolutePath = path.join(uploadDir, storedName)
+  let counter = 1
+
+  while (true) {
+    try {
+      const handle = await open(absolutePath, "wx")
+      try {
+        await handle.writeFile(args.bytes)
+      } finally {
+        await handle.close()
+      }
+      break
+    } catch (error) {
+      const code = error instanceof Error && "code" in error ? (error as NodeJS.ErrnoException).code : undefined
+      if (code !== "EEXIST") {
+        throw error
+      }
+
+      storedName = candidates.withCounter(counter)
+      absolutePath = path.join(uploadDir, storedName)
+      counter += 1
+    }
+  }
+
+  return {
+    id: randomUUID(),
+    kind: mimeType.startsWith(IMAGE_MIME_PREFIX) ? "image" : "file",
+    displayName: args.fileName,
+    absolutePath,
+    relativePath: `./.kanna/uploads/${storedName}`,
+    contentUrl: `/api/projects/${args.projectId}/uploads/${encodeURIComponent(storedName)}/content`,
+    mimeType,
+    size: args.bytes.byteLength,
+  }
+}
+
+export function inferAttachmentContentType(fileName: string, fallbackType?: string): string {
+  const extension = path.extname(fileName).toLowerCase()
+  const mappedType = TEXT_CONTENT_TYPE_BY_EXTENSION.get(extension)
+  if (mappedType) {
+    return mappedType
+  }
+
+  if (TEXT_LIKE_EXTENSIONS.has(extension)) {
+    return TEXT_PLAIN_CONTENT_TYPE
+  }
+
+  return fallbackType || DEFAULT_BINARY_MIME_TYPE
+}
+
+export async function deleteProjectUpload(args: {
+  localPath: string
+  storedName: string
+}): Promise<boolean> {
+  const storedName = args.storedName
+  if (!storedName || storedName.includes("/") || storedName.includes("\\") || storedName === "." || storedName === "..") {
+    return false
+  }
+
+  const absolutePath = path.join(getProjectUploadDir(args.localPath), storedName)
+  try {
+    await rm(absolutePath, { force: true })
+    return true
+  } catch {
+    return false
+  }
+}

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

@@ -1,5 +1,6 @@
 import type {
   AgentProvider,
+  ChatAttachment,
   ChatSnapshot,
   KeybindingsSnapshot,
   LocalProjectsSnapshot,
@@ -61,12 +62,14 @@ 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
       projectId?: string
       provider?: AgentProvider
       content: string
+      attachments?: ChatAttachment[]
       model?: string
       modelOptions?: ModelOptions
       effort?: string