kanna-code 0.9.1 → 0.10.0

package/src/server/keybindings.ts

@@ -0,0 +1,163 @@
+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 { getDataRootDir, 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 = createDefaultSnapshot()
+  private readonly listeners = new Set<(snapshot: KeybindingsSnapshot) => void>()
+
+  constructor(filePath = path.join(getDataRootDir(homedir()), "keybindings.json")) {
+    this.filePath = 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)
+    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("Keybindings file was empty. Using defaults.")
+    }
+    const parsed = JSON.parse(text) as KeybindingsFile
+    return normalizeKeybindings(parsed)
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code === "ENOENT") {
+      return createDefaultSnapshot()
+    }
+
+    if (error instanceof SyntaxError) {
+      return createDefaultSnapshot("Keybindings file is invalid JSON. Using defaults.")
+    }
+
+    throw error
+  }
+}
+
+export function normalizeKeybindings(value: KeybindingsFile | null | undefined): KeybindingsSnapshot {
+  const warnings: string[] = []
+  const source = value && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null
+
+  if (!source) {
+    return createDefaultSnapshot("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,
+  }
+}
+
+function createDefaultSnapshot(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,
+  }
+}

package/src/server/server.ts

@@ -4,6 +4,7 @@ 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,6 +32,8 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   let server: ReturnType<typeof Bun.serve<ClientState>>
   let router: ReturnType<typeof createWsRouter>
   const terminals = new TerminalManager()
+  const keybindings = new KeybindingsManager()
+  await keybindings.initialize()
   const fileTree = new FileTreeManager({
     getProject: (projectId) => store.getProject(projectId),
   })
@@ -44,6 +47,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
     store,
     agent,
     terminals,
+    keybindings,
     fileTree,
     refreshDiscovery,
     getDiscoveredProjects: () => discoveredProjects,
@@ -107,6 +111,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
     }
     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"
@@ -23,6 +24,10 @@ describe("ws-router", () => {
         getSnapshot: () => null,
         onEvent: () => () => {},
       } as never,
+      keybindings: {
+        getSnapshot: () => ({ bindings: { toggleEmbeddedTerminal: ["cmd+j", "ctrl+`"], toggleRightSidebar: ["ctrl+b"], openInFinder: ["cmd+alt+f"], openInEditor: ["cmd+shift+o"], addSplitTerminal: ["cmd+shift+j"] }, warning: null }),
+        onChange: () => () => {},
+      } as never,
       fileTree: {
         getSnapshot: () => ({ projectId: "project-1", rootPath: "/tmp/project-1", pageSize: 200, supportsRealtime: true }),
         onInvalidate: () => () => {},
@@ -62,6 +67,10 @@ describe("ws-router", () => {
         onEvent: () => () => {},
         write: () => {},
       } as never,
+      keybindings: {
+        getSnapshot: () => ({ bindings: { toggleEmbeddedTerminal: ["cmd+j", "ctrl+`"], toggleRightSidebar: ["ctrl+b"], openInFinder: ["cmd+alt+f"], openInEditor: ["cmd+shift+o"], addSplitTerminal: ["cmd+shift+j"] }, warning: null }),
+        onChange: () => () => {},
+      } as never,
       fileTree: {
         getSnapshot: () => ({ projectId: "project-1", rootPath: "/tmp/project-1", pageSize: 200, supportsRealtime: true }),
         onInvalidate: () => () => {},
@@ -128,6 +137,10 @@ describe("ws-router", () => {
         getSnapshot: () => null,
         onEvent: () => () => {},
       } as never,
+      keybindings: {
+        getSnapshot: () => ({ bindings: { toggleEmbeddedTerminal: ["cmd+j", "ctrl+`"], toggleRightSidebar: ["ctrl+b"], openInFinder: ["cmd+alt+f"], openInEditor: ["cmd+shift+o"], addSplitTerminal: ["cmd+shift+j"] }, warning: null }),
+        onChange: () => () => {},
+      } as never,
       fileTree: fileTree as never,
       refreshDiscovery: async () => [],
       getDiscoveredProjects: () => [],
@@ -204,4 +217,102 @@ describe("ws-router", () => {
       id: "tree-sub-1",
     })
   })
+
+  test("subscribes to keybindings snapshots and writes keybindings through the router", async () => {
+    const initialSnapshot: KeybindingsSnapshot = {
+      bindings: {
+        toggleEmbeddedTerminal: ["cmd+j", "ctrl+`"],
+        toggleRightSidebar: ["ctrl+b"],
+        openInFinder: ["cmd+alt+f"],
+        openInEditor: ["cmd+shift+o"],
+        addSplitTerminal: ["cmd+shift+j"],
+      },
+      warning: null,
+    }
+    const keybindings = {
+      snapshot: initialSnapshot,
+      getSnapshot() {
+        return this.snapshot
+      },
+      onChange: () => () => {},
+      async write(bindings: KeybindingsSnapshot["bindings"]) {
+        this.snapshot = { bindings, warning: null }
+        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,
+      fileTree: {
+        getSnapshot: () => ({ projectId: "project-1", rootPath: "/tmp/project-1", pageSize: 200, supportsRealtime: true }),
+        onInvalidate: () => () => {},
+      } 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,
+      },
+    })
+
+    router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 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"],
+          },
+        },
+      })
+    )
+
+    await Promise.resolve()
+    expect(ws.sent[1]).toEqual({
+      v: PROTOCOL_VERSION,
+      type: "ack",
+      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,
+        },
+    })
+  })
 })

package/src/server/ws-router.ts

@@ -7,6 +7,7 @@ import type { DiscoveredProject } from "./discovery"
 import { EventStore } from "./event-store"
 import { openExternal } from "./external-open"
 import { FileTreeManager } from "./file-tree-manager"
+import { KeybindingsManager } from "./keybindings"
 import { ensureProjectDirectory } from "./paths"
 import { TerminalManager } from "./terminal-manager"
 import { deriveChatSnapshot, deriveLocalProjectsSnapshot, deriveSidebarData } from "./read-models"
@@ -19,6 +20,7 @@ interface CreateWsRouterArgs {
   store: EventStore
   agent: AgentCoordinator
   terminals: TerminalManager
+  keybindings: KeybindingsManager
   fileTree: FileTreeManager
   refreshDiscovery: () => Promise<DiscoveredProject[]>
   getDiscoveredProjects: () => DiscoveredProject[]
@@ -33,6 +35,7 @@ export function createWsRouter({
   store,
   agent,
   terminals,
+  keybindings,
   fileTree,
   refreshDiscovery,
   getDiscoveredProjects,
@@ -68,6 +71,18 @@ export function createWsRouter({
       }
     }
 
+    if (topic.type === "keybindings") {
+      return {
+        v: PROTOCOL_VERSION,
+        type: "snapshot",
+        id,
+        snapshot: {
+          type: "keybindings",
+          data: keybindings.getSnapshot(),
+        },
+      }
+    }
+
     if (topic.type === "terminal") {
       return {
         v: PROTOCOL_VERSION,
@@ -156,6 +171,15 @@ export function createWsRouter({
     }
   })
 
+  const disposeKeybindingEvents = keybindings.onChange(() => {
+    for (const ws of sockets) {
+      for (const [id, topic] of ws.data.subscriptions.entries()) {
+        if (topic.type !== "keybindings") continue
+        send(ws, createEnvelope(id, topic))
+      }
+    }
+  })
+
   async function handleCommand(ws: ServerWebSocket<ClientState>, message: Extract<ClientEnvelope, { type: "command" }>) {
     const { command, id } = message
     try {
@@ -164,6 +188,15 @@ export function createWsRouter({
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
           return
         }
+        case "settings.readKeybindings": {
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: keybindings.getSnapshot() })
+          return
+        }
+        case "settings.writeKeybindings": {
+          const snapshot = await keybindings.write(command.bindings)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: snapshot })
+          return
+        }
         case "project.open": {
           await ensureProjectDirectory(command.localPath)
           const project = await store.openProject(command.localPath)
@@ -329,6 +362,7 @@ export function createWsRouter({
     dispose() {
       disposeTerminalEvents()
       disposeFileTreeEvents()
+      disposeKeybindingEvents()
     },
   }
 }

package/src/shared/branding.ts

@@ -12,8 +12,12 @@ export function getDataRootName() {
   return DATA_ROOT_NAME
 }
 
+export function getDataRootDir(homeDir: string) {
+  return `${homeDir}/${DATA_ROOT_NAME}`
+}
+
 export function getDataDir(homeDir: string) {
-  return `${homeDir}/${DATA_ROOT_NAME}/data`
+  return `${getDataRootDir(homeDir)}/data`
 }
 
 export function getDataDirDisplay() {

package/src/shared/protocol.ts

@@ -3,6 +3,7 @@ import type {
   ChatSnapshot,
   FileTreeDirectoryPage,
   FileTreeSnapshot,
+  KeybindingsSnapshot,
   LocalProjectsSnapshot,
   ModelOptions,
   SidebarData,
@@ -18,6 +19,7 @@ export interface EditorOpenSettings {
 export type SubscriptionTopic =
   | { type: "sidebar" }
   | { type: "local-projects" }
+  | { type: "keybindings" }
   | { type: "file-tree"; projectId: string }
   | { type: "chat"; chatId: string }
   | { type: "terminal"; terminalId: string }
@@ -45,6 +47,8 @@ export type ClientCommand =
   | { type: "project.create"; localPath: string; title: string }
   | { type: "project.remove"; projectId: string }
   | { type: "system.ping" }
+  | { type: "settings.readKeybindings" }
+  | { type: "settings.writeKeybindings"; bindings: KeybindingsSnapshot["bindings"] }
   | {
       type: "system.openExternal"
       localPath: string
@@ -89,6 +93,7 @@ export type ClientEnvelope =
 export type ServerSnapshot =
   | { type: "sidebar"; data: SidebarData }
   | { type: "local-projects"; data: LocalProjectsSnapshot }
+  | { type: "keybindings"; data: KeybindingsSnapshot }
   | { type: "file-tree"; data: FileTreeSnapshot }
   | { type: "chat"; data: ChatSnapshot | null }
   | { type: "terminal"; data: TerminalSnapshot | null }

package/src/shared/types.ts

@@ -191,6 +191,26 @@ export interface FileTreeSnapshot {
   supportsRealtime: true
 }
 
+export type KeybindingAction =
+  | "toggleEmbeddedTerminal"
+  | "toggleRightSidebar"
+  | "openInFinder"
+  | "openInEditor"
+  | "addSplitTerminal"
+
+export const DEFAULT_KEYBINDINGS: Record<KeybindingAction, string[]> = {
+  toggleEmbeddedTerminal: ["cmd+j", "ctrl+`"],
+  toggleRightSidebar: ["cmd+b", "ctrl+b"],
+  openInFinder: ["cmd+alt+f", "ctrl+alt+f"],
+  openInEditor: ["cmd+shift+o", "ctrl+shift+o"],
+  addSplitTerminal: ["cmd+/", "ctrl+/"],
+}
+
+export interface KeybindingsSnapshot {
+  bindings: Record<KeybindingAction, string[]>
+  warning: string | null
+}
+
 export interface McpServerInfo {
   name: string
   status: string
@@ -244,46 +264,46 @@ interface ToolCallBase<TKind extends string, TInput> {
 }
 
 export interface AskUserQuestionToolCall
-  extends ToolCallBase<"ask_user_question", { questions: AskUserQuestionItem[] }> {}
+  extends ToolCallBase<"ask_user_question", { questions: AskUserQuestionItem[] }> { }
 
 export interface ExitPlanModeToolCall
-  extends ToolCallBase<"exit_plan_mode", { plan?: string; summary?: string }> {}
+  extends ToolCallBase<"exit_plan_mode", { plan?: string; summary?: string }> { }
 
 export interface TodoWriteToolCall
-  extends ToolCallBase<"todo_write", { todos: TodoItem[] }> {}
+  extends ToolCallBase<"todo_write", { todos: TodoItem[] }> { }
 
 export interface SkillToolCall
-  extends ToolCallBase<"skill", { skill: string }> {}
+  extends ToolCallBase<"skill", { skill: string }> { }
 
 export interface GlobToolCall
-  extends ToolCallBase<"glob", { pattern: string }> {}
+  extends ToolCallBase<"glob", { pattern: string }> { }
 
 export interface GrepToolCall
-  extends ToolCallBase<"grep", { pattern: string; outputMode?: string }> {}
+  extends ToolCallBase<"grep", { pattern: string; outputMode?: string }> { }
 
 export interface BashToolCall
-  extends ToolCallBase<"bash", { command: string; description?: string; timeoutMs?: number; runInBackground?: boolean }> {}
+  extends ToolCallBase<"bash", { command: string; description?: string; timeoutMs?: number; runInBackground?: boolean }> { }
 
 export interface WebSearchToolCall
-  extends ToolCallBase<"web_search", { query: string }> {}
+  extends ToolCallBase<"web_search", { query: string }> { }
 
 export interface ReadFileToolCall
-  extends ToolCallBase<"read_file", { filePath: string }> {}
+  extends ToolCallBase<"read_file", { filePath: string }> { }
 
 export interface WriteFileToolCall
-  extends ToolCallBase<"write_file", { filePath: string; content: string }> {}
+  extends ToolCallBase<"write_file", { filePath: string; content: string }> { }
 
 export interface EditFileToolCall
-  extends ToolCallBase<"edit_file", { filePath: string; oldString: string; newString: string }> {}
+  extends ToolCallBase<"edit_file", { filePath: string; oldString: string; newString: string }> { }
 
 export interface SubagentTaskToolCall
-  extends ToolCallBase<"subagent_task", { subagentType?: string }> {}
+  extends ToolCallBase<"subagent_task", { subagentType?: string }> { }
 
 export interface McpGenericToolCall
-  extends ToolCallBase<"mcp_generic", { server: string; tool: string; payload: Record<string, unknown> }> {}
+  extends ToolCallBase<"mcp_generic", { server: string; tool: string; payload: Record<string, unknown> }> { }
 
 export interface UnknownToolCall
-  extends ToolCallBase<"unknown_tool", { payload: Record<string, unknown> }> {}
+  extends ToolCallBase<"unknown_tool", { payload: Record<string, unknown> }> { }
 
 export type NormalizedToolCall =
   | AskUserQuestionToolCall