@cuongtran001/kanna 1.2.0 → 1.3.1

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

@@ -0,0 +1,279 @@
+/**
+ * ws-router-chat.ts
+ *
+ * WS command handlers for chat lifecycle operations:
+ *   chat.create, chat.fork, chat.rename, chat.archive, chat.unarchive,
+ *   chat.delete, chat.markRead, chat.setPolicyOverride, chat.setDraftProtection,
+ *   chat.send, chat.cancel, chat.stopDraining, chat.loadHistory,
+ *   chat.respondTool, chat.toolRequestAnswer,
+ *   chat.respondSubagentTool, chat.cancelSubagentRun
+ *
+ * Extracted from ws-router.ts.
+ */
+import { PROTOCOL_VERSION } from "../shared/types"
+import type { ChatHistoryPage, StackBinding } from "../shared/types"
+import { isRecord } from "../shared/errors"
+import type { ClientCommand, ServerEnvelope } from "../shared/protocol"
+import type { ChatPermissionPolicyOverride, ToolRequestDecision } from "../shared/permission-policy"
+
+// ---------------------------------------------------------------------------
+// Dep interfaces (duck-typed; avoids circular imports with ws-router.ts)
+// ---------------------------------------------------------------------------
+
+/** Subset of EventStore methods consumed by chat WS commands. */
+export interface ChatStoreDep {
+  createChat(
+    projectId: string,
+    opts?: { stackId?: string | null; stackBindings?: StackBinding[] },
+  ): Promise<{ id: string }>
+  renameChat(chatId: string, title: string): Promise<void>
+  archiveChat(chatId: string): Promise<void>
+  unarchiveChat(chatId: string): Promise<void>
+  deleteChat(chatId: string): Promise<void>
+  setChatReadState(chatId: string, unread: boolean): Promise<void>
+  setChatPolicyOverride(chatId: string, policyOverride: ChatPermissionPolicyOverride | null): Promise<void>
+  getChat(chatId: string): { id: string } | null | undefined
+  getMessagesPageBefore(chatId: string, beforeCursor: string, limit: number): ChatHistoryPage
+  getToolRequest(toolRequestId: string): { chatId: string } | undefined | null
+}
+
+/** Subset of ToolCallbackService methods consumed by chat WS commands. */
+export interface ChatToolCallbackServiceDep {
+  cancelAllForChat(chatId: string, reason: string): Promise<void>
+  answer(toolRequestId: string, decision: ToolRequestDecision): Promise<void>
+}
+
+/** Subset of AgentCoordinator methods consumed by chat WS commands. */
+export interface ChatAgentDep {
+  send(command: Extract<ClientCommand, { type: "chat.send" }>): Promise<{ chatId?: string | null }>
+  forkChat(chatId: string): Promise<unknown>
+  cancel(chatId: string): Promise<void>
+  cancelAutoContinue(chatId: string, scheduleId: string, reason: string): Promise<void>
+  listLiveSchedules(chatId: string): Iterable<string>
+  closeChat(chatId: string): Promise<void>
+  stopDraining(chatId: string): Promise<void>
+  respondTool(command: Extract<ClientCommand, { type: "chat.respondTool" }>): Promise<void>
+  respondSubagentTool(
+    command: Extract<ClientCommand, { type: "chat.respondSubagentTool" }>,
+  ): Promise<void>
+  cancelSubagentRun(
+    command: Extract<ClientCommand, { type: "chat.cancelSubagentRun" }>,
+  ): Promise<void>
+  getActiveTurnProfile(
+    chatId: string,
+  ): { traceId?: string | null; startedAt?: number | null } | null | undefined
+  toolCallbackService?: ChatToolCallbackServiceDep | null
+}
+
+/** Analytics subset consumed by chat WS commands. */
+export interface ChatAnalyticsDep {
+  track(event: string): void
+}
+
+/** Full deps bundle for chat WS commands. */
+export interface ChatCommandDeps {
+  store: ChatStoreDep
+  agent: ChatAgentDep
+  analytics: ChatAnalyticsDep
+  /**
+   * Mutate per-connection draft protection — wraps
+   * `ws.data.protectedDraftChatIds = new Set(chatIds)` at the call site.
+   */
+  setDraftProtection: (chatIds: string[]) => void
+  /**
+   * Send-to-starting profiling hook (no-op when profiling is disabled).
+   * Wraps `logSendToStartingProfile` at the call site.
+   */
+  logSendProfilingFn: (
+    traceId: string | null | undefined,
+    startedAt: number | null | undefined,
+    stage: string,
+    details?: Record<string, unknown>,
+  ) => void
+  /** Pre-bound to the current WebSocket; returns the byte count sent. */
+  send: (envelope: ServerEnvelope) => number
+  /** Broadcast a chat-specific snapshot + sidebar snapshot. */
+  broadcastChatAndSidebar: (chatId: string) => Promise<void>
+  /** Broadcast sidebar snapshot to all connected clients. */
+  broadcastSidebar: () => Promise<void>
+  /**
+   * Broadcast ALL snapshots to all connected clients.
+   * Used for the chat.setDraftProtection fall-through broadcast.
+   */
+  broadcastAll: () => Promise<void>
+}
+
+// ---------------------------------------------------------------------------
+// Command dispatcher
+// ---------------------------------------------------------------------------
+
+/**
+ * Handle one chat WS command.
+ *
+ * Returns `true` when the command was handled (caller should `return`).
+ * Returns `false` when the command type is outside this module's scope.
+ */
+export async function handleChatCommand(
+  deps: ChatCommandDeps,
+  command: ClientCommand,
+  id: string,
+): Promise<boolean> {
+  const {
+    store,
+    agent,
+    analytics,
+    setDraftProtection,
+    logSendProfilingFn,
+    send,
+    broadcastChatAndSidebar,
+    broadcastSidebar,
+    broadcastAll,
+  } = deps
+
+  switch (command.type) {
+    case "chat.create": {
+      const chat = await store.createChat(command.projectId, {
+        stackId: command.stackId,
+        stackBindings: command.stackBindings,
+      })
+      send({ v: PROTOCOL_VERSION, type: "ack", id, result: { chatId: chat.id } })
+      analytics.track("chat_created")
+      await broadcastChatAndSidebar(chat.id)
+      return true
+    }
+    case "chat.fork": {
+      const result = await agent.forkChat(command.chatId)
+      send({ v: PROTOCOL_VERSION, type: "ack", id, result })
+      await broadcastSidebar()
+      return true
+    }
+    case "chat.rename": {
+      await store.renameChat(command.chatId, command.title)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      await broadcastChatAndSidebar(command.chatId)
+      return true
+    }
+    case "chat.archive": {
+      await store.archiveChat(command.chatId)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      await broadcastSidebar()
+      return true
+    }
+    case "chat.unarchive": {
+      await store.unarchiveChat(command.chatId)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      await broadcastChatAndSidebar(command.chatId)
+      return true
+    }
+    case "chat.delete": {
+      await agent.cancel(command.chatId)
+      for (const scheduleId of agent.listLiveSchedules(command.chatId)) {
+        await agent.cancelAutoContinue(command.chatId, scheduleId, "chat_deleted")
+      }
+      await agent.closeChat(command.chatId)
+      if (agent.toolCallbackService) {
+        await agent.toolCallbackService.cancelAllForChat(command.chatId, "chat_deleted")
+      }
+      await store.deleteChat(command.chatId)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      analytics.track("chat_deleted")
+      await broadcastSidebar()
+      return true
+    }
+    case "chat.markRead": {
+      await store.setChatReadState(command.chatId, false)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      await broadcastChatAndSidebar(command.chatId)
+      return true
+    }
+    case "chat.setPolicyOverride": {
+      await store.setChatPolicyOverride(command.chatId, command.policyOverride ?? null)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      await broadcastChatAndSidebar(command.chatId)
+      return true
+    }
+    case "chat.setDraftProtection": {
+      setDraftProtection(command.chatIds)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      // Preserves the original break→broadcastSnapshots fall-through behavior.
+      await broadcastAll()
+      return true
+    }
+    case "chat.send": {
+      const result = await agent.send(command)
+      const profile = command.clientTraceId && result.chatId
+        ? agent.getActiveTurnProfile(result.chatId)
+        : null
+      logSendProfilingFn(profile?.traceId ?? command.clientTraceId, profile?.startedAt, "ws.chat_send_ack", {
+        chatId: result.chatId ?? null,
+      })
+      const payloadBytes = send({ v: PROTOCOL_VERSION, type: "ack", id, result })
+      logSendProfilingFn(profile?.traceId ?? command.clientTraceId, profile?.startedAt, "ws.chat_send_ack_completed", {
+        chatId: result.chatId ?? null,
+        payloadBytes,
+      })
+      return true
+    }
+    case "chat.cancel": {
+      await agent.cancel(command.chatId)
+      // Resolve any open ask-style tool-callback prompts for this chat
+      // so the model's tool_use does not hang on a stranded pending. The
+      // session-close path no longer fires this cascade because it also
+      // ran on transparent respawns (rotation / idle sweep) — see
+      // makeClaudeSessionHandle.close() in agent.ts.
+      if (agent.toolCallbackService) {
+        await agent.toolCallbackService.cancelAllForChat(command.chatId, "chat_cancelled")
+      }
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      return true
+    }
+    case "chat.stopDraining": {
+      await agent.stopDraining(command.chatId)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      return true
+    }
+    case "chat.loadHistory": {
+      const chat = store.getChat(command.chatId)
+      if (!chat) throw new Error("Chat not found")
+      const page = store.getMessagesPageBefore(command.chatId, command.beforeCursor, command.limit)
+      send({ v: PROTOCOL_VERSION, type: "ack", id, result: page })
+      return true
+    }
+    case "chat.respondTool": {
+      await agent.respondTool(command)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      return true
+    }
+    case "chat.toolRequestAnswer": {
+      const toolCallbackSvc = agent.toolCallbackService
+      if (!toolCallbackSvc) throw new Error("tool callback service unavailable")
+      const validKinds = new Set(["allow", "deny", "answer"])
+      if (
+        !isRecord(command.decision) ||
+        !validKinds.has(typeof command.decision.kind === "string" ? command.decision.kind : "")
+      ) {
+        throw new Error("Invalid tool request decision kind")
+      }
+      const existing = store.getToolRequest(command.toolRequestId)
+      if (!existing || existing.chatId !== command.chatId) {
+        throw new Error("Tool request does not belong to this chat")
+      }
+      await toolCallbackSvc.answer(command.toolRequestId, command.decision)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      await broadcastChatAndSidebar(command.chatId)
+      return true
+    }
+    case "chat.respondSubagentTool": {
+      await agent.respondSubagentTool(command)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      return true
+    }
+    case "chat.cancelSubagentRun": {
+      await agent.cancelSubagentRun(command)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      return true
+    }
+    default:
+      return false
+  }
+}

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

@@ -0,0 +1,283 @@
+import { describe, expect, test } from "bun:test"
+import {
+  buildFallbackDiffStore,
+  buildFallbackLlmProvider,
+  buildInitialAppSettingsSnapshot,
+  buildResolvedAppSettings,
+  mergeAppSettingsPatch,
+} from "./ws-router-defaults"
+import type { AppSettingsSnapshot, SubagentInput } from "../shared/types"
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeSnapshot(): AppSettingsSnapshot {
+  return buildInitialAppSettingsSnapshot()
+}
+
+const BASE_SUBAGENT_INPUT: SubagentInput = {
+  name: "Bot",
+  description: "",
+  provider: "claude",
+  model: "claude-opus-4-7",
+  systemPrompt: "",
+  modelOptions: { reasoningEffort: "high", contextWindow: "200k" },
+  contextScope: "full-transcript",
+}
+
+// ---------------------------------------------------------------------------
+// mergeAppSettingsPatch
+// ---------------------------------------------------------------------------
+
+describe("mergeAppSettingsPatch", () => {
+  test("subagents.create appends a new subagent with generated id and trims name", () => {
+    const snapshot = makeSnapshot()
+    const result = mergeAppSettingsPatch(snapshot, {
+      subagents: {
+        create: { ...BASE_SUBAGENT_INPUT, name: "  My Bot  ", triggerMode: "manual" },
+      },
+    })
+    expect(result.subagents).toHaveLength(1)
+    const s = result.subagents[0]
+    expect(s).toBeDefined()
+    if (!s) return
+    expect(s.name).toBe("My Bot") // trimmed
+    expect(s.triggerMode).toBe("manual")
+    expect(typeof s.id).toBe("string")
+    expect(s.id.length).toBeGreaterThan(0)
+  })
+
+  test("subagents.create defaults triggerMode to 'auto' when omitted", () => {
+    const snapshot = makeSnapshot()
+    const result = mergeAppSettingsPatch(snapshot, {
+      subagents: { create: BASE_SUBAGENT_INPUT },
+    })
+    expect(result.subagents[0]?.triggerMode).toBe("auto")
+  })
+
+  test("subagents.update patches matching subagent name", () => {
+    const withSubagent = mergeAppSettingsPatch(makeSnapshot(), {
+      subagents: { create: BASE_SUBAGENT_INPUT },
+    })
+    const id = withSubagent.subagents[0]!.id
+    const updated = mergeAppSettingsPatch(withSubagent, {
+      subagents: { update: { id, patch: { name: "New Name" } } },
+    })
+    expect(updated.subagents[0]?.name).toBe("New Name")
+  })
+
+  test("subagents.delete removes the matching subagent", () => {
+    const withSubagent = mergeAppSettingsPatch(makeSnapshot(), {
+      subagents: { create: BASE_SUBAGENT_INPUT },
+    })
+    const id = withSubagent.subagents[0]!.id
+    const result = mergeAppSettingsPatch(withSubagent, { subagents: { delete: { id } } })
+    expect(result.subagents).toHaveLength(0)
+  })
+
+  test("terminal and editor are deep-merged (unset fields preserved)", () => {
+    const snapshot = makeSnapshot()
+    const result = mergeAppSettingsPatch(snapshot, {
+      terminal: { scrollbackLines: 2_000 },
+      editor: { preset: "vscode" },
+    })
+    expect(result.terminal.scrollbackLines).toBe(2_000)
+    expect(result.terminal.minColumnWidth).toBe(450) // preserved from base
+    expect(result.editor.preset).toBe("vscode")
+    expect(result.editor.commandTemplate).toBe("cursor {path}") // preserved from base
+  })
+
+  test("providerDefaults.claude modelOptions are deep-merged", () => {
+    const snapshot = makeSnapshot()
+    const result = mergeAppSettingsPatch(snapshot, {
+      providerDefaults: {
+        claude: { modelOptions: { reasoningEffort: "low", contextWindow: "200k" } },
+      },
+    })
+    expect(result.providerDefaults.claude.modelOptions.reasoningEffort).toBe("low")
+    // contextWindow preserved since we included it in the patch
+    expect(result.providerDefaults.claude.modelOptions.contextWindow).toBe("200k")
+    // unrelated provider unchanged
+    expect(result.providerDefaults.codex.modelOptions.reasoningEffort).toBe("high")
+  })
+
+  test("claudeDriver lifecycle is deep-merged and preference is preserved", () => {
+    const snapshot = makeSnapshot()
+    const result = mergeAppSettingsPatch(snapshot, {
+      claudeDriver: { lifecycle: { idleTimeoutMs: 9_000 } },
+    })
+    expect(result.claudeDriver.preference).toBe(snapshot.claudeDriver.preference)
+    expect(result.claudeDriver.lifecycle).toMatchObject({ idleTimeoutMs: 9_000 })
+  })
+
+  test("subagentRuntime.defaultLoopSubagentId null clears the value", () => {
+    const snapshot = {
+      ...makeSnapshot(),
+      subagentRuntime: { runTimeoutMs: 600_000, defaultLoopSubagentId: "abc" },
+    }
+    const result = mergeAppSettingsPatch(snapshot, {
+      subagentRuntime: { defaultLoopSubagentId: null },
+    })
+    expect(result.subagentRuntime.defaultLoopSubagentId).toBeNull()
+  })
+
+  test("returns a new snapshot object (does not mutate input)", () => {
+    const snapshot = makeSnapshot()
+    const result = mergeAppSettingsPatch(snapshot, { analyticsEnabled: false })
+    expect(result).not.toBe(snapshot)
+    expect(snapshot.analyticsEnabled).toBe(true) // original unchanged
+    expect(result.analyticsEnabled).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// buildFallbackDiffStore
+// ---------------------------------------------------------------------------
+
+describe("buildFallbackDiffStore", () => {
+  test("returns an object with all required DiffStore methods", () => {
+    const store = buildFallbackDiffStore()
+    const methods = [
+      "getProjectSnapshot", "refreshSnapshot", "initializeGit",
+      "getGitHubPublishInfo", "checkGitHubRepoAvailability", "publishToGitHub",
+      "listBranches", "previewMergeBranch", "mergeBranch", "syncBranch",
+      "checkoutBranch", "createBranch", "generateCommitMessage", "commitFiles",
+      "discardFile", "ignoreFile", "readPatch",
+    ] as const
+    for (const m of methods) {
+      expect(typeof store[m]).toBe("function")
+    }
+  })
+
+  test("getProjectSnapshot returns an unknown status with empty files", () => {
+    const store = buildFallbackDiffStore()
+    const snap = store.getProjectSnapshot("any-project-id")
+    expect(snap.status).toBe("unknown")
+    expect(snap.files).toEqual([])
+  })
+
+  test("listBranches resolves with empty arrays and unavailable pullRequestsStatus", async () => {
+    const result = await buildFallbackDiffStore().listBranches()
+    expect(result.recent).toEqual([])
+    expect(result.pullRequestsStatus).toBe("unavailable")
+  })
+
+  test("readPatch resolves with empty patch string", async () => {
+    const result = await buildFallbackDiffStore().readPatch()
+    expect(result.patch).toBe("")
+  })
+})
+
+// ---------------------------------------------------------------------------
+// buildFallbackLlmProvider
+// ---------------------------------------------------------------------------
+
+describe("buildFallbackLlmProvider", () => {
+  test("returns an object with read, write, validate methods", () => {
+    const provider = buildFallbackLlmProvider()
+    expect(typeof provider.read).toBe("function")
+    expect(typeof provider.write).toBe("function")
+    expect(typeof provider.validate).toBe("function")
+  })
+
+  test("read resolves with disabled openai shape", async () => {
+    const snap = await buildFallbackLlmProvider().read()
+    expect(snap.provider).toBe("openai")
+    expect(snap.enabled).toBe(false)
+    expect(snap.resolvedBaseUrl).toBe("https://api.openai.com/v1")
+  })
+
+  test("write computes resolvedBaseUrl for openrouter", async () => {
+    const snap = await buildFallbackLlmProvider().write({
+      provider: "openrouter",
+      apiKey: "k",
+      model: "m",
+      baseUrl: "",
+    })
+    expect(snap.resolvedBaseUrl).toBe("https://openrouter.ai/api/v1")
+  })
+
+  test("write uses custom baseUrl for 'custom' provider", async () => {
+    const snap = await buildFallbackLlmProvider().write({
+      provider: "custom",
+      apiKey: "",
+      model: "m",
+      baseUrl: "https://my-endpoint.example.com/v1",
+    })
+    expect(snap.resolvedBaseUrl).toBe("https://my-endpoint.example.com/v1")
+  })
+
+  test("validate always returns ok:false", async () => {
+    const result = await buildFallbackLlmProvider().validate({
+      provider: "openai",
+      apiKey: "k",
+      model: "m",
+      baseUrl: "",
+    })
+    expect(result.ok).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// buildResolvedAppSettings
+// ---------------------------------------------------------------------------
+
+describe("buildResolvedAppSettings", () => {
+  test("getSnapshot returns built-in fallback when no appSettings provided", () => {
+    const resolved = buildResolvedAppSettings(undefined)
+    const snap = resolved.getSnapshot()
+    expect(snap.analyticsEnabled).toBe(true)
+    expect(snap.subagents).toEqual([])
+    expect(snap.customMcpServers).toEqual([])
+  })
+
+  test("writePatch mutates the in-memory fallback when no appSettings", async () => {
+    const resolved = buildResolvedAppSettings(undefined)
+    expect(resolved.getSnapshot().analyticsEnabled).toBe(true)
+    const after = await resolved.writePatch({ analyticsEnabled: false })
+    expect(after.analyticsEnabled).toBe(false)
+    // getSnapshot reflects the mutation
+    expect(resolved.getSnapshot().analyticsEnabled).toBe(false)
+  })
+
+  test("onChange returns callable noop when no appSettings", () => {
+    const resolved = buildResolvedAppSettings(undefined)
+    const dispose = resolved.onChange(() => {})
+    expect(typeof dispose).toBe("function")
+    expect(() => dispose()).not.toThrow()
+  })
+
+  test("getSnapshot delegates to real appSettings when provided", () => {
+    const mockSnapshot = { ...makeSnapshot(), analyticsEnabled: false }
+    const fakeManager = { getSnapshot: () => mockSnapshot, write: async () => mockSnapshot }
+    const resolved = buildResolvedAppSettings(fakeManager)
+    expect(resolved.getSnapshot().analyticsEnabled).toBe(false)
+  })
+
+  test("createSubagent falls back to writePatch when manager lacks createSubagent", async () => {
+    const resolved = buildResolvedAppSettings(undefined)
+    const result = await resolved.createSubagent({ ...BASE_SUBAGENT_INPUT, name: "FallbackBot" })
+    // Should be the newly created subagent, not a NOT_FOUND error
+    if ("code" in result) {
+      throw new Error(`Expected subagent but got error: ${result.message}`)
+    }
+    expect(result.name).toBe("FallbackBot")
+    expect(resolved.getSnapshot().subagents).toHaveLength(1)
+  })
+
+  test("write delegates to real appSettings when provided", async () => {
+    let written: { analyticsEnabled: boolean } | null = null
+    const mockSnapshot = makeSnapshot()
+    const fakeManager = {
+      getSnapshot: () => mockSnapshot,
+      write: async (value: { analyticsEnabled: boolean }) => {
+        written = value
+        return mockSnapshot
+      },
+    }
+    const resolved = buildResolvedAppSettings(fakeManager)
+    await resolved.write({ analyticsEnabled: false })
+    expect(written!).toEqual({ analyticsEnabled: false })
+  })
+})