kanna-code 0.20.0 → 0.21.0

package/src/server/server.ts

@@ -4,6 +4,7 @@ import { APP_NAME, getRuntimeProfile } from "../shared/branding"
 import type { ChatAttachment } from "../shared/types"
 import { EventStore } from "./event-store"
 import { AgentCoordinator } from "./agent"
+import { DiffStore } from "./diff-store"
 import { discoverProjects, type DiscoveredProject } from "./discovery"
 import { KeybindingsManager } from "./keybindings"
 import { getMachineDisplayName } from "./machine-name"
@@ -11,7 +12,7 @@ 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 { deleteProjectUpload, inferAttachmentContentType, inferProjectFileContentType, persistProjectUpload } from "./uploads"
 import { getProjectUploadDir } from "./paths"
 
 const MAX_UPLOAD_FILES = 10
@@ -68,8 +69,10 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   const hostname = options.host ?? "127.0.0.1"
   const strictPort = options.strictPort ?? false
   const store = new EventStore()
+  const diffStore = new DiffStore(store.dataDir)
   const machineDisplayName = getMachineDisplayName()
   await store.initialize()
+  await diffStore.initialize()
   await store.migrateLegacyTranscripts(options.onMigrationProgress)
   let discoveredProjects: DiscoveredProject[] = []
 
@@ -101,6 +104,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   })
   router = createWsRouter({
     store,
+    diffStore,
     agent,
     terminals,
     keybindings,
@@ -127,6 +131,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
             const upgraded = serverInstance.upgrade(req, {
               data: {
                 subscriptions: new Map(),
+                snapshotSignatures: new Map(),
               },
             })
             return upgraded ? undefined : new Response("WebSocket upgrade failed", { status: 400 })
@@ -151,6 +156,11 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
             return attachmentContentResponse
           }
 
+          const projectFileContentResponse = await handleProjectFileContent(req, url, store)
+          if (projectFileContentResponse) {
+            return projectFileContentResponse
+          }
+
           return serveStatic(distDir, url.pathname)
         },
         websocket: {
@@ -191,6 +201,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   return {
     port: actualPort,
     store,
+    diffStore,
     updateManager,
     stop: shutdown,
   }
@@ -289,6 +300,54 @@ async function handleAttachmentContent(req: Request, url: URL, store: EventStore
   })
 }
 
+async function handleProjectFileContent(req: Request, url: URL, store: EventStore) {
+  const match = url.pathname.match(/^\/api\/projects\/([^/]+)\/files\/([^/]+)\/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 relativePath = path.posix.normalize(decodeURIComponent(match[2]).replaceAll("\\", "/"))
+  if (!relativePath || relativePath === "." || relativePath.startsWith("../") || relativePath.includes("/../") || path.posix.isAbsolute(relativePath)) {
+    return Response.json({ error: "Invalid project file path" }, { status: 400 })
+  }
+
+  const filePath = path.resolve(project.localPath, relativePath)
+  const projectRoot = path.resolve(project.localPath)
+  if (filePath !== projectRoot && !filePath.startsWith(`${projectRoot}${path.sep}`)) {
+    return Response.json({ error: "Invalid project file path" }, { status: 400 })
+  }
+
+  const file = Bun.file(filePath)
+  try {
+    const info = await stat(filePath)
+    if (!info.isFile()) {
+      return Response.json({ error: "File not found" }, { status: 404 })
+    }
+  } catch {
+    return Response.json({ error: "File not found" }, { status: 404 })
+  }
+
+  return new Response(file, {
+    headers: {
+      "Content-Type": inferProjectFileContentType(relativePath, file.type),
+    },
+  })
+}
+
 async function handleProjectUploadDelete(req: Request, url: URL, store: EventStore) {
   if (req.method !== "DELETE") {
     return null

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

@@ -1,5 +1,5 @@
-import { afterEach, beforeAll, describe, expect, test } from "bun:test"
-import { mkdtemp, rm } from "node:fs/promises"
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test"
+import { mkdtemp, mkdir, rm } from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
 import { TerminalManager } from "./terminal-manager"
@@ -13,10 +13,19 @@ const isSupportedPlatform = process.platform !== "win32" && typeof Bun.Terminal
 const describeIfSupported = isSupportedPlatform ? describe : describe.skip
 
 let tempProjectPath = ""
+let tempHomePath = ""
+const originalHome = process.env.HOME
+const originalZdotdir = process.env.ZDOTDIR
+const originalHistfile = process.env.HISTFILE
 
 beforeAll(async () => {
   if (!isSupportedPlatform) return
   tempProjectPath = await mkdtemp(path.join(os.tmpdir(), "kanna-terminal-manager-"))
+  tempHomePath = await mkdtemp(path.join(os.tmpdir(), "kanna-terminal-home-"))
+  await mkdir(path.join(tempHomePath, ".config"), { recursive: true })
+  process.env.HOME = tempHomePath
+  process.env.ZDOTDIR = tempHomePath
+  process.env.HISTFILE = path.join(tempHomePath, ".zsh_history")
 })
 
 afterEach(async () => {
@@ -25,6 +34,30 @@ afterEach(async () => {
   tempProjectPath = await mkdtemp(path.join(os.tmpdir(), "kanna-terminal-manager-"))
 })
 
+afterAll(async () => {
+  if (originalHome === undefined) {
+    delete process.env.HOME
+  } else {
+    process.env.HOME = originalHome
+  }
+
+  if (originalZdotdir === undefined) {
+    delete process.env.ZDOTDIR
+  } else {
+    process.env.ZDOTDIR = originalZdotdir
+  }
+
+  if (originalHistfile === undefined) {
+    delete process.env.HISTFILE
+  } else {
+    process.env.HISTFILE = originalHistfile
+  }
+
+  if (tempHomePath) {
+    await rm(tempHomePath, { recursive: true, force: true })
+  }
+})
+
 async function waitFor(check: () => boolean, timeoutMs: number, intervalMs = 25) {
   const startedAt = Date.now()
   while (Date.now() - startedAt < timeoutMs) {
@@ -70,8 +103,8 @@ describeIfSupported("TerminalManager", () => {
     const { manager, getOutput } = await createSession(terminalId)
 
     try {
-      manager.write(terminalId, 'python3 -c "import time; time.sleep(30)"\r')
-      await waitFor(() => getOutput().includes("time.sleep(30)"), COMMAND_TIMEOUT_MS)
+      manager.write(terminalId, `python3 -c "import time; print('__KANNA_SLEEP__', flush=True); time.sleep(30)"\r`)
+      await waitFor(() => getOutput().includes("__KANNA_SLEEP__"), COMMAND_TIMEOUT_MS)
 
       manager.write(terminalId, "\x03")
       manager.write(terminalId, "printf '__KANNA_AFTER_INT__\\n'\r")

package/src/server/uploads.ts

@@ -108,6 +108,10 @@ export function inferAttachmentContentType(fileName: string, fallbackType?: stri
   return fallbackType || DEFAULT_BINARY_MIME_TYPE
 }
 
+export function inferProjectFileContentType(fileName: string, fallbackType?: string): string {
+  return inferAttachmentContentType(fileName, fallbackType)
+}
+
 export async function deleteProjectUpload(args: {
   localPath: string
   storedName: string

package/src/server/ws-router.ts

@@ -4,6 +4,7 @@ import type { ClientEnvelope, ServerEnvelope, SubscriptionTopic } from "../share
 import { isClientEnvelope } from "../shared/protocol"
 import type { AgentCoordinator } from "./agent"
 import type { DiscoveredProject } from "./discovery"
+import { DiffStore } from "./diff-store"
 import { EventStore } from "./event-store"
 import { openExternal } from "./external-open"
 import { KeybindingsManager } from "./keybindings"
@@ -14,10 +15,12 @@ import { deriveChatSnapshot, deriveLocalProjectsSnapshot, deriveSidebarData } fr
 
 export interface ClientState {
   subscriptions: Map<string, SubscriptionTopic>
+  snapshotSignatures: Map<string, string>
 }
 
 interface CreateWsRouterArgs {
   store: EventStore
+  diffStore?: Pick<DiffStore, "getSnapshot" | "refreshSnapshot" | "generateCommitMessage" | "commitFiles">
   agent: AgentCoordinator
   terminals: TerminalManager
   keybindings: KeybindingsManager
@@ -31,8 +34,17 @@ function send(ws: ServerWebSocket<ClientState>, message: ServerEnvelope) {
   ws.send(JSON.stringify(message))
 }
 
+function ensureSnapshotSignatures(ws: ServerWebSocket<ClientState>) {
+  if (!ws.data.snapshotSignatures) {
+    ws.data.snapshotSignatures = new Map()
+  }
+
+  return ws.data.snapshotSignatures
+}
+
 export function createWsRouter({
   store,
+  diffStore,
   agent,
   terminals,
   keybindings,
@@ -42,6 +54,12 @@ export function createWsRouter({
   updateManager,
 }: CreateWsRouterArgs) {
   const sockets = new Set<ServerWebSocket<ClientState>>()
+  const resolvedDiffStore = diffStore ?? {
+    getSnapshot: () => ({ status: "unknown", branchName: undefined, files: [] as const }),
+    refreshSnapshot: async () => false,
+    generateCommitMessage: async () => ({ subject: "Update selected files", body: "", usedFallback: true, failureMessage: null }),
+    commitFiles: async () => false,
+  }
 
   function createEnvelope(id: string, topic: SubscriptionTopic): ServerEnvelope {
     if (topic.type === "sidebar") {
@@ -121,14 +139,28 @@ export function createWsRouter({
       id,
       snapshot: {
         type: "chat",
-        data: deriveChatSnapshot(store.state, agent.getActiveStatuses(), agent.getDrainingChatIds(), topic.chatId, (chatId) => store.getMessages(chatId)),
+        data: deriveChatSnapshot(
+          store.state,
+          agent.getActiveStatuses(),
+          agent.getDrainingChatIds(),
+          topic.chatId,
+          (chatId) => store.getMessages(chatId),
+          (chatId) => resolvedDiffStore.getSnapshot(chatId)
+        ),
       },
     }
   }
 
   function pushSnapshots(ws: ServerWebSocket<ClientState>) {
+    const snapshotSignatures = ensureSnapshotSignatures(ws)
     for (const [id, topic] of ws.data.subscriptions.entries()) {
-      send(ws, createEnvelope(id, topic))
+      const envelope = createEnvelope(id, topic)
+      const signature = JSON.stringify(envelope.snapshot)
+      if (snapshotSignatures.get(id) === signature) {
+        continue
+      }
+      snapshotSignatures.set(id, signature)
+      send(ws, envelope)
     }
   }
 
@@ -150,9 +182,14 @@ export function createWsRouter({
 
   function pushTerminalSnapshot(terminalId: string) {
     for (const ws of sockets) {
+      const snapshotSignatures = ensureSnapshotSignatures(ws)
       for (const [id, topic] of ws.data.subscriptions.entries()) {
         if (topic.type !== "terminal" || topic.terminalId !== terminalId) continue
-        send(ws, createEnvelope(id, topic))
+        const envelope = createEnvelope(id, topic)
+        const signature = JSON.stringify(envelope.snapshot)
+        if (snapshotSignatures.get(id) === signature) continue
+        snapshotSignatures.set(id, signature)
+        send(ws, envelope)
       }
     }
   }
@@ -177,18 +214,28 @@ export function createWsRouter({
 
   const disposeKeybindingEvents = keybindings.onChange(() => {
     for (const ws of sockets) {
+      const snapshotSignatures = ensureSnapshotSignatures(ws)
       for (const [id, topic] of ws.data.subscriptions.entries()) {
         if (topic.type !== "keybindings") continue
-        send(ws, createEnvelope(id, topic))
+        const envelope = createEnvelope(id, topic)
+        const signature = JSON.stringify(envelope.snapshot)
+        if (snapshotSignatures.get(id) === signature) continue
+        snapshotSignatures.set(id, signature)
+        send(ws, envelope)
       }
     }
   })
 
   const disposeUpdateEvents = updateManager?.onChange(() => {
     for (const ws of sockets) {
+      const snapshotSignatures = ensureSnapshotSignatures(ws)
       for (const [id, topic] of ws.data.subscriptions.entries()) {
         if (topic.type !== "update") continue
-        send(ws, createEnvelope(id, topic))
+        const envelope = createEnvelope(id, topic)
+        const signature = JSON.stringify(envelope.snapshot)
+        if (snapshotSignatures.get(id) === signature) continue
+        snapshotSignatures.set(id, signature)
+        send(ws, envelope)
       }
     }
   }) ?? (() => {})
@@ -299,6 +346,60 @@ export function createWsRouter({
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
           break
         }
+        case "chat.refreshDiffs": {
+          const chat = store.getChat(command.chatId)
+          if (!chat) {
+            throw new Error("Chat not found")
+          }
+          const project = store.getProject(chat.projectId)
+          if (!project) {
+            throw new Error("Project not found")
+          }
+          const changed = await resolvedDiffStore.refreshSnapshot(command.chatId, project.localPath)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          if (changed) {
+            broadcastSnapshots()
+          }
+          return
+        }
+        case "chat.generateCommitMessage": {
+          const chat = store.getChat(command.chatId)
+          if (!chat) {
+            throw new Error("Chat not found")
+          }
+          const project = store.getProject(chat.projectId)
+          if (!project) {
+            throw new Error("Project not found")
+          }
+          const result = await resolvedDiffStore.generateCommitMessage({
+            projectPath: project.localPath,
+            paths: command.paths,
+          })
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
+          return
+        }
+        case "chat.commitDiffs": {
+          const chat = store.getChat(command.chatId)
+          if (!chat) {
+            throw new Error("Chat not found")
+          }
+          const project = store.getProject(chat.projectId)
+          if (!project) {
+            throw new Error("Project not found")
+          }
+          const changed = await resolvedDiffStore.commitFiles({
+            chatId: command.chatId,
+            projectPath: project.localPath,
+            paths: command.paths,
+            summary: command.summary,
+            description: command.description,
+          })
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          if (changed) {
+            broadcastSnapshots()
+          }
+          return
+        }
         case "chat.cancel": {
           await agent.cancel(command.chatId)
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
@@ -350,6 +451,11 @@ export function createWsRouter({
       broadcastSnapshots()
     } catch (error) {
       const messageText = error instanceof Error ? error.message : String(error)
+      console.error("[ws-router] command failed", {
+        id,
+        type: command.type,
+        message: messageText,
+      })
       send(ws, { v: PROTOCOL_VERSION, type: "error", id, message: messageText })
     }
   }
@@ -377,20 +483,25 @@ export function createWsRouter({
       }
 
       if (parsed.type === "subscribe") {
+        const snapshotSignatures = ensureSnapshotSignatures(ws)
         ws.data.subscriptions.set(parsed.id, parsed.topic)
+        snapshotSignatures.delete(parsed.id)
         if (parsed.topic.type === "local-projects") {
           void refreshDiscovery().then(() => {
             if (ws.data.subscriptions.has(parsed.id)) {
-              send(ws, createEnvelope(parsed.id, parsed.topic))
+              pushSnapshots(ws)
             }
           })
+          return
         }
-        send(ws, createEnvelope(parsed.id, parsed.topic))
+        pushSnapshots(ws)
         return
       }
 
       if (parsed.type === "unsubscribe") {
+        const snapshotSignatures = ensureSnapshotSignatures(ws)
         ws.data.subscriptions.delete(parsed.id)
+        snapshotSignatures.delete(parsed.id)
         send(ws, { v: PROTOCOL_VERSION, type: "ack", id: parsed.id })
         return
       }

package/src/shared/protocol.ts

@@ -75,6 +75,9 @@ export type ClientCommand =
       effort?: string
       planMode?: boolean
     }
+  | { type: "chat.refreshDiffs"; chatId: string }
+  | { type: "chat.generateCommitMessage"; chatId: string; paths: string[] }
+  | { type: "chat.commitDiffs"; chatId: string; paths: string[]; summary: string; description?: string }
   | { type: "chat.cancel"; chatId: string }
   | { type: "chat.stopDraining"; chatId: string }
   | { type: "chat.respondTool"; chatId: string; toolUseId: string; result: unknown }

package/src/shared/types.ts

@@ -171,6 +171,16 @@ export function resolveClaudeApiModelId(modelId: string, contextWindow?: ClaudeC
   return contextWindow === "1m" ? `${modelId}[1m]` : modelId
 }
 
+export function resolveClaudeContextWindowTokens(contextWindow: ClaudeContextWindow): number {
+  switch (contextWindow) {
+    case "1m":
+      return 1_000_000
+    case "200k":
+    default:
+      return 200_000
+  }
+}
+
 export type KannaStatus =
   | "idle"
   | "starting"
@@ -440,6 +450,43 @@ export interface StatusEntry extends TranscriptEntryBase {
   status: string
 }
 
+export interface ContextWindowUsageSnapshot {
+  usedTokens: number
+  totalProcessedTokens?: number
+  maxTokens?: number
+  inputTokens?: number
+  cachedInputTokens?: number
+  outputTokens?: number
+  reasoningOutputTokens?: number
+  lastUsedTokens?: number
+  lastInputTokens?: number
+  lastCachedInputTokens?: number
+  lastOutputTokens?: number
+  lastReasoningOutputTokens?: number
+  toolUses?: number
+  durationMs?: number
+  compactsAutomatically: boolean
+}
+
+export interface ChatDiffFile {
+  path: string
+  changeType: "added" | "deleted" | "modified" | "renamed"
+  patch: string
+  mimeType?: string
+  size?: number
+}
+
+export interface ChatDiffSnapshot {
+  status: "unknown" | "ready" | "no_repo"
+  branchName?: string
+  files: ChatDiffFile[]
+}
+
+export interface ContextWindowUpdatedEntry extends TranscriptEntryBase {
+  kind: "context_window_updated"
+  usage: ContextWindowUsageSnapshot
+}
+
 export interface CompactBoundaryEntry extends TranscriptEntryBase {
   kind: "compact_boundary"
 }
@@ -466,6 +513,7 @@ export type TranscriptEntry =
   | ToolResultEntry
   | ResultEntry
   | StatusEntry
+  | ContextWindowUpdatedEntry
   | CompactBoundaryEntry
   | CompactSummaryEntry
   | ContextClearedEntry
@@ -579,6 +627,7 @@ export type HydratedTranscriptMessage =
   | ({ kind: "assistant_text"; text: string; id: string; messageId?: string; timestamp: string; hidden?: boolean })
   | ({ kind: "result"; success: boolean; cancelled?: boolean; result: string; durationMs: number; costUsd?: number; id: string; messageId?: string; timestamp: string; hidden?: boolean })
   | ({ kind: "status"; status: string; id: string; messageId?: string; timestamp: string; hidden?: boolean })
+  | ({ kind: "context_window_updated"; usage: ContextWindowUsageSnapshot; id: string; messageId?: string; timestamp: string; hidden?: boolean })
   | ({ kind: "compact_boundary"; id: string; messageId?: string; timestamp: string; hidden?: boolean })
   | ({ kind: "compact_summary"; summary: string; id: string; messageId?: string; timestamp: string; hidden?: boolean })
   | ({ kind: "context_cleared"; id: string; messageId?: string; timestamp: string; hidden?: boolean })
@@ -601,6 +650,7 @@ export interface ChatRuntime {
 export interface ChatSnapshot {
   runtime: ChatRuntime
   messages: TranscriptEntry[]
+  diffs: ChatDiffSnapshot
   availableProviders: ProviderCatalogEntry[]
 }