npm - kanna-code - Versions diffs - 0.26.5 → 0.26.7 - Mend

kanna-code 0.26.5 → 0.26.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/client/assets/index-CH3ZbXse.js +2583 -0
package/dist/client/index.html +1 -1
package/package.json +1 -1
package/src/server/agent.ts +128 -0
package/src/server/event-store.test.ts +102 -5
package/src/server/event-store.ts +73 -17
package/src/server/ws-router.test.ts +80 -0
package/src/server/ws-router.ts +63 -2
package/src/shared/protocol.ts +2 -0
package/dist/client/assets/index-BaEB4jie.js +0 -2583

package/dist/client/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <link rel="icon" type="image/png" href="/favicon.png" />
     <title>Kanna</title>
-    <script type="module" crossorigin src="/assets/index-BaEB4jie.js"></script>
+    <script type="module" crossorigin src="/assets/index-CH3ZbXse.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-C5RBxQW4.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "kanna-code",
   "type": "module",
-  "version": "0.26.5",
+  "version": "0.26.7",
   "description": "A beautiful web UI for Claude Code",
   "license": "MIT",
   "keywords": [

package/src/server/agent.ts CHANGED Viewed

@@ -63,6 +63,8 @@ interface ActiveTurn {
   hasFinalResult: boolean
   cancelRequested: boolean
   cancelRecorded: boolean
+  clientTraceId?: string
+  profilingStartedAt?: number
 }
 interface ClaudeSessionHandle {
@@ -102,6 +104,11 @@ interface AgentCoordinatorArgs {
   }) => Promise<ClaudeSessionHandle>
 }
+interface SendToStartingProfile {
+  traceId: string
+  startedAt: number
+}
 function timestamped<T extends Omit<TranscriptEntry, "_id" | "createdAt">>(
   entry: T,
   createdAt = Date.now()
@@ -138,6 +145,31 @@ function escapeXmlAttribute(value: string) {
     .replaceAll(">", "&gt;")
 }
+function isSendToStartingProfilingEnabled() {
+  return process.env.KANNA_PROFILE_SEND_TO_STARTING === "1"
+}
+function elapsedProfileMs(startedAt: number) {
+  return Number((performance.now() - startedAt).toFixed(1))
+}
+function logSendToStartingProfile(
+  profile: SendToStartingProfile | null | undefined,
+  stage: string,
+  details?: Record<string, unknown>
+) {
+  if (!profile || !isSendToStartingProfilingEnabled()) {
+    return
+  }
+  console.log("[kanna/send->starting][server]", JSON.stringify({
+    traceId: profile.traceId,
+    stage,
+    elapsedMs: elapsedProfileMs(profile.startedAt),
+    ...details,
+  }))
+}
 export function buildAttachmentHintText(attachments: ChatAttachment[]) {
   if (attachments.length === 0) return ""
@@ -636,6 +668,18 @@ export class AgentCoordinator {
     return new Set(this.drainingStreams.keys())
   }
+  getActiveTurnProfile(chatId: string): SendToStartingProfile | null {
+    const active = this.activeTurns.get(chatId)
+    if (!active?.clientTraceId || active.profilingStartedAt === undefined) {
+      return null
+    }
+    return {
+      traceId: active.clientTraceId,
+      startedAt: active.profilingStartedAt,
+    }
+  }
   async stopDraining(chatId: string) {
     const draining = this.drainingStreams.get(chatId)
     if (!draining) return
@@ -691,7 +735,15 @@ export class AgentCoordinator {
     serviceTier?: "fast"
     planMode: boolean
     appendUserPrompt: boolean
+    profile?: SendToStartingProfile | null
   }) {
+    logSendToStartingProfile(args.profile, "start_turn.begin", {
+      chatId: args.chatId,
+      provider: args.provider,
+      appendUserPrompt: args.appendUserPrompt,
+      planMode: args.planMode,
+    })
     // Close any lingering draining stream before starting a new turn.
     const draining = this.drainingStreams.get(args.chatId)
     if (draining) {
@@ -706,8 +758,16 @@ export class AgentCoordinator {
     if (!chat.provider) {
       await this.store.setChatProvider(args.chatId, args.provider)
+      logSendToStartingProfile(args.profile, "start_turn.provider_set", {
+        chatId: args.chatId,
+        provider: args.provider,
+      })
     }
     await this.store.setPlanMode(args.chatId, args.planMode)
+    logSendToStartingProfile(args.profile, "start_turn.plan_mode_set", {
+      chatId: args.chatId,
+      planMode: args.planMode,
+    })
     const existingMessages = this.store.getMessages(args.chatId)
     const shouldGenerateTitle = args.appendUserPrompt && chat.title === "New Chat" && existingMessages.length === 0
@@ -715,6 +775,10 @@ export class AgentCoordinator {
     if (optimisticTitle) {
       await this.store.renameChat(args.chatId, optimisticTitle)
+      logSendToStartingProfile(args.profile, "start_turn.optimistic_title_set", {
+        chatId: args.chatId,
+        title: optimisticTitle,
+      })
     }
     const project = this.store.getProject(chat.projectId)
@@ -728,8 +792,15 @@ export class AgentCoordinator {
         Date.now()
       )
       await this.store.appendMessage(args.chatId, userPromptEntry)
+      logSendToStartingProfile(args.profile, "start_turn.user_prompt_appended", {
+        chatId: args.chatId,
+        entryId: userPromptEntry._id,
+      })
     }
     await this.store.recordTurnStarted(args.chatId)
+    logSendToStartingProfile(args.profile, "start_turn.turn_started_recorded", {
+      chatId: args.chatId,
+    })
     if (shouldGenerateTitle) {
       void this.generateTitleInBackground(args.chatId, args.content, project.localPath, optimisticTitle ?? "New Chat")
@@ -755,6 +826,11 @@ export class AgentCoordinator {
     let turn: HarnessTurn
     if (args.provider === "claude") {
+      logSendToStartingProfile(args.profile, "start_turn.provider_boot.begin", {
+        chatId: args.chatId,
+        provider: args.provider,
+        model: args.model,
+      })
       turn = await this.startClaudeTurn({
         chatId: args.chatId,
         localPath: project.localPath,
@@ -764,7 +840,17 @@ export class AgentCoordinator {
         sessionToken: chat.sessionToken,
         onToolRequest,
       })
+      logSendToStartingProfile(args.profile, "start_turn.provider_boot.ready", {
+        chatId: args.chatId,
+        provider: args.provider,
+        model: args.model,
+      })
     } else {
+      logSendToStartingProfile(args.profile, "start_turn.provider_boot.begin", {
+        chatId: args.chatId,
+        provider: args.provider,
+        model: args.model,
+      })
       await this.codexManager.startSession({
         chatId: args.chatId,
         cwd: project.localPath,
@@ -772,6 +858,11 @@ export class AgentCoordinator {
         serviceTier: args.serviceTier,
         sessionToken: chat.sessionToken,
       })
+      logSendToStartingProfile(args.profile, "start_turn.session_ready", {
+        chatId: args.chatId,
+        provider: args.provider,
+        model: args.model,
+      })
       turn = await this.codexManager.startTurn({
         chatId: args.chatId,
         content: buildPromptText(args.content, args.attachments),
@@ -781,6 +872,11 @@ export class AgentCoordinator {
         planMode: args.planMode,
         onToolRequest,
       })
+      logSendToStartingProfile(args.profile, "start_turn.provider_boot.ready", {
+        chatId: args.chatId,
+        provider: args.provider,
+        model: args.model,
+      })
     }
     const active: ActiveTurn = {
@@ -797,9 +893,19 @@ export class AgentCoordinator {
       hasFinalResult: false,
       cancelRequested: false,
       cancelRecorded: false,
+      clientTraceId: args.profile?.traceId,
+      profilingStartedAt: args.profile?.startedAt,
     }
     this.activeTurns.set(args.chatId, active)
+    logSendToStartingProfile(args.profile, "start_turn.active_turn_registered", {
+      chatId: args.chatId,
+      status: active.status,
+    })
     this.onStateChange()
+    logSendToStartingProfile(args.profile, "start_turn.state_change_emitted", {
+      chatId: args.chatId,
+      status: active.status,
+    })
     if (turn.getAccountInfo) {
       void turn.getAccountInfo()
@@ -826,6 +932,9 @@ export class AgentCoordinator {
         throw new Error("Claude session was not initialized")
       }
       await session.session.sendPrompt(buildPromptText(args.content, args.attachments))
+      logSendToStartingProfile(args.profile, "start_turn.claude_prompt_sent", {
+        chatId: args.chatId,
+      })
       return
     }
@@ -893,14 +1002,26 @@ export class AgentCoordinator {
   }
   async send(command: Extract<ClientCommand, { type: "chat.send" }>) {
+    const profile = command.clientTraceId
+      ? { traceId: command.clientTraceId, startedAt: performance.now() }
+      : null
     let chatId = command.chatId
+    logSendToStartingProfile(profile, "chat_send.received", {
+      existingChatId: command.chatId ?? null,
+      projectId: command.projectId ?? null,
+    })
     if (!chatId) {
       if (!command.projectId) {
         throw new Error("Missing projectId for new chat")
       }
       const created = await this.store.createChat(command.projectId)
       chatId = created.id
+      logSendToStartingProfile(profile, "chat_send.chat_created", {
+        chatId,
+        projectId: command.projectId,
+      })
     }
     const chat = this.store.requireChat(chatId)
@@ -916,6 +1037,13 @@ export class AgentCoordinator {
       serviceTier: settings.serviceTier,
       planMode: settings.planMode,
       appendUserPrompt: true,
+      profile,
+    })
+    logSendToStartingProfile(profile, "chat_send.ready_for_ack", {
+      chatId,
+      provider,
+      model: settings.model,
     })
     return { chatId }

package/src/server/event-store.test.ts CHANGED Viewed

@@ -191,6 +191,86 @@ describe("EventStore", () => {
     expect(reloaded.getChat(chat.id)?.unread).toBe(true)
   })
+  test("preserves read state after a finished turn across restart", async () => {
+    const dataDir = await createTempDataDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+    const project = await store.openProject("/tmp/project")
+    const chat = await store.createChat(project.id)
+    await store.recordTurnFinished(chat.id)
+    await store.setChatReadState(chat.id, false)
+    expect(store.getChat(chat.id)?.unread).toBe(false)
+    const reloaded = new EventStore(dataDir)
+    await reloaded.initialize()
+    expect(reloaded.getChat(chat.id)?.unread).toBe(false)
+  })
+  test("preserves read state after a failed turn across restart", async () => {
+    const dataDir = await createTempDataDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+    const project = await store.openProject("/tmp/project")
+    const chat = await store.createChat(project.id)
+    await store.recordTurnFailed(chat.id, "boom")
+    await store.setChatReadState(chat.id, false)
+    expect(store.getChat(chat.id)?.unread).toBe(false)
+    const reloaded = new EventStore(dataDir)
+    await reloaded.initialize()
+    expect(reloaded.getChat(chat.id)?.unread).toBe(false)
+  })
+  test("prefers mark-read over turn completion when replay timestamps tie", async () => {
+    const dataDir = await createTempDataDir()
+    const chatsLogPath = join(dataDir, "chats.jsonl")
+    const turnsLogPath = join(dataDir, "turns.jsonl")
+    const projectId = "project-1"
+    const chatId = "chat-1"
+    const timestamp = 100
+    await writeFile(chatsLogPath, [
+      JSON.stringify({
+        v: 2,
+        type: "chat_created",
+        timestamp,
+        chatId,
+        projectId,
+        title: "Chat",
+      }),
+      JSON.stringify({
+        v: 2,
+        type: "chat_read_state_set",
+        timestamp,
+        chatId,
+        unread: false,
+      }),
+      "",
+    ].join("\n"), "utf8")
+    await writeFile(turnsLogPath, [
+      JSON.stringify({
+        v: 2,
+        type: "turn_finished",
+        timestamp,
+        chatId,
+      }),
+      "",
+    ].join("\n"), "utf8")
+    const store = new EventStore(dataDir)
+    await store.initialize()
+    expect(store.getChat(chatId)?.unread).toBe(false)
+  })
   test("loads chats without unread from older snapshots as read", async () => {
     const dataDir = await createTempDataDir()
     const snapshotPath = join(dataDir, "snapshot.json")
@@ -226,14 +306,14 @@ describe("EventStore", () => {
     expect(store.getChat("chat-1")?.unread).toBe(false)
   })
-  test("prunes stale empty chats after five minutes", async () => {
+  test("prunes stale empty chats after thirty minutes", async () => {
     const dataDir = await createTempDataDir()
     const store = new EventStore(dataDir)
     await store.initialize()
     const project = await store.openProject("/tmp/project")
     const chat = await store.createChat(project.id)
-    const staleNow = chat.createdAt + 5 * 60 * 1000
+    const staleNow = chat.createdAt + 30 * 60 * 1000
     const pruned = await store.pruneStaleEmptyChats({ now: staleNow })
@@ -248,7 +328,7 @@ describe("EventStore", () => {
     const project = await store.openProject("/tmp/project")
     const chat = await store.createChat(project.id)
-    const pruned = await store.pruneStaleEmptyChats({ now: chat.createdAt + 5 * 60 * 1000 - 1 })
+    const pruned = await store.pruneStaleEmptyChats({ now: chat.createdAt + 30 * 60 * 1000 - 1 })
     expect(pruned).toEqual([])
     expect(store.getChat(chat.id)?.id).toBe(chat.id)
@@ -263,7 +343,7 @@ describe("EventStore", () => {
     const chat = await store.createChat(project.id)
     await store.appendMessage(chat.id, entry("user_prompt", chat.createdAt + 1, { content: "hello" }))
-    const pruned = await store.pruneStaleEmptyChats({ now: chat.createdAt + 5 * 60 * 1000 })
+    const pruned = await store.pruneStaleEmptyChats({ now: chat.createdAt + 30 * 60 * 1000 })
     expect(pruned).toEqual([])
     expect(store.getChat(chat.id)?.id).toBe(chat.id)
@@ -278,11 +358,28 @@ describe("EventStore", () => {
     const chat = await store.createChat(project.id)
     const pruned = await store.pruneStaleEmptyChats({
-      now: chat.createdAt + 5 * 60 * 1000,
+      now: chat.createdAt + 30 * 60 * 1000,
       activeChatIds: [chat.id],
     })
     expect(pruned).toEqual([])
     expect(store.getChat(chat.id)?.id).toBe(chat.id)
   })
+  test("does not prune stale chats with protected draft state", async () => {
+    const dataDir = await createTempDataDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+    const project = await store.openProject("/tmp/project")
+    const chat = await store.createChat(project.id)
+    const pruned = await store.pruneStaleEmptyChats({
+      now: chat.createdAt + 30 * 60 * 1000,
+      protectedChatIds: [chat.id],
+    })
+    expect(pruned).toEqual([])
+    expect(store.getChat(chat.id)?.id).toBe(chat.id)
+  })
 })

package/src/server/event-store.ts CHANGED Viewed

@@ -7,7 +7,6 @@ import type { AgentProvider, ChatHistoryPage, ChatHistorySnapshot, TranscriptEnt
 import { STORE_VERSION } from "../shared/types"
 import {
   type ChatEvent,
-  type MessageEvent,
   type ProjectEvent,
   type SnapshotFile,
   type StoreEvent,
@@ -19,7 +18,7 @@ import {
 import { resolveLocalPath } from "./paths"
 const COMPACTION_THRESHOLD_BYTES = 2 * 1024 * 1024
-const STALE_EMPTY_CHAT_MAX_AGE_MS = 5 * 60 * 1000
+const STALE_EMPTY_CHAT_MAX_AGE_MS = 30 * 60 * 1000
 interface LegacyTranscriptStats {
   hasLegacyData: boolean
   sources: Array<"snapshot" | "messages_log">
@@ -33,6 +32,41 @@ interface TranscriptPageResult {
   olderCursor: string | null
 }
+interface ParsedReplayEvent {
+  event: StoreEvent
+  sourceIndex: number
+  lineIndex: number
+}
+function getReplayEventPriority(event: StoreEvent) {
+  switch (event.type) {
+    case "project_opened":
+    case "project_removed":
+      return 0
+    case "chat_created":
+      return 1
+    case "chat_renamed":
+    case "chat_provider_set":
+    case "chat_plan_mode_set":
+      return 2
+    case "message_appended":
+      return 3
+    case "turn_started":
+      return 4
+    case "session_token_set":
+      return 5
+    case "turn_cancelled":
+      return 6
+    case "turn_finished":
+    case "turn_failed":
+      return 7
+    case "chat_read_state_set":
+      return 8
+    case "chat_deleted":
+      return 9
+  }
+}
 function encodeHistoryCursor(index: number) {
   return `idx:${index}`
 }
@@ -166,21 +200,33 @@ export class EventStore {
   private async replayLogs() {
     if (this.storageReset) return
-    await this.replayLog<ProjectEvent>(this.projectsLogPath)
-    if (this.storageReset) return
-    await this.replayLog<ChatEvent>(this.chatsLogPath)
-    if (this.storageReset) return
-    await this.replayLog<MessageEvent>(this.messagesLogPath)
+    const replayEvents = [
+      ...await this.loadReplayEvents(this.projectsLogPath, 0),
+      ...await this.loadReplayEvents(this.chatsLogPath, 1),
+      ...await this.loadReplayEvents(this.messagesLogPath, 2),
+      ...await this.loadReplayEvents(this.turnsLogPath, 3),
+    ]
     if (this.storageReset) return
-    await this.replayLog<TurnEvent>(this.turnsLogPath)
+    replayEvents
+      .sort((left, right) => (
+        left.event.timestamp - right.event.timestamp
+        || getReplayEventPriority(left.event) - getReplayEventPriority(right.event)
+        || left.sourceIndex - right.sourceIndex
+        || left.lineIndex - right.lineIndex
+      ))
+      .forEach(({ event }) => {
+        this.applyEvent(event)
+      })
   }
-  private async replayLog<TEvent extends StoreEvent>(filePath: string) {
+  private async loadReplayEvents(filePath: string, sourceIndex: number): Promise<ParsedReplayEvent[]> {
     const file = Bun.file(filePath)
-    if (!(await file.exists())) return
+    if (!(await file.exists())) return []
     const text = await file.text()
-    if (!text.trim()) return
+    if (!text.trim()) return []
+    const parsedEvents: ParsedReplayEvent[] = []
     const lines = text.split("\n")
     let lastNonEmpty = -1
     for (let index = lines.length - 1; index >= 0; index -= 1) {
@@ -198,19 +244,25 @@ export class EventStore {
         if (event.v !== STORE_VERSION) {
           console.warn(`${LOG_PREFIX} Resetting local history from incompatible event log`)
           await this.clearStorage()
-          return
+          return []
         }
-        this.applyEvent(event as StoreEvent)
+        parsedEvents.push({
+          event: event as StoreEvent,
+          sourceIndex,
+          lineIndex: index,
+        })
       } catch (error) {
         if (index === lastNonEmpty) {
           console.warn(`${LOG_PREFIX} Ignoring corrupt trailing line in ${path.basename(filePath)}`)
-          return
+          return parsedEvents
         }
         console.warn(`${LOG_PREFIX} Failed to replay ${path.basename(filePath)}, resetting local history:`, error)
         await this.clearStorage()
-        return
+        return []
       }
     }
+    return parsedEvents
   }
   private applyEvent(event: StoreEvent) {
@@ -459,14 +511,18 @@ export class EventStore {
     now?: number
     maxAgeMs?: number
     activeChatIds?: Iterable<string>
+    protectedChatIds?: Iterable<string>
   }) {
     const now = args?.now ?? Date.now()
     const maxAgeMs = args?.maxAgeMs ?? STALE_EMPTY_CHAT_MAX_AGE_MS
-    const activeChatIds = new Set(args?.activeChatIds ?? [])
+    const protectedChatIds = new Set([
+      ...(args?.activeChatIds ?? []),
+      ...(args?.protectedChatIds ?? []),
+    ])
     const prunedChatIds: string[] = []
     for (const chat of this.state.chatsById.values()) {
-      if (chat.deletedAt || activeChatIds.has(chat.id)) continue
+      if (chat.deletedAt || protectedChatIds.has(chat.id)) continue
       if (now - chat.createdAt < maxAgeMs) continue
       if (this.getMessages(chat.id).length > 0) continue

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

@@ -8,6 +8,7 @@ class FakeWebSocket {
   readonly sent: unknown[] = []
   readonly data = {
     subscriptions: new Map(),
+    protectedDraftChatIds: new Set<string>(),
   }
   send(message: string) {
@@ -742,6 +743,85 @@ describe("ws-router", () => {
     })
   })
+  test("protects draft-bearing chats from stale pruning before 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-stale", {
+      id: "chat-stale",
+      projectId: "project-1",
+      title: "New Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      unread: false,
+      provider: null,
+      planMode: false,
+      sessionToken: null,
+      lastTurnOutcome: null,
+    })
+    let capturedProtectedChatIds: string[] = []
+    const router = createWsRouter({
+      store: {
+        state,
+        async pruneStaleEmptyChats(args?: { protectedChatIds?: Iterable<string> }) {
+          capturedProtectedChatIds = [...(args?.protectedChatIds ?? [])]
+          return []
+        },
+      } 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()
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "draft-protection-1",
+        command: {
+          type: "chat.setDraftProtection",
+          chatIds: ["chat-stale"],
+        },
+      })
+    )
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "subscribe",
+        id: "sidebar-sub-1",
+        topic: { type: "sidebar" },
+      })
+    )
+    expect(capturedProtectedChatIds).toEqual(["chat-stale"])
+    expect(ws.sent[0]).toEqual({
+      v: PROTOCOL_VERSION,
+      type: "ack",
+      id: "draft-protection-1",
+    })
+  })
   test("broadcasts background title-generation errors to connected clients", () => {
     let reportBackgroundError: ((message: string) => void) | null | undefined
     const router = createWsRouter({