feat: configurable keybinding system with agent presets

.gitignore

@@ -7,4 +7,4 @@ release
 .idea
 .claude
 .DS_Store
-docs/plans
+docs/

electron/ipc/__tests__/keybindings.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { loadKeybindings, saveKeybindings } from '../keybindings.js';
+
+describe('keybindings persistence', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'keybindings-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns default config when file does not exist', () => {
+    const result = loadKeybindings(tmpDir);
+    expect(result).toEqual({ preset: 'default', overridesByPreset: {} });
+  });
+
+  it('saves and loads a keybinding config', () => {
+    const config = {
+      preset: 'claude-code',
+      overridesByPreset: {
+        'claude-code': {
+          'app.toggle-sidebar': { key: 'b', modifiers: { cmdOrCtrl: true, shift: true } },
+        },
+      },
+    };
+    saveKeybindings(tmpDir, JSON.stringify(config));
+    const loaded = loadKeybindings(tmpDir);
+    expect(loaded).toEqual(config);
+  });
+
+  it('falls back to default on corrupted file', () => {
+    fs.writeFileSync(path.join(tmpDir, 'keybindings.json'), 'not json', 'utf8');
+    const result = loadKeybindings(tmpDir);
+    expect(result).toEqual({ preset: 'default', overridesByPreset: {} });
+  });
+
+  it('falls back to backup on corrupted primary', () => {
+    const config = { preset: 'claude-code', overridesByPreset: {} };
+    fs.writeFileSync(path.join(tmpDir, 'keybindings.json'), 'corrupted', 'utf8');
+    fs.writeFileSync(path.join(tmpDir, 'keybindings.json.bak'), JSON.stringify(config), 'utf8');
+    const result = loadKeybindings(tmpDir);
+    expect(result).toEqual(config);
+  });
+
+  it('accepts legacy flat userOverrides format', () => {
+    const legacy = {
+      preset: 'claude-code',
+      userOverrides: {
+        'app.toggle-sidebar': { key: 'b', modifiers: { cmdOrCtrl: true, shift: true } },
+      },
+    };
+    fs.writeFileSync(path.join(tmpDir, 'keybindings.json'), JSON.stringify(legacy), 'utf8');
+    const loaded = loadKeybindings(tmpDir);
+    expect(loaded.preset).toBe('claude-code');
+    expect(loaded.userOverrides).toEqual(legacy.userOverrides);
+  });
+});

electron/ipc/channels.ts

@@ -40,6 +40,10 @@ export enum IPC {
   SaveAppState = 'save_app_state',
   LoadAppState = 'load_app_state',
 
+  // Keybindings
+  LoadKeybindings = 'load_keybindings',
+  SaveKeybindings = 'save_keybindings',
+
   // Window
   WindowIsFocused = '__window_is_focused',
   WindowIsMaximized = '__window_is_maximized',

electron/ipc/keybindings.ts

@@ -0,0 +1,85 @@
+import fs from 'fs';
+import path from 'path';
+
+const FILENAME = 'keybindings.json';
+
+/**
+ * Persisted keybinding config.
+ * - `overridesByPreset` is the current shape (per-preset user overrides)
+ * - `userOverrides` is the legacy flat shape (still accepted on load)
+ */
+export interface PersistedKeybindings {
+  preset: string;
+  overridesByPreset?: Record<string, Record<string, unknown>>;
+  /** @deprecated use overridesByPreset. Still read for backward compat. */
+  userOverrides?: Record<string, unknown>;
+}
+
+const DEFAULT_CONFIG: PersistedKeybindings = {
+  preset: 'default',
+  overridesByPreset: {},
+};
+
+function isValidShape(parsed: unknown): parsed is PersistedKeybindings {
+  if (!parsed || typeof parsed !== 'object') return false;
+  const obj = parsed as Record<string, unknown>;
+  if (typeof obj.preset !== 'string') return false;
+  if (obj.overridesByPreset !== undefined && typeof obj.overridesByPreset !== 'object') {
+    return false;
+  }
+  if (obj.userOverrides !== undefined && typeof obj.userOverrides !== 'object') return false;
+  return true;
+}
+
+export function loadKeybindings(dir: string): PersistedKeybindings {
+  const filePath = path.join(dir, FILENAME);
+  const bakPath = filePath + '.bak';
+
+  for (const candidate of [filePath, bakPath]) {
+    try {
+      if (fs.existsSync(candidate)) {
+        const content = fs.readFileSync(candidate, 'utf8');
+        if (content.trim()) {
+          const parsed: unknown = JSON.parse(content);
+          if (isValidShape(parsed)) {
+            return parsed;
+          }
+        }
+      }
+    } catch {
+      // Try next candidate
+    }
+  }
+
+  return { ...DEFAULT_CONFIG };
+}
+
+export function saveKeybindings(dir: string, json: string): void {
+  const filePath = path.join(dir, FILENAME);
+  fs.mkdirSync(dir, { recursive: true });
+
+  // Validate JSON before writing
+  JSON.parse(json);
+
+  const tmpPath = filePath + '.tmp';
+  try {
+    fs.writeFileSync(tmpPath, json, 'utf8');
+
+    if (fs.existsSync(filePath)) {
+      try {
+        fs.copyFileSync(filePath, filePath + '.bak');
+      } catch {
+        /* ignore */
+      }
+    }
+
+    fs.renameSync(tmpPath, filePath);
+  } catch (err) {
+    try {
+      fs.unlinkSync(tmpPath);
+    } catch {
+      /* ignore */
+    }
+    throw err;
+  }
+}

electron/ipc/register.ts

@@ -51,6 +51,7 @@ import {
 import { createTask, deleteTask } from './tasks.js';
 import { listAgents } from './agents.js';
 import { saveAppState, loadAppState } from './persistence.js';
+import { loadKeybindings, saveKeybindings } from './keybindings.js';
 import { spawn } from 'child_process';
 import { askAboutCode, cancelAskAboutCode } from './ask-code.js';
 import { getSystemMonospaceFonts } from './system-fonts.js';
@@ -369,6 +370,25 @@ export function registerAllHandlers(win: BrowserWindow): void {
     return json;
   });
 
+  // --- Keybindings ---
+  function getKeybindingsDir(): string {
+    let dir = app.getPath('userData');
+    if (!app.isPackaged) {
+      const base = path.basename(dir);
+      dir = path.join(path.dirname(dir), `${base}-dev`);
+    }
+    return dir;
+  }
+
+  ipcMain.handle(IPC.LoadKeybindings, () => {
+    return loadKeybindings(getKeybindingsDir());
+  });
+
+  ipcMain.handle(IPC.SaveKeybindings, (_e, args) => {
+    assertString(args?.json, 'json');
+    saveKeybindings(getKeybindingsDir(), args.json);
+  });
+
   // --- Arena persistence ---
   ipcMain.handle(IPC.SaveArenaData, (_e, args) => {
     assertString(args.filename, 'filename');

electron/preload.cjs

@@ -41,6 +41,9 @@ const ALLOWED_CHANNELS = new Set([
   // Persistence
   'save_app_state',
   'load_app_state',
+  // Keybindings
+  'load_keybindings',
+  'save_keybindings',
   // Window
   '__window_is_focused',
   '__window_is_maximized',