@hienlh/ppm 0.6.2 → 0.6.3

package/src/services/db.service.ts

@@ -4,7 +4,7 @@ import { homedir } from "node:os";
 import { mkdirSync, existsSync } from "node:fs";
 
 const PPM_DIR = resolve(homedir(), ".ppm");
-const CURRENT_SCHEMA_VERSION = 1;
+const CURRENT_SCHEMA_VERSION = 2;
 
 let db: Database | null = null;
 let dbProfile: string | null = null;
@@ -121,6 +121,27 @@ function runMigrations(database: Database): void {
       PRAGMA user_version = 1;
     `);
   }
+
+  if (current < 2) {
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS connections (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        type TEXT NOT NULL CHECK(type IN ('sqlite', 'postgres')),
+        name TEXT NOT NULL UNIQUE,
+        connection_config TEXT NOT NULL,
+        group_name TEXT,
+        color TEXT,
+        sort_order INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_connections_type ON connections(type);
+      CREATE INDEX IF NOT EXISTS idx_connections_group ON connections(group_name);
+
+      PRAGMA user_version = 2;
+    `);
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -299,5 +320,82 @@ export function getDbFilePath(): string {
   return getDbPath();
 }
 
+// ---------------------------------------------------------------------------
+// Connection helpers
+// ---------------------------------------------------------------------------
+
+export interface ConnectionRow {
+  id: number;
+  type: "sqlite" | "postgres";
+  name: string;
+  connection_config: string;
+  group_name: string | null;
+  color: string | null;
+  sort_order: number;
+  created_at: string;
+  updated_at: string;
+}
+
+/** Parsed config stored in connection_config JSON */
+export type ConnectionConfig =
+  | { type: "sqlite"; path: string }
+  | { type: "postgres"; connectionString: string };
+
+export function getConnections(): ConnectionRow[] {
+  return getDb().query(
+    "SELECT * FROM connections ORDER BY sort_order, id",
+  ).all() as ConnectionRow[];
+}
+
+export function getConnectionById(id: number): ConnectionRow | null {
+  return getDb().query("SELECT * FROM connections WHERE id = ?").get(id) as ConnectionRow | null;
+}
+
+export function getConnectionByName(name: string): ConnectionRow | null {
+  return getDb().query("SELECT * FROM connections WHERE name = ?").get(name) as ConnectionRow | null;
+}
+
+/** Resolve a connection by name or numeric ID */
+export function resolveConnection(nameOrId: string): ConnectionRow | null {
+  const asNum = Number(nameOrId);
+  if (!Number.isNaN(asNum) && Number.isInteger(asNum)) {
+    return getConnectionById(asNum) ?? getConnectionByName(nameOrId);
+  }
+  return getConnectionByName(nameOrId);
+}
+
+export function insertConnection(
+  type: "sqlite" | "postgres", name: string, config: ConnectionConfig,
+  groupName?: string | null, color?: string | null,
+): ConnectionRow {
+  const maxOrder = (getDb().query("SELECT COALESCE(MAX(sort_order), -1) as m FROM connections").get() as { m: number }).m;
+  getDb().query(
+    "INSERT INTO connections (type, name, connection_config, group_name, color, sort_order) VALUES (?, ?, ?, ?, ?, ?)",
+  ).run(type, name, JSON.stringify(config), groupName ?? null, color ?? null, maxOrder + 1);
+  return getConnectionByName(name)!;
+}
+
+export function deleteConnection(nameOrId: string): boolean {
+  const conn = resolveConnection(nameOrId);
+  if (!conn) return false;
+  getDb().query("DELETE FROM connections WHERE id = ?").run(conn.id);
+  return true;
+}
+
+export function updateConnection(
+  id: number, updates: { name?: string; config?: ConnectionConfig; groupName?: string | null; color?: string | null },
+): void {
+  const sets: string[] = [];
+  const vals: unknown[] = [];
+  if (updates.name !== undefined) { sets.push("name = ?"); vals.push(updates.name); }
+  if (updates.config !== undefined) { sets.push("connection_config = ?"); vals.push(JSON.stringify(updates.config)); }
+  if (updates.groupName !== undefined) { sets.push("group_name = ?"); vals.push(updates.groupName); }
+  if (updates.color !== undefined) { sets.push("color = ?"); vals.push(updates.color); }
+  if (sets.length === 0) return;
+  sets.push("updated_at = datetime('now')");
+  vals.push(id);
+  getDb().query(`UPDATE connections SET ${sets.join(", ")} WHERE id = ?`).run(...vals);
+}
+
 // Auto-close on process exit
 process.on("beforeExit", closeDb);

package/src/web/app.tsx

@@ -58,8 +58,13 @@ export function App() {
     }
   }, [theme]);
 
-  // Fetch server info on mount (before auth — shown on login screen)
-  useEffect(() => { fetchServerInfo(); }, [fetchServerInfo]);
+  // Fetch server info + keybindings on mount (before auth — shown on login screen)
+  useEffect(() => {
+    fetchServerInfo();
+    import("@/stores/keybindings-store").then(({ useKeybindingsStore }) => {
+      useKeybindingsStore.getState().loadFromServer();
+    });
+  }, [fetchServerInfo]);
 
   // Auth check on mount
   useEffect(() => {

package/src/web/components/settings/keyboard-shortcuts-section.tsx

@@ -0,0 +1,182 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+import { RotateCcw, AlertTriangle, Lock } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import {
+  KEY_ACTIONS,
+  useKeybindingsStore,
+  formatCombo,
+  comboFromEvent,
+  type KeyCategory,
+} from "@/stores/keybindings-store";
+
+const CATEGORIES: { key: KeyCategory; label: string }[] = [
+  { key: "general", label: "General" },
+  { key: "tabs", label: "Tabs" },
+  { key: "projects", label: "Projects" },
+];
+
+const BROWSER_RESERVED = [
+  "Ctrl+T", "Ctrl+W", "Ctrl+N", "Ctrl+Tab",
+  "Ctrl+L", "Ctrl+H", "Ctrl+J", "F5", "Ctrl+R",
+  "Ctrl+Shift+I", "Ctrl+Shift+J",
+];
+
+/** A single shortcut badge — click to record, Escape to cancel */
+function ShortcutBadge({
+  actionId,
+  combo,
+  locked,
+}: {
+  actionId: string;
+  combo: string;
+  locked?: boolean;
+}) {
+  const [recording, setRecording] = useState(false);
+  const setBinding = useKeybindingsStore((s) => s.setBinding);
+  const badgeRef = useRef<HTMLButtonElement>(null);
+
+  const handleRecord = useCallback(
+    (e: KeyboardEvent) => {
+      e.preventDefault();
+      e.stopPropagation();
+      if (e.key === "Escape") {
+        setRecording(false);
+        return;
+      }
+      const newCombo = comboFromEvent(e);
+      if (newCombo) {
+        setBinding(actionId, newCombo);
+        setRecording(false);
+      }
+    },
+    [actionId, setBinding],
+  );
+
+  useEffect(() => {
+    if (!recording) return;
+    document.addEventListener("keydown", handleRecord, true);
+    return () => document.removeEventListener("keydown", handleRecord, true);
+  }, [recording, handleRecord]);
+
+  // Close recording on outside click
+  useEffect(() => {
+    if (!recording) return;
+    const handler = (e: MouseEvent) => {
+      if (badgeRef.current && !badgeRef.current.contains(e.target as Node)) {
+        setRecording(false);
+      }
+    };
+    document.addEventListener("mousedown", handler);
+    return () => document.removeEventListener("mousedown", handler);
+  }, [recording]);
+
+  if (locked) {
+    return (
+      <span className="inline-flex items-center gap-1 rounded border border-border bg-muted px-2 py-0.5 text-[11px] font-mono text-muted-foreground">
+        <Lock className="size-2.5" />
+        {formatCombo(combo)}
+      </span>
+    );
+  }
+
+  if (recording) {
+    return (
+      <button
+        ref={badgeRef}
+        className="inline-flex items-center rounded border-2 border-primary bg-primary/10 px-2 py-0.5 text-[11px] font-mono text-primary animate-pulse"
+      >
+        Press keys...
+      </button>
+    );
+  }
+
+  return (
+    <button
+      ref={badgeRef}
+      onClick={() => setRecording(true)}
+      className="inline-flex items-center rounded border border-border bg-surface px-2 py-0.5 text-[11px] font-mono text-foreground hover:border-primary hover:bg-primary/5 transition-colors cursor-pointer"
+      title="Click to change shortcut"
+    >
+      {formatCombo(combo)}
+    </button>
+  );
+}
+
+export function KeyboardShortcutsSection() {
+  const { getBinding, resetBinding, resetAll, overrides } = useKeybindingsStore();
+
+  return (
+    <div className="space-y-3">
+      <div className="flex items-center justify-between">
+        <h3 className="text-xs font-medium text-text-secondary">Keyboard Shortcuts</h3>
+        {Object.keys(overrides).length > 0 && (
+          <Button
+            variant="ghost"
+            size="sm"
+            className="h-6 text-[10px] text-muted-foreground"
+            onClick={resetAll}
+          >
+            <RotateCcw className="size-3 mr-1" />
+            Reset all
+          </Button>
+        )}
+      </div>
+
+      {/* Browser warning */}
+      <div className="flex items-start gap-2 rounded-md border border-amber-500/30 bg-amber-500/5 px-2.5 py-2">
+        <AlertTriangle className="size-3.5 text-amber-500 shrink-0 mt-0.5" />
+        <p className="text-[10px] text-muted-foreground leading-relaxed">
+          Some shortcuts ({BROWSER_RESERVED.slice(0, 4).join(", ")}...) are reserved by the browser and cannot be overridden.
+        </p>
+      </div>
+
+      {/* Categories */}
+      {CATEGORIES.map((cat) => {
+        const actions = KEY_ACTIONS.filter((a) => a.category === cat.key);
+        if (actions.length === 0) return null;
+        return (
+          <div key={cat.key} className="space-y-1">
+            <span className="text-[10px] font-medium text-muted-foreground uppercase tracking-wide">
+              {cat.label}
+            </span>
+            <div className="space-y-0.5">
+              {actions.map((action) => {
+                const currentCombo = getBinding(action.id);
+                const isOverridden = action.id in overrides;
+                return (
+                  <div
+                    key={action.id}
+                    className="flex items-center justify-between py-1 px-1 rounded hover:bg-surface-elevated/50 transition-colors"
+                  >
+                    <div className="flex flex-col min-w-0">
+                      <span className="text-xs text-foreground">{action.label}</span>
+                      {action.note && (
+                        <span className="text-[10px] text-muted-foreground">{action.note}</span>
+                      )}
+                    </div>
+                    <div className="flex items-center gap-1 shrink-0 ml-2">
+                      <ShortcutBadge
+                        actionId={action.id}
+                        combo={currentCombo}
+                        locked={action.locked}
+                      />
+                      {isOverridden && !action.locked && (
+                        <button
+                          onClick={() => resetBinding(action.id)}
+                          className="flex items-center justify-center size-5 rounded text-muted-foreground hover:text-foreground hover:bg-surface-elevated transition-colors"
+                          title="Reset to default"
+                        >
+                          <RotateCcw className="size-3" />
+                        </button>
+                      )}
+                    </div>
+                  </div>
+                );
+              })}
+            </div>
+          </div>
+        );
+      })}
+    </div>
+  );
+}

package/src/web/components/settings/settings-tab.tsx

@@ -4,6 +4,7 @@ import { Separator } from "@/components/ui/separator";
 import { useSettingsStore, type Theme } from "@/stores/settings-store";
 import { cn } from "@/lib/utils";
 import { AISettingsSection } from "./ai-settings-section";
+import { KeyboardShortcutsSection } from "./keyboard-shortcuts-section";
 import { usePushNotification } from "@/hooks/use-push-notification";
 
 const THEME_OPTIONS: { value: Theme; label: string; icon: React.ElementType }[] = [
@@ -109,6 +110,10 @@ export function SettingsTab() {
 
       <Separator />
 
+      <KeyboardShortcutsSection />
+
+      <Separator />
+
       <div className="space-y-1.5">
         <h3 className="text-xs font-medium text-text-secondary">About</h3>
         <p className="text-xs text-text-secondary">

package/src/web/hooks/use-global-keybindings.ts

@@ -1,6 +1,8 @@
 import { useEffect, useState, useCallback } from "react";
 import { useTabStore } from "@/stores/tab-store";
 import { useSettingsStore } from "@/stores/settings-store";
+import { useProjectStore } from "@/stores/project-store";
+import { useKeybindingsStore } from "@/stores/keybindings-store";
 
 /** Dispatch this event to open the command palette from anywhere, optionally with initial query */
 export function openCommandPalette(initialQuery?: string) {
@@ -8,10 +10,10 @@ export function openCommandPalette(initialQuery?: string) {
 }
 
 /**
- * Global keyboard shortcuts.
+ * Global keyboard shortcuts — reads bindings from keybindings store.
  *
- * Shift+Shift (double tap) → Open command palette
- * Alt+] / Alt+[            → Next / previous tab
+ * Shift+Shift (double tap) is always hardcoded (non-customizable).
+ * Everything else uses `matchesEvent()` from the keybindings store.
  */
 export function useGlobalKeybindings() {
   const [paletteOpen, setPaletteOpen] = useState(false);
@@ -19,9 +21,10 @@ export function useGlobalKeybindings() {
 
   useEffect(() => {
     let lastShiftUp = 0;
+    const { matchesEvent } = useKeybindingsStore.getState();
 
     function handler(e: KeyboardEvent) {
-      // Double-Shift detection (on keyup to avoid repeats)
+      // Double-Shift detection (on keyup to avoid repeats) — always active
       if (e.type === "keyup" && e.key === "Shift" && !e.ctrlKey && !e.metaKey && !e.altKey) {
         const now = Date.now();
         if (now - lastShiftUp < 400) {
@@ -34,40 +37,97 @@ export function useGlobalKeybindings() {
         return;
       }
 
-      // Keydown shortcuts
       if (e.type !== "keydown") return;
 
-      // Cmd/Ctrl+S → Prevent browser save dialog (editor auto-saves)
-      if (e.key === "s" && (e.metaKey || e.ctrlKey) && !e.altKey && !e.shiftKey) {
+      // Re-read matchesEvent on each keydown to pick up live overrides
+      const { matchesEvent: match } = useKeybindingsStore.getState();
+
+      // Prevent browser save dialog (locked — always Mod+S)
+      if (match(e, "save-prevent")) {
         e.preventDefault();
         return;
       }
 
-      // F1 → Open command palette
-      if (e.key === "F1") {
+      // Command palette
+      if (match(e, "command-palette")) {
         e.preventDefault();
         setPaletteInitialQuery("");
         setPaletteOpen(true);
         return;
       }
 
-      // Cmd/Ctrl+B → Toggle sidebar
-      if (e.key === "b" && (e.metaKey || e.ctrlKey) && !e.altKey && !e.shiftKey) {
+      // Toggle sidebar
+      if (match(e, "toggle-sidebar")) {
         e.preventDefault();
         useSettingsStore.getState().toggleSidebar();
         return;
       }
 
-      // Alt+] / Alt+[ → Cycle tabs
-      if (e.altKey && !e.ctrlKey && !e.metaKey && (e.key === "]" || e.key === "[")) {
+      // Tab cycling
+      if (match(e, "next-tab") || match(e, "prev-tab")) {
         e.preventDefault();
         const { tabs, activeTabId, setActiveTab } = useTabStore.getState();
         if (tabs.length < 2) return;
         const idx = tabs.findIndex((t) => t.id === activeTabId);
-        const next = e.key === "]"
+        const forward = match(e, "next-tab");
+        const next = forward
           ? (idx + 1) % tabs.length
           : (idx - 1 + tabs.length) % tabs.length;
         setActiveTab(tabs[next]!.id);
+        return;
+      }
+
+      // Open tab shortcuts
+      const tabShortcuts: { action: string; type: string; title: string }[] = [
+        { action: "open-chat", type: "chat", title: "AI Chat" },
+        { action: "open-terminal", type: "terminal", title: "Terminal" },
+        { action: "open-git-graph", type: "git-graph", title: "Git Graph" },
+      ];
+      for (const s of tabShortcuts) {
+        if (match(e, s.action)) {
+          e.preventDefault();
+          const project = useProjectStore.getState().activeProject;
+          useTabStore.getState().openTab({
+            type: s.type as any,
+            title: s.title,
+            projectId: project?.name ?? null,
+            metadata: project ? { projectName: project.name } : undefined,
+            closable: true,
+          });
+          return;
+        }
+      }
+
+      // Open settings (sidebar)
+      if (match(e, "open-settings")) {
+        e.preventDefault();
+        const settings = useSettingsStore.getState();
+        if (settings.sidebarCollapsed) settings.toggleSidebar();
+        settings.setSidebarActiveTab("settings");
+        return;
+      }
+
+      // Open git status (sidebar)
+      if (match(e, "open-git-status")) {
+        e.preventDefault();
+        const settings = useSettingsStore.getState();
+        if (settings.sidebarCollapsed) settings.toggleSidebar();
+        settings.setSidebarActiveTab("git");
+        return;
+      }
+
+      // Switch project 1-9
+      for (let i = 1; i <= 9; i++) {
+        if (match(e, `switch-project-${i}`)) {
+          e.preventDefault();
+          const projects = useProjectStore.getState().projects;
+          const target = projects[i - 1];
+          if (target) {
+            useProjectStore.getState().setActiveProject(target);
+            useTabStore.getState().switchProject(target.name);
+          }
+          return;
+        }
       }
     }
 

package/src/web/stores/keybindings-store.ts

@@ -0,0 +1,192 @@
+import { create } from "zustand";
+import { api } from "@/lib/api-client";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type KeyCategory = "general" | "tabs" | "projects";
+
+export interface KeyAction {
+  id: string;
+  label: string;
+  category: KeyCategory;
+  defaultKey: string;
+  locked?: boolean;
+  note?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Action catalog
+// ---------------------------------------------------------------------------
+
+const isMac = typeof navigator !== "undefined" && /Mac|iPhone|iPad/.test(navigator.userAgent);
+
+export const KEY_ACTIONS: KeyAction[] = [
+  // General
+  { id: "command-palette", label: "Command Palette", category: "general", defaultKey: "F1", note: "Shift+Shift also opens (not customizable)" },
+  { id: "toggle-sidebar", label: "Toggle Sidebar", category: "general", defaultKey: "Mod+B" },
+  { id: "save-prevent", label: "Prevent Save Dialog", category: "general", defaultKey: "Mod+S", locked: true, note: "Always active — prevents browser save" },
+  // Tabs
+  { id: "next-tab", label: "Next Tab", category: "tabs", defaultKey: "Alt+]" },
+  { id: "prev-tab", label: "Previous Tab", category: "tabs", defaultKey: "Alt+[" },
+  { id: "open-chat", label: "Open Chat", category: "tabs", defaultKey: "Mod+Shift+L" },
+  { id: "open-terminal", label: "Open Terminal", category: "tabs", defaultKey: "Mod+`" },
+  { id: "open-settings", label: "Open Settings", category: "tabs", defaultKey: "Mod+," },
+  { id: "open-git-graph", label: "Git Graph", category: "tabs", defaultKey: "Mod+Shift+G" },
+  { id: "open-git-status", label: "Git Status (sidebar)", category: "tabs", defaultKey: "Mod+Shift+E" },
+  // Projects — Mod+1..9
+  ...Array.from({ length: 9 }, (_, i) => ({
+    id: `switch-project-${i + 1}`,
+    label: `Switch to Project ${i + 1}`,
+    category: "projects" as KeyCategory,
+    defaultKey: `Mod+${i + 1}`,
+  })),
+];
+
+/** Map action ID → default key for fast lookup */
+const DEFAULT_MAP = new Map(KEY_ACTIONS.map((a) => [a.id, a.defaultKey]));
+
+// ---------------------------------------------------------------------------
+// Key combo parsing & matching
+// ---------------------------------------------------------------------------
+
+interface ParsedCombo {
+  ctrl: boolean;
+  meta: boolean;
+  alt: boolean;
+  shift: boolean;
+  key: string; // lowercase
+}
+
+function parseCombo(combo: string): ParsedCombo {
+  const parts = combo.split("+");
+  const result: ParsedCombo = { ctrl: false, meta: false, alt: false, shift: false, key: "" };
+  for (const part of parts) {
+    const p = part.trim();
+    switch (p) {
+      case "Mod":
+        if (isMac) result.meta = true;
+        else result.ctrl = true;
+        break;
+      case "Ctrl": result.ctrl = true; break;
+      case "Meta": case "Cmd": result.meta = true; break;
+      case "Alt": result.alt = true; break;
+      case "Shift": result.shift = true; break;
+      default: result.key = p.toLowerCase(); break;
+    }
+  }
+  return result;
+}
+
+function eventMatchesCombo(e: KeyboardEvent, combo: ParsedCombo): boolean {
+  if (e.ctrlKey !== combo.ctrl) return false;
+  if (e.metaKey !== combo.meta) return false;
+  if (e.altKey !== combo.alt) return false;
+  if (e.shiftKey !== combo.shift) return false;
+  return e.key.toLowerCase() === combo.key;
+}
+
+// ---------------------------------------------------------------------------
+// Format combo for display
+// ---------------------------------------------------------------------------
+
+export function formatCombo(combo: string): string {
+  return combo
+    .replace(/Mod/g, isMac ? "\u2318" : "Ctrl")
+    .replace(/Shift/g, isMac ? "\u21E7" : "Shift")
+    .replace(/Alt/g, isMac ? "\u2325" : "Alt")
+    .replace(/Meta|Cmd/g, "\u2318")
+    .replace(/Ctrl/g, isMac ? "\u2303" : "Ctrl");
+}
+
+/** Build combo string from a KeyboardEvent (for recording) */
+export function comboFromEvent(e: KeyboardEvent): string | null {
+  // Ignore bare modifier keys
+  if (["Control", "Meta", "Alt", "Shift"].includes(e.key)) return null;
+
+  const parts: string[] = [];
+  if (e.ctrlKey && !e.metaKey) parts.push(isMac ? "Ctrl" : "Mod");
+  if (e.metaKey) parts.push(isMac ? "Mod" : "Meta");
+  if (e.altKey) parts.push("Alt");
+  if (e.shiftKey) parts.push("Shift");
+
+  // Normalize key
+  let key = e.key;
+  if (key === " ") key = "Space";
+  else if (key.length === 1) key = key.toUpperCase();
+  parts.push(key);
+
+  return parts.join("+");
+}
+
+// ---------------------------------------------------------------------------
+// Store
+// ---------------------------------------------------------------------------
+
+interface KeybindingsState {
+  /** User overrides from server (action ID → combo string) */
+  overrides: Record<string, string>;
+  loaded: boolean;
+
+  /** Get the effective binding for an action */
+  getBinding: (actionId: string) => string;
+  /** Check if a keyboard event matches an action */
+  matchesEvent: (e: KeyboardEvent, actionId: string) => boolean;
+  /** Set a custom binding (persists to server) */
+  setBinding: (actionId: string, combo: string) => void;
+  /** Reset a single binding to default (persists to server) */
+  resetBinding: (actionId: string) => void;
+  /** Reset all bindings to defaults (persists to server) */
+  resetAll: () => void;
+  /** Load overrides from server */
+  loadFromServer: () => Promise<void>;
+}
+
+export const useKeybindingsStore = create<KeybindingsState>((set, get) => ({
+  overrides: {},
+  loaded: false,
+
+  getBinding: (actionId) => {
+    return get().overrides[actionId] ?? DEFAULT_MAP.get(actionId) ?? "";
+  },
+
+  matchesEvent: (e, actionId) => {
+    const combo = get().getBinding(actionId);
+    if (!combo) return false;
+    return eventMatchesCombo(e, parseCombo(combo));
+  },
+
+  setBinding: (actionId, combo) => {
+    const newOverrides = { ...get().overrides, [actionId]: combo };
+    set({ overrides: newOverrides });
+    // Persist to server (fire-and-forget)
+    api.put("/api/settings/keybindings", { [actionId]: combo }).catch(() => {});
+  },
+
+  resetBinding: (actionId) => {
+    const newOverrides = { ...get().overrides };
+    delete newOverrides[actionId];
+    set({ overrides: newOverrides });
+    api.put("/api/settings/keybindings", { [actionId]: null }).catch(() => {});
+  },
+
+  resetAll: () => {
+    set({ overrides: {} });
+    // Send all current override keys as null to clear them
+    const nulled: Record<string, null> = {};
+    for (const key of Object.keys(get().overrides)) nulled[key] = null;
+    if (Object.keys(nulled).length > 0) {
+      api.put("/api/settings/keybindings", nulled).catch(() => {});
+    }
+  },
+
+  loadFromServer: async () => {
+    try {
+      const overrides = await api.get<Record<string, string>>("/api/settings/keybindings");
+      set({ overrides, loaded: true });
+    } catch {
+      set({ loaded: true }); // proceed with defaults on error
+    }
+  },
+}));

package/dist/web/assets/api-client-DPWUomlf.js

@@ -1 +0,0 @@
-import{a as e}from"./jsx-runtime-B4BJKQ1u.js";var t=e({api:()=>r,getAuthToken:()=>o,projectUrl:()=>i,setAuthToken:()=>a}),n=`ppm-auth-token`,r=new class{baseUrl;constructor(e=``){this.baseUrl=e}getToken(){return localStorage.getItem(n)}headers(){let e={"Content-Type":`application/json`},t=this.getToken();return t&&(e.Authorization=`Bearer ${t}`),e}async get(e){let t=await fetch(`${this.baseUrl}${e}`,{headers:this.headers()});return this.handleResponse(t)}async post(e,t){let n=await fetch(`${this.baseUrl}${e}`,{method:`POST`,headers:this.headers(),body:t==null?void 0:JSON.stringify(t)});return this.handleResponse(n)}async put(e,t){let n=await fetch(`${this.baseUrl}${e}`,{method:`PUT`,headers:this.headers(),body:t==null?void 0:JSON.stringify(t)});return this.handleResponse(n)}async patch(e,t){let n=await fetch(`${this.baseUrl}${e}`,{method:`PATCH`,headers:this.headers(),body:t==null?void 0:JSON.stringify(t)});return this.handleResponse(n)}async del(e,t){let n=await fetch(`${this.baseUrl}${e}`,{method:`DELETE`,headers:this.headers(),body:t==null?void 0:JSON.stringify(t)});await this.handleResponse(n)}async handleResponse(e){if(e.status===401)throw localStorage.removeItem(n),window.location.reload(),Error(`Unauthorized`);let t=await e.json();if(t.ok===!1)throw Error(t.error??`HTTP ${e.status}`);return t.data}};function i(e){return`/api/project/${encodeURIComponent(e)}`}function a(e){localStorage.setItem(n,e)}function o(){return localStorage.getItem(n)}export{a,i,t as n,o as r,r as t};