kanna-code 0.3.0 → 0.4.1

package/src/server/discovery.ts

@@ -4,8 +4,6 @@ import path from "node:path"
 import type { AgentProvider } from "../shared/types"
 import { resolveLocalPath } from "./paths"
 
-const LOG_PREFIX = "[kanna discovery]"
-
 export interface DiscoveredProject {
   localPath: string
   title: string
@@ -91,23 +89,18 @@ export class ClaudeProjectDiscoveryAdapter implements ProjectDiscoveryAdapter {
   scan(homeDir: string = homedir()): ProviderDiscoveredProject[] {
     const projectsDir = path.join(homeDir, ".claude", "projects")
     if (!existsSync(projectsDir)) {
-      console.log(`${LOG_PREFIX} provider=claude status=missing root=${projectsDir}`)
       return []
     }
 
     const entries = readdirSync(projectsDir, { withFileTypes: true })
     const projects: ProviderDiscoveredProject[] = []
-    let directoryEntries = 0
-    let skippedMissing = 0
 
     for (const entry of entries) {
       if (!entry.isDirectory()) continue
-      directoryEntries += 1
 
       const resolvedPath = resolveEncodedClaudePath(entry.name)
       const normalizedPath = normalizeExistingDirectory(resolvedPath)
       if (!normalizedPath) {
-        skippedMissing += 1
         continue
       }
 
@@ -125,10 +118,6 @@ export class ClaudeProjectDiscoveryAdapter implements ProjectDiscoveryAdapter {
       ...project,
     }))
 
-    console.log(
-      `${LOG_PREFIX} provider=claude scanned=${directoryEntries} valid=${projects.length} deduped=${mergedProjects.length} skipped_missing=${skippedMissing} samples=${mergedProjects.slice(0, 5).map((project) => project.localPath).join(", ") || "-"}`
-    )
-
     return mergedProjects
   }
 }
@@ -244,36 +233,19 @@ export class CodexProjectDiscoveryAdapter implements ProjectDiscoveryAdapter {
     const metadataById = readCodexSessionMetadata(sessionsDir)
     const configuredProjects = readCodexConfiguredProjects(configPath)
     const projects: ProviderDiscoveredProject[] = []
-    let skippedMissingMeta = 0
-    let skippedRelative = 0
-    let skippedMissingPath = 0
-    let fallbackSessionTimestamps = 0
-    let configProjectsIncluded = 0
-
-    if (!existsSync(indexPath) || !existsSync(sessionsDir) || !existsSync(configPath)) {
-      console.log(
-        `${LOG_PREFIX} provider=codex status=missing index_exists=${existsSync(indexPath)} sessions_exists=${existsSync(sessionsDir)} config_exists=${existsSync(configPath)}`
-      )
-    }
 
     for (const [sessionId, metadata] of metadataById.entries()) {
       const modifiedAt = updatedAtById.get(sessionId) ?? metadata.modifiedAt
       const cwd = metadata.cwd
-      if (!updatedAtById.has(sessionId)) {
-        fallbackSessionTimestamps += 1
-      }
       if (!cwd) {
-        skippedMissingMeta += 1
         continue
       }
       if (!path.isAbsolute(cwd)) {
-        skippedRelative += 1
         continue
       }
 
       const normalizedPath = normalizeExistingDirectory(cwd)
       if (!normalizedPath) {
-        skippedMissingPath += 1
         continue
       }
 
@@ -287,17 +259,14 @@ export class CodexProjectDiscoveryAdapter implements ProjectDiscoveryAdapter {
 
     for (const [configuredPath, modifiedAt] of configuredProjects.entries()) {
       if (!path.isAbsolute(configuredPath)) {
-        skippedRelative += 1
         continue
       }
 
       const normalizedPath = normalizeExistingDirectory(configuredPath)
       if (!normalizedPath) {
-        skippedMissingPath += 1
         continue
       }
 
-      configProjectsIncluded += 1
       projects.push({
         provider: this.provider,
         localPath: normalizedPath,
@@ -311,10 +280,6 @@ export class CodexProjectDiscoveryAdapter implements ProjectDiscoveryAdapter {
       ...project,
     }))
 
-    console.log(
-      `${LOG_PREFIX} provider=codex indexed_sessions=${updatedAtById.size} session_meta=${metadataById.size} config_projects=${configuredProjects.size} valid=${projects.length} deduped=${mergedProjects.length} fallback_session_timestamps=${fallbackSessionTimestamps} config_projects_included=${configProjectsIncluded} skipped_missing_meta=${skippedMissingMeta} skipped_relative=${skippedRelative} skipped_missing_path=${skippedMissingPath} samples=${mergedProjects.slice(0, 5).map((project) => project.localPath).join(", ") || "-"}`
-    )
-
     return mergedProjects
   }
 }
@@ -332,9 +297,5 @@ export function discoverProjects(
     adapters.flatMap((adapter) => adapter.scan(homeDir).map(({ provider: _provider, ...project }) => project))
   )
 
-  console.log(
-    `${LOG_PREFIX} aggregate providers=${adapters.map((adapter) => adapter.provider).join(",")} total=${mergedProjects.length} samples=${mergedProjects.slice(0, 10).map((project) => project.localPath).join(", ") || "-"}`
-  )
-
   return mergedProjects
 }

package/src/server/server.ts

@@ -8,10 +8,12 @@ import { createWsRouter, type ClientState } from "./ws-router"
 
 export interface StartKannaServerOptions {
   port?: number
+  strictPort?: boolean
 }
 
 export async function startKannaServer(options: StartKannaServerOptions = {}) {
   const port = options.port ?? 3210
+  const strictPort = options.strictPort ?? false
   const store = new EventStore()
   const machineDisplayName = getMachineDisplayName()
   await store.initialize()
@@ -83,7 +85,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
     } catch (err: unknown) {
       const isAddrInUse =
         err instanceof Error && "code" in err && (err as NodeJS.ErrnoException).code === "EADDRINUSE"
-      if (!isAddrInUse || attempt === MAX_PORT_ATTEMPTS - 1) {
+      if (!isAddrInUse || strictPort || attempt === MAX_PORT_ATTEMPTS - 1) {
         throw err
       }
       console.log(`Port ${actualPort} is in use, trying ${actualPort + 1}...`)

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 =