kanna-code 0.9.1 → 0.11.0

package/src/server/keybindings.test.ts

@@ -0,0 +1,132 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtemp, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { DEFAULT_KEYBINDINGS } from "../shared/types"
+import { KeybindingsManager, normalizeKeybindings, readKeybindingsSnapshot } from "./keybindings"
+
+let tempDirs: string[] = []
+const TEST_FILE_PATH = "/tmp/kanna-test-keybindings.json"
+
+afterEach(async () => {
+  await Promise.all(tempDirs.map((dir) => rm(dir, { recursive: true, force: true })))
+  tempDirs = []
+})
+
+async function createTempFilePath() {
+  const dir = await mkdtemp(path.join(tmpdir(), "kanna-keybindings-"))
+  tempDirs.push(dir)
+  return path.join(dir, "keybindings.json")
+}
+
+describe("normalizeKeybindings", () => {
+  test("falls back to defaults for invalid entries", () => {
+    const snapshot = normalizeKeybindings({
+      toggleEmbeddedTerminal: [],
+      toggleRightSidebar: "Ctrl+B",
+    }, TEST_FILE_PATH)
+
+    expect(snapshot.bindings).toEqual(DEFAULT_KEYBINDINGS)
+    expect(snapshot.warning).toContain("toggleEmbeddedTerminal")
+    expect(snapshot.warning).toContain("toggleRightSidebar")
+  })
+
+  test("keeps valid shortcut arrays", () => {
+    const snapshot = normalizeKeybindings({
+      toggleEmbeddedTerminal: [" Cmd+K ", "Ctrl+`"],
+      toggleRightSidebar: ["Ctrl+Shift+B"],
+      openInFinder: ["Cmd+Alt+F"],
+      openInEditor: ["Cmd+Shift+O"],
+      addSplitTerminal: ["Cmd+Shift+J"],
+    }, TEST_FILE_PATH)
+
+    expect(snapshot).toEqual({
+      bindings: {
+        toggleEmbeddedTerminal: ["cmd+k", "ctrl+`"],
+        toggleRightSidebar: ["ctrl+shift+b"],
+        openInFinder: ["cmd+alt+f"],
+        openInEditor: ["cmd+shift+o"],
+        addSplitTerminal: ["cmd+shift+j"],
+      },
+      warning: null,
+      filePathDisplay: TEST_FILE_PATH,
+    })
+  })
+})
+
+describe("readKeybindingsSnapshot", () => {
+  test("returns defaults when the file does not exist", async () => {
+    const filePath = await createTempFilePath()
+    const snapshot = await readKeybindingsSnapshot(filePath)
+    expect(snapshot).toEqual({
+      bindings: DEFAULT_KEYBINDINGS,
+      warning: null,
+      filePathDisplay: filePath,
+    })
+  })
+
+  test("returns a warning when the file contains invalid json", async () => {
+    const filePath = await createTempFilePath()
+    await writeFile(filePath, "{not-json", "utf8")
+
+    const snapshot = await readKeybindingsSnapshot(filePath)
+    expect(snapshot.bindings).toEqual(DEFAULT_KEYBINDINGS)
+    expect(snapshot.warning).toContain("invalid JSON")
+  })
+})
+
+describe("KeybindingsManager", () => {
+  test("creates the keybindings file with defaults during initialization", async () => {
+    const filePath = await createTempFilePath()
+    const manager = new KeybindingsManager(filePath)
+
+    await manager.initialize()
+
+    expect(await Bun.file(filePath).json()).toEqual(DEFAULT_KEYBINDINGS)
+    manager.dispose()
+  })
+
+  test("writes normalized bindings to disk", async () => {
+    const filePath = await createTempFilePath()
+    const manager = new KeybindingsManager(filePath)
+
+    await manager.initialize()
+    const snapshot = await manager.write({
+      toggleEmbeddedTerminal: ["Cmd+K"],
+      toggleRightSidebar: ["Ctrl+Shift+B"],
+      openInFinder: ["Cmd+Alt+F"],
+      openInEditor: ["Cmd+Shift+O"],
+      addSplitTerminal: ["Cmd+Shift+J"],
+    })
+
+    expect(snapshot).toEqual({
+      bindings: {
+        toggleEmbeddedTerminal: ["cmd+k"],
+        toggleRightSidebar: ["ctrl+shift+b"],
+        openInFinder: ["cmd+alt+f"],
+        openInEditor: ["cmd+shift+o"],
+        addSplitTerminal: ["cmd+shift+j"],
+      },
+      warning: null,
+      filePathDisplay: filePath,
+    })
+    expect(JSON.parse(await Bun.file(filePath).text())).toEqual(snapshot.bindings)
+
+    manager.dispose()
+  })
+
+  test("uses the runtime profile for the default keybindings path", () => {
+    const previous = process.env.KANNA_RUNTIME_PROFILE
+    process.env.KANNA_RUNTIME_PROFILE = "dev"
+
+    const manager = new KeybindingsManager()
+
+    expect(manager.filePath).toEndWith("/.kanna-dev/keybindings.json")
+
+    if (previous === undefined) {
+      delete process.env.KANNA_RUNTIME_PROFILE
+    } else {
+      process.env.KANNA_RUNTIME_PROFILE = previous
+    }
+  })
+})

package/src/server/keybindings.ts

@@ -0,0 +1,175 @@
+import { watch, type FSWatcher } from "node:fs"
+import { mkdir, readFile, writeFile } from "node:fs/promises"
+import { homedir } from "node:os"
+import path from "node:path"
+import { getKeybindingsFilePath, LOG_PREFIX } from "../shared/branding"
+import { DEFAULT_KEYBINDINGS, type KeybindingAction, type KeybindingsSnapshot } from "../shared/types"
+
+const KEYBINDING_ACTIONS = Object.keys(DEFAULT_KEYBINDINGS) as KeybindingAction[]
+
+type KeybindingsFile = Partial<Record<KeybindingAction, unknown>>
+
+export class KeybindingsManager {
+  readonly filePath: string
+  private watcher: FSWatcher | null = null
+  private snapshot: KeybindingsSnapshot
+  private readonly listeners = new Set<(snapshot: KeybindingsSnapshot) => void>()
+
+  constructor(filePath = getKeybindingsFilePath(homedir())) {
+    this.filePath = filePath
+    this.snapshot = createDefaultSnapshot(this.filePath)
+  }
+
+  async initialize() {
+    await mkdir(path.dirname(this.filePath), { recursive: true })
+    const file = Bun.file(this.filePath)
+    if (!(await file.exists())) {
+      await writeFile(this.filePath, `${JSON.stringify(DEFAULT_KEYBINDINGS, null, 2)}\n`, "utf8")
+    }
+    await this.reload()
+    this.startWatching()
+  }
+
+  dispose() {
+    this.watcher?.close()
+    this.watcher = null
+    this.listeners.clear()
+  }
+
+  getSnapshot() {
+    return this.snapshot
+  }
+
+  onChange(listener: (snapshot: KeybindingsSnapshot) => void) {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  async reload() {
+    const nextSnapshot = await readKeybindingsSnapshot(this.filePath)
+    this.setSnapshot(nextSnapshot)
+  }
+
+  async write(bindings: Partial<Record<KeybindingAction, string[]>>) {
+    const nextSnapshot = normalizeKeybindings(bindings, this.filePath)
+    await mkdir(path.dirname(this.filePath), { recursive: true })
+    await writeFile(this.filePath, `${JSON.stringify(nextSnapshot.bindings, null, 2)}\n`, "utf8")
+    this.setSnapshot(nextSnapshot)
+    return nextSnapshot
+  }
+
+  private setSnapshot(snapshot: KeybindingsSnapshot) {
+    this.snapshot = snapshot
+    for (const listener of this.listeners) {
+      listener(snapshot)
+    }
+  }
+
+  private startWatching() {
+    this.watcher?.close()
+    try {
+      this.watcher = watch(path.dirname(this.filePath), { persistent: false }, (_eventType, filename) => {
+        if (filename && filename !== path.basename(this.filePath)) {
+          return
+        }
+        void this.reload().catch((error: unknown) => {
+          console.warn(`${LOG_PREFIX} Failed to reload keybindings:`, error)
+        })
+      })
+    } catch (error) {
+      console.warn(`${LOG_PREFIX} Failed to watch keybindings file:`, error)
+      this.watcher = null
+    }
+  }
+}
+
+export async function readKeybindingsSnapshot(filePath: string) {
+  try {
+    const text = await readFile(filePath, "utf8")
+    if (!text.trim()) {
+      return createDefaultSnapshot(filePath, "Keybindings file was empty. Using defaults.")
+    }
+    const parsed = JSON.parse(text) as KeybindingsFile
+    return normalizeKeybindings(parsed, filePath)
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code === "ENOENT") {
+      return createDefaultSnapshot(filePath)
+    }
+
+    if (error instanceof SyntaxError) {
+      return createDefaultSnapshot(filePath, "Keybindings file is invalid JSON. Using defaults.")
+    }
+
+    throw error
+  }
+}
+
+export function normalizeKeybindings(value: KeybindingsFile | null | undefined, filePath = getKeybindingsFilePath(homedir())): KeybindingsSnapshot {
+  const warnings: string[] = []
+  const source = value && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null
+
+  if (!source) {
+    return createDefaultSnapshot(filePath, "Keybindings file must contain a JSON object. Using defaults.")
+  }
+
+  const bindings = {} as Record<KeybindingAction, string[]>
+  for (const action of KEYBINDING_ACTIONS) {
+    const rawValue = source[action]
+    if (!Array.isArray(rawValue)) {
+      bindings[action] = [...DEFAULT_KEYBINDINGS[action]]
+      if (rawValue !== undefined) {
+        warnings.push(`${action} must be an array of shortcut strings`)
+      }
+      continue
+    }
+
+    const normalized = rawValue
+      .filter((entry): entry is string => typeof entry === "string")
+      .map((entry) => entry.trim())
+      .map((entry) => entry.toLowerCase())
+      .filter(Boolean)
+
+    if (normalized.length === 0) {
+      bindings[action] = [...DEFAULT_KEYBINDINGS[action]]
+      if (rawValue.length > 0 || source[action] !== undefined) {
+        warnings.push(`${action} did not contain any valid shortcut strings`)
+      }
+      continue
+    }
+
+    bindings[action] = normalized
+  }
+
+  return {
+    bindings,
+    warning: warnings.length > 0 ? `Some keybindings were reset to defaults: ${warnings.join("; ")}` : null,
+    filePathDisplay: formatDisplayPath(filePath),
+  }
+}
+
+function createDefaultSnapshot(filePath: string, warning: string | null = null): KeybindingsSnapshot {
+  return {
+    bindings: {
+      toggleEmbeddedTerminal: [...DEFAULT_KEYBINDINGS.toggleEmbeddedTerminal],
+      toggleRightSidebar: [...DEFAULT_KEYBINDINGS.toggleRightSidebar],
+      openInFinder: [...DEFAULT_KEYBINDINGS.openInFinder],
+      openInEditor: [...DEFAULT_KEYBINDINGS.openInEditor],
+      addSplitTerminal: [...DEFAULT_KEYBINDINGS.addSplitTerminal],
+    },
+    warning,
+    filePathDisplay: formatDisplayPath(filePath),
+  }
+}
+
+function formatDisplayPath(filePath: string) {
+  const homePath = homedir()
+  if (filePath === homePath) return "~"
+  if (filePath.startsWith(`${homePath}${path.sep}`)) {
+    return `~${filePath.slice(homePath.length)}`
+  }
+  return filePath
+}

package/src/server/server.ts

@@ -3,7 +3,7 @@ import { APP_NAME } from "../shared/branding"
 import { EventStore } from "./event-store"
 import { AgentCoordinator } from "./agent"
 import { discoverProjects, type DiscoveredProject } from "./discovery"
-import { FileTreeManager } from "./file-tree-manager"
+import { KeybindingsManager } from "./keybindings"
 import { getMachineDisplayName } from "./machine-name"
 import { TerminalManager } from "./terminal-manager"
 import { createWsRouter, type ClientState } from "./ws-router"
@@ -31,9 +31,8 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   let server: ReturnType<typeof Bun.serve<ClientState>>
   let router: ReturnType<typeof createWsRouter>
   const terminals = new TerminalManager()
-  const fileTree = new FileTreeManager({
-    getProject: (projectId) => store.getProject(projectId),
-  })
+  const keybindings = new KeybindingsManager()
+  await keybindings.initialize()
   const agent = new AgentCoordinator({
     store,
     onStateChange: () => {
@@ -44,7 +43,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
     store,
     agent,
     terminals,
-    fileTree,
+    keybindings,
     refreshDiscovery,
     getDiscoveredProjects: () => discoveredProjects,
     machineDisplayName,
@@ -106,7 +105,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
       await agent.cancel(chatId)
     }
     router.dispose()
-    fileTree.dispose()
+    keybindings.dispose()
     terminals.closeAll()
     await store.compact()
     server.stop(true)

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

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test"
+import type { KeybindingsSnapshot } from "../shared/types"
 import { PROTOCOL_VERSION } from "../shared/types"
 import { createEmptyState } from "./events"
 import { createWsRouter } from "./ws-router"
@@ -14,6 +15,18 @@ class FakeWebSocket {
   }
 }
 
+const DEFAULT_KEYBINDINGS_SNAPSHOT: KeybindingsSnapshot = {
+  bindings: {
+    toggleEmbeddedTerminal: ["cmd+j", "ctrl+`"],
+    toggleRightSidebar: ["ctrl+b"],
+    openInFinder: ["cmd+alt+f"],
+    openInEditor: ["cmd+shift+o"],
+    addSplitTerminal: ["cmd+shift+j"],
+  },
+  warning: null,
+  filePathDisplay: "~/.kanna/keybindings.json",
+}
+
 describe("ws-router", () => {
   test("acks system.ping without broadcasting snapshots", () => {
     const router = createWsRouter({
@@ -23,9 +36,9 @@ describe("ws-router", () => {
         getSnapshot: () => null,
         onEvent: () => () => {},
       } as never,
-      fileTree: {
-        getSnapshot: () => ({ projectId: "project-1", rootPath: "/tmp/project-1", pageSize: 200, supportsRealtime: true }),
-        onInvalidate: () => () => {},
+      keybindings: {
+        getSnapshot: () => DEFAULT_KEYBINDINGS_SNAPSHOT,
+        onChange: () => () => {},
       } as never,
       refreshDiscovery: async () => [],
       getDiscoveredProjects: () => [],
@@ -62,9 +75,9 @@ describe("ws-router", () => {
         onEvent: () => () => {},
         write: () => {},
       } as never,
-      fileTree: {
-        getSnapshot: () => ({ projectId: "project-1", rootPath: "/tmp/project-1", pageSize: 200, supportsRealtime: true }),
-        onInvalidate: () => () => {},
+      keybindings: {
+        getSnapshot: () => DEFAULT_KEYBINDINGS_SNAPSHOT,
+        onChange: () => () => {},
       } as never,
       refreshDiscovery: async () => [],
       getDiscoveredProjects: () => [],
@@ -96,31 +109,7 @@ describe("ws-router", () => {
     ])
   })
 
-  test("subscribes and unsubscribes file-tree topics and acks directory reads", async () => {
-    const fileTree = {
-      subscribeCalls: [] as string[],
-      unsubscribeCalls: [] as string[],
-      subscribe(projectId: string) {
-        this.subscribeCalls.push(projectId)
-      },
-      unsubscribe(projectId: string) {
-        this.unsubscribeCalls.push(projectId)
-      },
-      getSnapshot: (projectId: string) => ({
-        projectId,
-        rootPath: "/tmp/project-1",
-        pageSize: 200,
-        supportsRealtime: true as const,
-      }),
-      readDirectory: async () => ({
-        directoryPath: "",
-        entries: [],
-        nextCursor: null,
-        hasMore: false,
-      }),
-      onInvalidate: () => () => {},
-    }
-
+  test("subscribes and unsubscribes chat topics", () => {
     const router = createWsRouter({
       store: { state: createEmptyState() } as never,
       agent: { getActiveStatuses: () => new Map() } as never,
@@ -128,7 +117,10 @@ describe("ws-router", () => {
         getSnapshot: () => null,
         onEvent: () => () => {},
       } as never,
-      fileTree: fileTree as never,
+      keybindings: {
+        getSnapshot: () => DEFAULT_KEYBINDINGS_SNAPSHOT,
+        onChange: () => () => {},
+      } as never,
       refreshDiscovery: async () => [],
       getDiscoveredProjects: () => [],
       machineDisplayName: "Local Machine",
@@ -140,24 +132,18 @@ describe("ws-router", () => {
       JSON.stringify({
         v: 1,
         type: "subscribe",
-        id: "tree-sub-1",
-        topic: { type: "file-tree", projectId: "project-1" },
+        id: "chat-sub-1",
+        topic: { type: "chat", chatId: "chat-1" },
       })
     )
 
-    expect(fileTree.subscribeCalls).toEqual(["project-1"])
     expect(ws.sent[0]).toEqual({
       v: PROTOCOL_VERSION,
       type: "snapshot",
-      id: "tree-sub-1",
+      id: "chat-sub-1",
       snapshot: {
-        type: "file-tree",
-        data: {
-          projectId: "project-1",
-          rootPath: "/tmp/project-1",
-          pageSize: 200,
-          supportsRealtime: true,
-        },
+        type: "chat",
+        data: null,
       },
     })
 
@@ -165,26 +151,63 @@ describe("ws-router", () => {
       ws as never,
       JSON.stringify({
         v: 1,
-        type: "command",
-        id: "tree-read-1",
-        command: {
-          type: "file-tree.readDirectory",
-          projectId: "project-1",
-          directoryPath: "",
-        },
+        type: "unsubscribe",
+        id: "chat-sub-1",
       })
     )
 
-    await Promise.resolve()
     expect(ws.sent[1]).toEqual({
       v: PROTOCOL_VERSION,
       type: "ack",
-      id: "tree-read-1",
-      result: {
-        directoryPath: "",
-        entries: [],
-        nextCursor: null,
-        hasMore: false,
+      id: "chat-sub-1",
+    })
+  })
+
+  test("subscribes to keybindings snapshots and writes keybindings through the router", async () => {
+    const initialSnapshot: KeybindingsSnapshot = DEFAULT_KEYBINDINGS_SNAPSHOT
+    const keybindings = {
+      snapshot: initialSnapshot,
+      getSnapshot() {
+        return this.snapshot
+      },
+      onChange: () => () => {},
+      async write(bindings: KeybindingsSnapshot["bindings"]) {
+        this.snapshot = { bindings, warning: null, filePathDisplay: "~/.kanna/keybindings.json" }
+        return this.snapshot
+      },
+    }
+
+    const router = createWsRouter({
+      store: { state: createEmptyState() } as never,
+      agent: { getActiveStatuses: () => new Map() } as never,
+      terminals: {
+        getSnapshot: () => null,
+        onEvent: () => () => {},
+      } as never,
+      keybindings: keybindings as never,
+      refreshDiscovery: async () => [],
+      getDiscoveredProjects: () => [],
+      machineDisplayName: "Local Machine",
+    })
+    const ws = new FakeWebSocket()
+
+    router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "subscribe",
+        id: "keybindings-sub-1",
+        topic: { type: "keybindings" },
+      })
+    )
+
+    expect(ws.sent[0]).toEqual({
+      v: PROTOCOL_VERSION,
+      type: "snapshot",
+      id: "keybindings-sub-1",
+      snapshot: {
+        type: "keybindings",
+        data: keybindings.snapshot,
       },
     })
 
@@ -192,16 +215,37 @@ describe("ws-router", () => {
       ws as never,
       JSON.stringify({
         v: 1,
-        type: "unsubscribe",
-        id: "tree-sub-1",
+        type: "command",
+        id: "keybindings-write-1",
+        command: {
+          type: "settings.writeKeybindings",
+          bindings: {
+            toggleEmbeddedTerminal: ["cmd+k"],
+            toggleRightSidebar: ["ctrl+shift+b"],
+            openInFinder: ["cmd+shift+g"],
+            openInEditor: ["cmd+shift+p"],
+            addSplitTerminal: ["cmd+alt+j"],
+          },
+        },
       })
     )
 
-    expect(fileTree.unsubscribeCalls).toEqual(["project-1"])
-    expect(ws.sent[2]).toEqual({
+    await Promise.resolve()
+    expect(ws.sent[1]).toEqual({
       v: PROTOCOL_VERSION,
       type: "ack",
-      id: "tree-sub-1",
-    })
+      id: "keybindings-write-1",
+        result: {
+          bindings: {
+            toggleEmbeddedTerminal: ["cmd+k"],
+            toggleRightSidebar: ["ctrl+shift+b"],
+            openInFinder: ["cmd+shift+g"],
+            openInEditor: ["cmd+shift+p"],
+            addSplitTerminal: ["cmd+alt+j"],
+          },
+          warning: null,
+          filePathDisplay: "~/.kanna/keybindings.json",
+        },
+      })
   })
 })