kanna-code 0.19.0 → 0.20.0

package/src/server/agent.ts

@@ -1,4 +1,4 @@
-import { query, type CanUseTool, type PermissionResult, type Query } from "@anthropic-ai/claude-agent-sdk"
+import { query, type CanUseTool, type PermissionResult, type Query, type SDKUserMessage } from "@anthropic-ai/claude-agent-sdk"
 import type {
   AgentProvider,
   ChatAttachment,
@@ -64,11 +64,41 @@ interface ActiveTurn {
   cancelRecorded: boolean
 }
 
+interface ClaudeSessionHandle {
+  provider: "claude"
+  stream: AsyncIterable<HarnessEvent>
+  getAccountInfo?: () => Promise<any>
+  interrupt: () => Promise<void>
+  close: () => void
+  sendPrompt: (content: string) => Promise<void>
+  setModel: (model: string) => Promise<void>
+  setPermissionMode: (planMode: boolean) => Promise<void>
+}
+
+interface ClaudeSessionState {
+  chatId: string
+  session: ClaudeSessionHandle
+  localPath: string
+  model: string
+  effort?: string
+  planMode: boolean
+  sessionToken: string | null
+  accountInfoLoaded: boolean
+}
+
 interface AgentCoordinatorArgs {
   store: EventStore
   onStateChange: () => void
   codexManager?: CodexAppServerManager
   generateTitle?: (messageContent: string, cwd: string) => Promise<GenerateChatTitleResult>
+  startClaudeSession?: (args: {
+    localPath: string
+    model: string
+    effort?: string
+    planMode: boolean
+    sessionToken: string | null
+    onToolRequest: (request: HarnessToolRequest) => Promise<unknown>
+  }) => Promise<ClaudeSessionHandle>
 }
 
 function timestamped<T extends Omit<TranscriptEntry, "_id" | "createdAt">>(
@@ -269,15 +299,61 @@ async function* createClaudeHarnessStream(q: Query): AsyncGenerator<HarnessEvent
   }
 }
 
-async function startClaudeTurn(args: {
-  content: string
+class AsyncMessageQueue<T> implements AsyncIterable<T> {
+  private readonly values: T[] = []
+  private readonly waiters: Array<(result: IteratorResult<T>) => void> = []
+  private closed = false
+
+  push(value: T) {
+    if (this.closed) {
+      throw new Error("Cannot push to a closed queue")
+    }
+
+    const waiter = this.waiters.shift()
+    if (waiter) {
+      waiter({ done: false, value })
+      return
+    }
+
+    this.values.push(value)
+  }
+
+  close() {
+    if (this.closed) return
+    this.closed = true
+    while (this.waiters.length > 0) {
+      const waiter = this.waiters.shift()
+      waiter?.({ done: true, value: undefined as never })
+    }
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<T> {
+    return {
+      next: async () => {
+        if (this.values.length > 0) {
+          return { done: false, value: this.values.shift() as T }
+        }
+
+        if (this.closed) {
+          return { done: true, value: undefined as never }
+        }
+
+        return await new Promise<IteratorResult<T>>((resolve) => {
+          this.waiters.push(resolve)
+        })
+      },
+    }
+  }
+}
+
+async function startClaudeSession(args: {
   localPath: string
   model: string
   effort?: string
   planMode: boolean
   sessionToken: string | null
   onToolRequest: (request: HarnessToolRequest) => Promise<unknown>
-}): Promise<HarnessTurn> {
+}): Promise<ClaudeSessionHandle> {
   const canUseTool: CanUseTool = async (toolName, input, options) => {
     if (toolName !== "AskUserQuestion" && toolName !== "ExitPlanMode") {
       return {
@@ -333,8 +409,10 @@ async function startClaudeTurn(args: {
     } satisfies PermissionResult
   }
 
+  const promptQueue = new AsyncMessageQueue<SDKUserMessage>()
+
   const q = query({
-    prompt: args.content,
+    prompt: promptQueue,
     options: {
       cwd: args.localPath,
       model: args.model,
@@ -361,7 +439,25 @@ async function startClaudeTurn(args: {
     interrupt: async () => {
       await q.interrupt()
     },
+    sendPrompt: async (content: string) => {
+      promptQueue.push({
+        type: "user",
+        message: {
+          role: "user",
+          content,
+        },
+        parent_tool_use_id: null,
+        session_id: args.sessionToken ?? "",
+      })
+    },
+    setModel: async (model: string) => {
+      await q.setModel(model)
+    },
+    setPermissionMode: async (planMode: boolean) => {
+      await q.setPermissionMode(planMode ? "plan" : "acceptEdits")
+    },
     close: () => {
+      promptQueue.close()
       q.close()
     },
   }
@@ -372,14 +468,18 @@ export class AgentCoordinator {
   private readonly onStateChange: () => void
   private readonly codexManager: CodexAppServerManager
   private readonly generateTitle: (messageContent: string, cwd: string) => Promise<GenerateChatTitleResult>
+  private readonly startClaudeSessionFn: NonNullable<AgentCoordinatorArgs["startClaudeSession"]>
   private reportBackgroundError: ((message: string) => void) | null = null
   readonly activeTurns = new Map<string, ActiveTurn>()
+  readonly drainingStreams = new Map<string, { turn: HarnessTurn }>()
+  readonly claudeSessions = new Map<string, ClaudeSessionState>()
 
   constructor(args: AgentCoordinatorArgs) {
     this.store = args.store
     this.onStateChange = args.onStateChange
     this.codexManager = args.codexManager ?? new CodexAppServerManager()
     this.generateTitle = args.generateTitle ?? generateTitleForChatDetailed
+    this.startClaudeSessionFn = args.startClaudeSession ?? startClaudeSession
   }
 
   setBackgroundErrorReporter(report: ((message: string) => void) | null) {
@@ -400,6 +500,28 @@ export class AgentCoordinator {
     return { toolUseId: pending.toolUseId, toolKind: pending.tool.toolKind }
   }
 
+  getDrainingChatIds(): Set<string> {
+    return new Set(this.drainingStreams.keys())
+  }
+
+  async stopDraining(chatId: string) {
+    const draining = this.drainingStreams.get(chatId)
+    if (!draining) return
+    draining.turn.close()
+    this.drainingStreams.delete(chatId)
+    this.onStateChange()
+  }
+
+  async closeChat(chatId: string) {
+    await this.stopDraining(chatId)
+    const claudeSession = this.claudeSessions.get(chatId)
+    if (claudeSession) {
+      claudeSession.session.close()
+      this.claudeSessions.delete(chatId)
+    }
+    this.onStateChange()
+  }
+
   private resolveProvider(command: Extract<ClientCommand, { type: "chat.send" }>, currentProvider: AgentProvider | null) {
     if (currentProvider) return currentProvider
     return command.provider ?? "claude"
@@ -438,6 +560,13 @@ export class AgentCoordinator {
     planMode: boolean
     appendUserPrompt: boolean
   }) {
+    // Close any lingering draining stream before starting a new turn.
+    const draining = this.drainingStreams.get(args.chatId)
+    if (draining) {
+      draining.turn.close()
+      this.drainingStreams.delete(args.chatId)
+    }
+
     const chat = this.store.requireChat(args.chatId)
     if (this.activeTurns.has(args.chatId)) {
       throw new Error("Chat is already running")
@@ -493,8 +622,8 @@ export class AgentCoordinator {
 
     let turn: HarnessTurn
     if (args.provider === "claude") {
-      turn = await startClaudeTurn({
-        content: buildPromptText(args.content, args.attachments),
+      turn = await this.startClaudeTurn({
+        chatId: args.chatId,
         localPath: project.localPath,
         model: args.model,
         effort: args.effort,
@@ -529,7 +658,7 @@ export class AgentCoordinator {
       effort: args.effort,
       serviceTier: args.serviceTier,
       planMode: args.planMode,
-      status: "starting",
+      status: args.provider === "claude" ? "running" : "starting",
       pendingTool: null,
       postToolFollowUp: null,
       hasFinalResult: false,
@@ -543,15 +672,93 @@ export class AgentCoordinator {
       void turn.getAccountInfo()
         .then(async (accountInfo) => {
           if (!accountInfo) return
+          if (args.provider === "claude") {
+            const session = this.claudeSessions.get(args.chatId)
+            if (session) {
+              if (session.accountInfoLoaded) return
+              session.accountInfoLoaded = true
+            } else {
+              return
+            }
+          }
           await this.store.appendMessage(args.chatId, timestamped({ kind: "account_info", accountInfo }))
           this.onStateChange()
         })
         .catch(() => undefined)
     }
 
+    if (args.provider === "claude") {
+      const session = this.claudeSessions.get(args.chatId)
+      if (!session) {
+        throw new Error("Claude session was not initialized")
+      }
+      await session.session.sendPrompt(buildPromptText(args.content, args.attachments))
+      return
+    }
+
     void this.runTurn(active)
   }
 
+  private async startClaudeTurn(args: {
+    chatId: string
+    localPath: string
+    model: string
+    effort?: string
+    planMode: boolean
+    sessionToken: string | null
+    onToolRequest: (request: HarnessToolRequest) => Promise<unknown>
+  }): Promise<HarnessTurn> {
+    let session = this.claudeSessions.get(args.chatId)
+
+    if (!session || session.localPath !== args.localPath || session.effort !== args.effort) {
+      if (session) {
+        session.session.close()
+        this.claudeSessions.delete(args.chatId)
+      }
+
+      const started = await this.startClaudeSessionFn({
+        localPath: args.localPath,
+        model: args.model,
+        effort: args.effort,
+        planMode: args.planMode,
+        sessionToken: args.sessionToken,
+        onToolRequest: args.onToolRequest,
+      })
+
+      session = {
+        chatId: args.chatId,
+        session: started,
+        localPath: args.localPath,
+        model: args.model,
+        effort: args.effort,
+        planMode: args.planMode,
+        sessionToken: args.sessionToken,
+        accountInfoLoaded: false,
+      }
+      this.claudeSessions.set(args.chatId, session)
+      void this.runClaudeSession(session)
+    } else {
+      if (session.model !== args.model) {
+        await session.session.setModel(args.model)
+        session.model = args.model
+      }
+      if (session.planMode !== args.planMode) {
+        await session.session.setPermissionMode(args.planMode)
+        session.planMode = args.planMode
+      }
+    }
+
+    return {
+      provider: "claude",
+      stream: {
+        async *[Symbol.asyncIterator]() {},
+      },
+      getAccountInfo: session.session.getAccountInfo,
+      interrupt: session.session.interrupt,
+      close: () => {},
+    }
+  }
+
   async send(command: Extract<ClientCommand, { type: "chat.send" }>) {
     let chatId = command.chatId
 
@@ -581,6 +788,66 @@ export class AgentCoordinator {
     return { chatId }
   }
 
+  private async runClaudeSession(session: ClaudeSessionState) {
+    try {
+      for await (const event of session.session.stream) {
+        if (event.type === "session_token" && event.sessionToken) {
+          session.sessionToken = event.sessionToken
+          await this.store.setSessionToken(session.chatId, event.sessionToken)
+          this.onStateChange()
+          continue
+        }
+
+        if (!event.entry) continue
+        await this.store.appendMessage(session.chatId, event.entry)
+
+        const active = this.activeTurns.get(session.chatId)
+        if (event.entry.kind === "system_init" && active) {
+          active.status = "running"
+        }
+
+        if (event.entry.kind === "result" && active) {
+          active.hasFinalResult = true
+          if (event.entry.isError) {
+            await this.store.recordTurnFailed(session.chatId, event.entry.result || "Turn failed")
+          } else if (!active.cancelRequested) {
+            await this.store.recordTurnFinished(session.chatId)
+          }
+          this.activeTurns.delete(session.chatId)
+        }
+
+        this.onStateChange()
+      }
+    } catch (error) {
+      const active = this.activeTurns.get(session.chatId)
+      if (active && !active.cancelRequested) {
+        const message = error instanceof Error ? error.message : String(error)
+        await this.store.appendMessage(
+          session.chatId,
+          timestamped({
+            kind: "result",
+            subtype: "error",
+            isError: true,
+            durationMs: 0,
+            result: message,
+          })
+        )
+        await this.store.recordTurnFailed(session.chatId, message)
+      }
+    } finally {
+      this.claudeSessions.delete(session.chatId)
+      const active = this.activeTurns.get(session.chatId)
+      if (active?.provider === "claude") {
+        if (active.cancelRequested && !active.cancelRecorded) {
+          await this.store.recordTurnCancelled(session.chatId)
+        }
+        this.activeTurns.delete(session.chatId)
+      }
+      session.session.close()
+      this.onStateChange()
+    }
+  }
+
   private async generateTitleInBackground(chatId: string, messageContent: string, cwd: string, expectedCurrentTitle: string) {
     try {
       const result = await this.generateTitle(messageContent, cwd)
@@ -607,6 +874,10 @@ export class AgentCoordinator {
   private async runTurn(active: ActiveTurn) {
     try {
       for await (const event of active.turn.stream) {
+        // Once cancelled, stop processing further stream events.
+        // cancel() already removed us from activeTurns and notified the UI.
+        if (active.cancelRequested) break
+
         if (event.type === "session_token" && event.sessionToken) {
           await this.store.setSessionToken(active.chatId, event.sessionToken)
           this.onStateChange()
@@ -627,6 +898,14 @@ export class AgentCoordinator {
           } else if (!active.cancelRequested) {
             await this.store.recordTurnFinished(active.chatId)
           }
+          // Remove from activeTurns as soon as the result arrives so the UI
+          // transitions to idle immediately. The stream may still be open
+          // (e.g. background tasks), but the user should be able to send
+          // new messages without having to hit stop first.
+          this.activeTurns.delete(active.chatId)
+          // Track the still-open stream so the UI can show a draining
+          // indicator and the user can stop background tasks.
+          this.drainingStreams.set(active.chatId, { turn: active.turn })
         }
 
         this.onStateChange()
@@ -651,7 +930,14 @@ export class AgentCoordinator {
         await this.store.recordTurnCancelled(active.chatId)
       }
       active.turn.close()
-      this.activeTurns.delete(active.chatId)
+      // Only remove if we're still the active turn for this chat.
+      // We may have already been removed by result handling or cancel(),
+      // and a new turn may have started for the same chatId.
+      if (this.activeTurns.get(active.chatId) === active) {
+        this.activeTurns.delete(active.chatId)
+      }
+      // Stream has fully ended — no longer draining.
+      this.drainingStreams.delete(active.chatId)
       this.onStateChange()
 
       if (active.postToolFollowUp && !active.cancelRequested) {
@@ -687,9 +973,18 @@ export class AgentCoordinator {
   }
 
   async cancel(chatId: string) {
+    // Also clean up any draining stream for this chat.
+    const draining = this.drainingStreams.get(chatId)
+    if (draining) {
+      draining.turn.close()
+      this.drainingStreams.delete(chatId)
+    }
+
     const active = this.activeTurns.get(chatId)
     if (!active) return
 
+    // Guard against concurrent cancel() calls — only the first one does work.
+    if (active.cancelRequested) return
     active.cancelRequested = true
 
     const pendingTool = active.pendingTool
@@ -715,14 +1010,23 @@ export class AgentCoordinator {
     active.cancelRecorded = true
     active.hasFinalResult = true
 
+    // Remove from activeTurns immediately so the UI reflects the cancellation
+    // right away, rather than waiting for interrupt() which may hang.
+    this.activeTurns.delete(chatId)
+    this.onStateChange()
+
+    // Now attempt to interrupt/close the underlying stream in the background.
+    // This is best-effort — the turn is already removed from active state above,
+    // and runTurn()'s finally block will also call close().
     try {
-      await active.turn.interrupt()
+      await Promise.race([
+        active.turn.interrupt(),
+        new Promise((resolve) => setTimeout(resolve, 5_000)),
+      ])
     } catch {
-      active.turn.close()
+      // interrupt() failed — force close
     }
-
-    this.activeTurns.delete(chatId)
-    this.onStateChange()
+    active.turn.close()
   }
 
   async respondTool(command: Extract<ClientCommand, { type: "chat.respondTool" }>) {

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

@@ -54,7 +54,7 @@ describe("read models", () => {
       lastTurnOutcome: null,
     })
 
-    const chat = deriveChatSnapshot(state, new Map(), "chat-1", () => [])
+    const chat = deriveChatSnapshot(state, new Map(), new Set(), "chat-1", () => [])
     expect(chat?.runtime.provider).toBe("claude")
     expect(chat?.availableProviders.length).toBeGreaterThan(1)
     expect(chat?.availableProviders.find((provider) => provider.id === "codex")?.models.map((model) => model.id)).toEqual([

package/src/server/read-models.ts

@@ -98,6 +98,7 @@ export function deriveLocalProjectsSnapshot(
 export function deriveChatSnapshot(
   state: StoreState,
   activeStatuses: Map<string, KannaStatus>,
+  drainingChatIds: Set<string>,
   chatId: string,
   getMessages: (chatId: string) => ChatSnapshot["messages"]
 ): ChatSnapshot | null {
@@ -112,6 +113,7 @@ export function deriveChatSnapshot(
     localPath: project.localPath,
     title: chat.title,
     status: deriveStatus(chat, activeStatuses.get(chat.id)),
+    isDraining: drainingChatIds.has(chat.id),
     provider: chat.provider,
     planMode: chat.planMode,
     sessionToken: chat.sessionToken,

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

@@ -41,7 +41,7 @@ describe("ws-router", () => {
   test("acks system.ping without broadcasting snapshots", () => {
     const router = createWsRouter({
       store: { state: createEmptyState() } as never,
-      agent: { getActiveStatuses: () => new Map() } as never,
+      agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set() } as never,
       terminals: {
         getSnapshot: () => null,
         onEvent: () => () => {},
@@ -80,7 +80,7 @@ describe("ws-router", () => {
   test("acks terminal.input without rebroadcasting terminal snapshots", () => {
     const router = createWsRouter({
       store: { state: createEmptyState() } as never,
-      agent: { getActiveStatuses: () => new Map() } as never,
+      agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set() } as never,
       terminals: {
         getSnapshot: () => null,
         onEvent: () => () => {},
@@ -124,7 +124,7 @@ describe("ws-router", () => {
   test("subscribes and unsubscribes chat topics", () => {
     const router = createWsRouter({
       store: { state: createEmptyState() } as never,
-      agent: { getActiveStatuses: () => new Map() } as never,
+      agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set() } as never,
       terminals: {
         getSnapshot: () => null,
         onEvent: () => () => {},
@@ -373,7 +373,7 @@ describe("ws-router", () => {
 
     const router = createWsRouter({
       store: { state: createEmptyState() } as never,
-      agent: { getActiveStatuses: () => new Map() } as never,
+      agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set() } as never,
       terminals: {
         getSnapshot: () => null,
         onEvent: () => () => {},
@@ -474,7 +474,7 @@ describe("ws-router", () => {
 
     const router = createWsRouter({
       store: { state: createEmptyState() } as never,
-      agent: { getActiveStatuses: () => new Map() } as never,
+      agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set() } as never,
       terminals: {
         getSnapshot: () => null,
         onEvent: () => () => {},

package/src/server/ws-router.ts

@@ -121,7 +121,7 @@ export function createWsRouter({
       id,
       snapshot: {
         type: "chat",
-        data: deriveChatSnapshot(store.state, agent.getActiveStatuses(), topic.chatId, (chatId) => store.getMessages(chatId)),
+        data: deriveChatSnapshot(store.state, agent.getActiveStatuses(), agent.getDrainingChatIds(), topic.chatId, (chatId) => store.getMessages(chatId)),
       },
     }
   }
@@ -258,6 +258,7 @@ export function createWsRouter({
           const project = store.getProject(command.projectId)
           for (const chat of store.listChatsByProject(command.projectId)) {
             await agent.cancel(chat.id)
+            await agent.closeChat(chat.id)
           }
           if (project) {
             terminals.closeByCwd(project.localPath)
@@ -283,6 +284,7 @@ export function createWsRouter({
         }
         case "chat.delete": {
           await agent.cancel(command.chatId)
+          await agent.closeChat(command.chatId)
           await store.deleteChat(command.chatId)
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
           break
@@ -302,6 +304,11 @@ export function createWsRouter({
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
           break
         }
+        case "chat.stopDraining": {
+          await agent.stopDraining(command.chatId)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          break
+        }
         case "chat.respondTool": {
           await agent.respondTool(command)
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })

package/src/shared/protocol.ts

@@ -76,6 +76,7 @@ export type ClientCommand =
       planMode?: boolean
     }
   | { type: "chat.cancel"; chatId: string }
+  | { type: "chat.stopDraining"; chatId: string }
   | { type: "chat.respondTool"; chatId: string; toolUseId: string; result: unknown }
   | { type: "terminal.create"; projectId: string; terminalId: string; cols: number; rows: number; scrollback: number }
   | { type: "terminal.input"; terminalId: string; data: string }

package/src/shared/types.ts

@@ -592,6 +592,7 @@ export interface ChatRuntime {
   localPath: string
   title: string
   status: KannaStatus
+  isDraining: boolean
   provider: AgentProvider | null
   planMode: boolean
   sessionToken: string | null