kanna-code 0.2.0 → 0.4.0

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

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test"
+import { PROTOCOL_VERSION } from "../shared/types"
+import { createEmptyState } from "./events"
+import { createWsRouter } from "./ws-router"
+
+class FakeWebSocket {
+  readonly sent: unknown[] = []
+  readonly data = {
+    subscriptions: new Map(),
+  }
+
+  send(message: string) {
+    this.sent.push(JSON.parse(message))
+  }
+}
+
+describe("ws-router", () => {
+  test("acks system.ping without broadcasting snapshots", () => {
+    const router = createWsRouter({
+      store: { state: createEmptyState() } as never,
+      agent: { getActiveStatuses: () => new Map() } as never,
+      refreshDiscovery: async () => [],
+      getDiscoveredProjects: () => [],
+      machineDisplayName: "Local Machine",
+    })
+    const ws = new FakeWebSocket()
+
+    ws.data.subscriptions.set("sub-1", { type: "sidebar" })
+    router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "ping-1",
+        command: { type: "system.ping" },
+      })
+    )
+
+    expect(ws.sent).toEqual([
+      {
+        v: PROTOCOL_VERSION,
+        type: "ack",
+        id: "ping-1",
+      },
+    ])
+  })
+})

package/src/server/ws-router.ts

@@ -89,6 +89,10 @@ export function createWsRouter({
     const { command, id } = message
     try {
       switch (command.type) {
+        case "system.ping": {
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          return
+        }
         case "project.open": {
           await ensureProjectDirectory(command.localPath)
           const project = await store.openProject(command.localPath)

package/src/shared/protocol.ts

@@ -9,6 +9,7 @@ export type ClientCommand =
   | { type: "project.open"; localPath: string }
   | { type: "project.create"; localPath: string; title: string }
   | { type: "project.remove"; projectId: string }
+  | { type: "system.ping" }
   | { type: "system.openExternal"; localPath: string; action: "open_finder" | "open_terminal" | "open_editor" }
   | { type: "chat.create"; projectId: string }
   | { type: "chat.rename"; chatId: string; title: string }

package/src/shared/tools.test.ts

@@ -62,7 +62,18 @@ describe("hydrateToolResult", () => {
     })
 
     const result = hydrateToolResult(tool, JSON.stringify({ answers: { runtime: "codex" } }))
-    expect(result).toEqual({ answers: { runtime: "codex" } })
+    expect(result).toEqual({ answers: { runtime: ["codex"] } })
+  })
+
+  test("hydrates AskUserQuestion multi-select answers", () => {
+    const tool = normalizeToolCall({
+      toolName: "AskUserQuestion",
+      toolId: "tool-1",
+      input: { questions: [] },
+    })
+
+    const result = hydrateToolResult(tool, JSON.stringify({ answers: { runtime: ["bun", "node"] } }))
+    expect(result).toEqual({ answers: { runtime: ["bun", "node"] } })
   })
 
   test("hydrates ExitPlanMode decisions", () => {

package/src/shared/tools.ts

@@ -1,5 +1,6 @@
 import type {
   AskUserQuestionItem,
+  AskUserQuestionAnswerMap,
   AskUserQuestionToolResult,
   ExitPlanModeToolResult,
   HydratedToolCall,
@@ -209,7 +210,23 @@ export function hydrateToolResult(tool: NormalizedToolCall, raw: unknown): Hydra
     case "ask_user_question": {
       const record = asRecord(parsed)
       const answers = asRecord(record?.answers) ?? (record ? record : {})
-      return { answers: Object.fromEntries(Object.entries(answers).map(([key, value]) => [key, String(value)])) } satisfies AskUserQuestionToolResult
+      return {
+        answers: Object.fromEntries(
+          Object.entries(answers).map(([key, value]) => {
+            if (Array.isArray(value)) {
+              return [key, value.map((entry) => String(entry))]
+            }
+            if (value && typeof value === "object" && Array.isArray((value as { answers?: unknown }).answers)) {
+              return [key, (value as { answers: unknown[] }).answers.map((entry) => String(entry))]
+            }
+            if (value == null || value === "") {
+              return [key, []]
+            }
+            return [key, [String(value)]]
+          })
+        ) as AskUserQuestionAnswerMap,
+        ...(record?.discarded === true ? { discarded: true } : {}),
+      } satisfies AskUserQuestionToolResult
     }
     case "exit_plan_mode": {
       const record = asRecord(parsed)
@@ -217,6 +234,7 @@ export function hydrateToolResult(tool: NormalizedToolCall, raw: unknown): Hydra
         confirmed: typeof record?.confirmed === "boolean" ? record.confirmed : undefined,
         clearContext: typeof record?.clearContext === "boolean" ? record.clearContext : undefined,
         message: typeof record?.message === "string" ? record.message : undefined,
+        ...(record?.discarded === true ? { discarded: true } : {}),
       } satisfies ExitPlanModeToolResult
     }
     case "read_file":

package/src/shared/types.ts

@@ -194,6 +194,8 @@ export interface AskUserQuestionItem {
   multiSelect?: boolean
 }
 
+export type AskUserQuestionAnswerMap = Record<string, string[]>
+
 export interface TodoItem {
   content: string
   status: "pending" | "in_progress" | "completed"
@@ -373,13 +375,15 @@ export interface HydratedToolCallBase<TKind extends string, TInput, TResult> {
 }
 
 export interface AskUserQuestionToolResult {
-  answers: Record<string, string>
+  answers: AskUserQuestionAnswerMap
+  discarded?: boolean
 }
 
 export interface ExitPlanModeToolResult {
   confirmed?: boolean
   clearContext?: boolean
   message?: string
+  discarded?: boolean
 }
 
 export type HydratedAskUserQuestionToolCall =