@hienlh/ppm 0.9.0-beta.8 → 0.9.1

package/src/services/extension-manifest.ts

@@ -0,0 +1,65 @@
+import { resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import type { ExtensionManifest } from "../types/extension.ts";
+
+/** Parse a package.json object into an ExtensionManifest (or null if invalid) */
+export function parseManifest(pkg: Record<string, unknown>): ExtensionManifest | null {
+  const name = pkg.name as string | undefined;
+  const version = pkg.version as string | undefined;
+  const main = pkg.main as string | undefined;
+  if (!name || !version || !main) return null;
+
+  const ppmField = pkg.ppm as Record<string, unknown> | undefined;
+  return {
+    id: name,
+    version,
+    main,
+    displayName: (ppmField?.displayName as string) || (pkg.displayName as string) || name,
+    description: pkg.description as string | undefined,
+    icon: (ppmField?.icon as string) || undefined,
+    engines: pkg.engines as ExtensionManifest["engines"],
+    activationEvents: pkg.activationEvents as string[] | undefined,
+    contributes: pkg.contributes as ExtensionManifest["contributes"],
+    ppm: ppmField as ExtensionManifest["ppm"],
+    permissions: pkg.permissions as string[] | undefined,
+  };
+}
+
+/** Read and parse manifest from a directory containing package.json */
+export function readManifestAt(dir: string): ExtensionManifest | null {
+  const pkgPath = resolve(dir, "package.json");
+  if (!existsSync(pkgPath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return parseManifest(raw);
+  } catch {
+    return null;
+  }
+}
+
+/** Scan extensions directory for all valid manifests */
+export async function discoverManifests(extensionsDir: string): Promise<ExtensionManifest[]> {
+  const manifests: ExtensionManifest[] = [];
+  if (!existsSync(extensionsDir)) return manifests;
+
+  const entries = await readdir(extensionsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    if (entry.name === "node_modules" || entry.name === "package.json") continue;
+
+    // Handle scoped packages (@scope/name)
+    const entryPath = resolve(extensionsDir, entry.name);
+    if (entry.name.startsWith("@")) {
+      const scopedEntries = await readdir(entryPath, { withFileTypes: true });
+      for (const scoped of scopedEntries) {
+        const manifest = readManifestAt(resolve(entryPath, scoped.name));
+        if (manifest) manifests.push(manifest);
+      }
+    } else {
+      const manifest = readManifestAt(entryPath);
+      if (manifest) manifests.push(manifest);
+    }
+  }
+  return manifests;
+}

package/src/services/extension-rpc-handlers.ts

@@ -0,0 +1,235 @@
+/**
+ * Main-side RPC handlers for vscode-compat API calls from the Worker.
+ * Each handler runs in the main process, accessing PPM services directly.
+ * UI-facing calls are forwarded to browser clients via the WS bridge.
+ */
+import type { RpcChannel } from "./extension-rpc.ts";
+import { contributionRegistry } from "./contribution-registry.ts";
+import { broadcastExtMsg, requestFromBrowser } from "../server/ws/extensions.ts";
+
+let requestIdCounter = 0;
+function nextRequestId(): string {
+  return `req_${++requestIdCounter}_${Date.now()}`;
+}
+
+/** Register all vscode-compat RPC handlers on the given RPC channel */
+export function registerVscodeCompatHandlers(rpc: RpcChannel): void {
+  // --- commands ---
+  rpc.onRequest("commands:execute", async (params) => {
+    const [command, ...args] = params as [string, ...unknown[]];
+    // Try contribution registry commands first (future: route to Worker handler)
+    const cmds = contributionRegistry.getCommands();
+    const found = cmds.find((c) => c.command === command);
+    if (!found) throw new Error(`Command not found: ${command}`);
+    // For now, command execution goes back to the Worker (round-trip)
+    return { executed: true, command };
+  });
+
+  rpc.onRequest("commands:list", async (params) => {
+    const [_filterInternal] = params as [boolean];
+    return contributionRegistry.getCommands().map((c) => c.command);
+  });
+
+  // --- window messages (forwarded to browser via WS bridge) ---
+  rpc.onRequest("window:showMessage", async (params) => {
+    const [level, message, items] = params as [string, string, string[]];
+    console.log(`[Ext:${level}] ${message}`);
+    if (items.length > 0) {
+      const requestId = nextRequestId();
+      const action = await requestFromBrowser<string | null>(
+        { type: "notification", id: requestId, level: level as "info" | "warn" | "error", message, actions: items },
+        requestId,
+      );
+      return action ?? undefined;
+    }
+    // No action items — just broadcast notification
+    broadcastExtMsg({ type: "notification", id: nextRequestId(), level: level as "info" | "warn" | "error", message });
+    return undefined;
+  });
+
+  rpc.onRequest("window:showQuickPick", async (params) => {
+    const [items, options] = params as [unknown[], unknown];
+    const requestId = nextRequestId();
+    const selected = await requestFromBrowser<unknown[] | null>(
+      {
+        type: "quickpick:show", requestId,
+        items: items as { label: string; description?: string; detail?: string; picked?: boolean }[],
+        options: (options ?? {}) as { placeholder?: string; canPickMany?: boolean },
+      },
+      requestId,
+    );
+    return selected;
+  });
+
+  rpc.onRequest("window:showInputBox", async (params) => {
+    const [options] = params as [unknown];
+    const requestId = nextRequestId();
+    const value = await requestFromBrowser<string | null>(
+      {
+        type: "inputbox:show", requestId,
+        options: (options ?? {}) as { prompt?: string; value?: string; placeholder?: string; password?: boolean },
+      },
+      requestId,
+    );
+    return value;
+  });
+
+  // --- status bar (forwarded to browser via WS bridge) ---
+  rpc.onRequest("window:statusbar:update", async (params) => {
+    const [item] = params as [{ id: string; text: string; tooltip?: string; command?: string; alignment: "left" | "right"; priority: number; extensionId?: string }];
+    broadcastExtMsg({ type: "statusbar:update", item });
+    return { ok: true };
+  });
+
+  rpc.onRequest("window:statusbar:remove", async (params) => {
+    const [itemId] = params as [string];
+    broadcastExtMsg({ type: "statusbar:remove", itemId });
+    return { ok: true };
+  });
+
+  // --- webview panels (forwarded to browser via WS bridge) ---
+  rpc.onRequest("window:webview:create", async (params) => {
+    const [panelId, extensionId, viewType, title] = params as [string, string, string, string];
+    broadcastExtMsg({ type: "webview:create", panelId, extensionId, viewType, title });
+    return { ok: true };
+  });
+
+  rpc.onRequest("window:webview:html", async (params) => {
+    const [panelId, html] = params as [string, string];
+    broadcastExtMsg({ type: "webview:html", panelId, html });
+    return { ok: true };
+  });
+
+  rpc.onRequest("window:webview:dispose", async (params) => {
+    const [panelId] = params as [string];
+    broadcastExtMsg({ type: "webview:dispose", panelId });
+    return { ok: true };
+  });
+
+  rpc.onRequest("window:webview:postMessage", async (params) => {
+    const [panelId, message] = params as [string, unknown];
+    broadcastExtMsg({ type: "webview:postMessage", panelId, message });
+    return { ok: true };
+  });
+
+  // --- tree views (forwarded to browser via WS bridge) ---
+  rpc.onRequest("window:tree:update", async (params) => {
+    const [viewId, items] = params as [string, unknown[]];
+    broadcastExtMsg({ type: "tree:update", viewId, items: items as any });
+    return { ok: true };
+  });
+
+  rpc.onRequest("window:tree:refresh", async (params) => {
+    const [viewId] = params as [string];
+    broadcastExtMsg({ type: "tree:refresh", viewId });
+    return { ok: true };
+  });
+
+  // --- workspace config ---
+  rpc.onRequest("workspace:config:get", async (params) => {
+    const [key] = params as [string];
+    // Read from PPM config service
+    try {
+      const { configService } = await import("./config.service.ts");
+      const config = configService.getAll() as unknown as Record<string, unknown>;
+      return getNestedValue(config, key) ?? null;
+    } catch {
+      return null;
+    }
+  });
+
+  rpc.onRequest("workspace:config:update", async (params) => {
+    const [key, value, _target] = params as [string, unknown, unknown];
+    try {
+      const { configService } = await import("./config.service.ts");
+      configService.set(key as any, value);
+    } catch (e) {
+      console.error(`[Ext:config] update error for ${key}:`, e);
+    }
+    return { ok: true };
+  });
+
+  // --- workspace fs (path-restricted) ---
+
+  /** Validate path is within allowed roots. Throws if path escapes. */
+  async function assertSafePath(filePath: string): Promise<string> {
+    const { resolve, relative } = await import("node:path");
+    const resolved = resolve(filePath);
+    // Allow: CWD (project root) and ~/.ppm/extensions/ (extension storage)
+    const { homedir } = await import("node:os");
+    const allowedRoots = [resolve(process.cwd()), resolve(homedir(), ".ppm", "extensions")];
+    const isSafe = allowedRoots.some((root) => {
+      const rel = relative(root, resolved);
+      return !rel.startsWith("..") && !rel.startsWith("/");
+    });
+    if (!isSafe) throw new Error(`Path outside allowed scope: ${filePath}`);
+    return resolved;
+  }
+
+  rpc.onRequest("workspace:fs:readFile", async (params) => {
+    const [filePath] = params as [string];
+    const safePath = await assertSafePath(filePath);
+    const { readFileSync } = await import("node:fs");
+    const content = readFileSync(safePath);
+    return Buffer.from(content).toString("base64");
+  });
+
+  rpc.onRequest("workspace:fs:writeFile", async (params) => {
+    const [filePath, base64Content] = params as [string, string];
+    const safePath = await assertSafePath(filePath);
+    const { writeFileSync } = await import("node:fs");
+    writeFileSync(safePath, Buffer.from(base64Content, "base64"));
+    return { ok: true };
+  });
+
+  rpc.onRequest("workspace:fs:stat", async (params) => {
+    const [filePath] = params as [string];
+    const safePath = await assertSafePath(filePath);
+    const { statSync } = await import("node:fs");
+    const stat = statSync(safePath);
+    return {
+      type: stat.isDirectory() ? 2 : 1,
+      size: stat.size,
+      mtime: stat.mtimeMs,
+    };
+  });
+
+  rpc.onRequest("workspace:fs:readDirectory", async (params) => {
+    const [dirPath] = params as [string];
+    const safePath = await assertSafePath(dirPath);
+    const { readdirSync, statSync } = await import("node:fs");
+    const { resolve } = await import("node:path");
+    const entries = readdirSync(safePath);
+    return entries.map((name) => {
+      try {
+        const full = resolve(safePath, name);
+        const s = statSync(full);
+        return [name, s.isDirectory() ? 2 : 1] as [string, number];
+      } catch {
+        return [name, 0] as [string, number];
+      }
+    });
+  });
+
+  rpc.onRequest("workspace:findFiles", async (params) => {
+    const [pattern, maxResults] = params as [string, number];
+    const glob = new Bun.Glob(pattern);
+    const results: string[] = [];
+    for await (const path of glob.scan({ cwd: process.cwd() })) {
+      results.push(path);
+      if (results.length >= maxResults) break;
+    }
+    return results;
+  });
+}
+
+/** Get a nested value from an object by dot-separated key */
+function getNestedValue(obj: Record<string, unknown>, key: string): unknown {
+  const parts = key.split(".");
+  let current: unknown = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return undefined;
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current;
+}

package/src/services/extension-rpc.ts

@@ -0,0 +1,105 @@
+import type { RpcRequest, RpcResponse, RpcEvent, RpcMessage } from "../types/extension.ts";
+
+const RPC_TIMEOUT = 10_000; // 10s per request
+
+type RpcHandler = (params: unknown[]) => unknown | Promise<unknown>;
+
+/**
+ * Typed RPC channel over Worker postMessage.
+ * Used by both main process (ExtensionService) and worker (ExtensionHost).
+ */
+export class RpcChannel {
+  private nextId = 1;
+  private pending = new Map<number, { resolve: (v: unknown) => void; reject: (e: Error) => void; timer: ReturnType<typeof setTimeout> }>();
+  private handlers = new Map<string, RpcHandler>();
+  private eventHandlers = new Map<string, Set<(data: unknown) => void>>();
+  private postFn: (msg: RpcMessage) => void;
+
+  constructor(postFn: (msg: RpcMessage) => void) {
+    this.postFn = postFn;
+  }
+
+  /** Send a request and wait for response (with timeout) */
+  sendRequest<T = unknown>(method: string, ...params: unknown[]): Promise<T> {
+    const id = this.nextId++;
+    return new Promise<T>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`RPC timeout: ${method} (${RPC_TIMEOUT}ms)`));
+      }, RPC_TIMEOUT);
+
+      this.pending.set(id, {
+        resolve: resolve as (v: unknown) => void,
+        reject,
+        timer,
+      });
+
+      this.postFn({ type: "request", id, method, params });
+    });
+  }
+
+  /** Fire an event (no response expected) */
+  sendEvent(event: string, data: unknown): void {
+    this.postFn({ type: "event", event, data });
+  }
+
+  /** Register a handler for incoming requests */
+  onRequest(method: string, handler: RpcHandler): void {
+    this.handlers.set(method, handler);
+  }
+
+  /** Register a handler for incoming events */
+  onEvent(event: string, handler: (data: unknown) => void): void {
+    if (!this.eventHandlers.has(event)) this.eventHandlers.set(event, new Set());
+    this.eventHandlers.get(event)!.add(handler);
+  }
+
+  /** Process an incoming message (call from message event listener) */
+  async handleMessage(msg: RpcMessage): Promise<void> {
+    if (msg.type === "response") {
+      const pending = this.pending.get(msg.id);
+      if (!pending) return;
+      this.pending.delete(msg.id);
+      clearTimeout(pending.timer);
+      if (msg.error) pending.reject(new Error(msg.error));
+      else pending.resolve(msg.result);
+      return;
+    }
+
+    if (msg.type === "request") {
+      const handler = this.handlers.get(msg.method);
+      const response: RpcResponse = { type: "response", id: msg.id };
+      if (!handler) {
+        response.error = `No handler for method: ${msg.method}`;
+      } else {
+        try {
+          response.result = await handler(msg.params);
+        } catch (e) {
+          response.error = e instanceof Error ? e.message : String(e);
+        }
+      }
+      this.postFn(response);
+      return;
+    }
+
+    if (msg.type === "event") {
+      const handlers = this.eventHandlers.get(msg.event);
+      if (handlers) {
+        for (const h of handlers) {
+          try { h(msg.data); } catch (e) { console.error(`[RPC] Event handler error (${msg.event}):`, e); }
+        }
+      }
+    }
+  }
+
+  /** Clean up all pending requests */
+  dispose(): void {
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(new Error("RPC channel disposed"));
+    }
+    this.pending.clear();
+    this.handlers.clear();
+    this.eventHandlers.clear();
+  }
+}

package/src/services/extension.service.ts

@@ -0,0 +1,228 @@
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import type { ExtensionManifest, ExtensionInfo, RpcMessage } from "../types/extension.ts";
+import { getExtensions, getExtensionById, insertExtension, getExtensionStorage, setExtensionStorageValue } from "./db.service.ts";
+import { contributionRegistry } from "./contribution-registry.ts";
+import { RpcChannel } from "./extension-rpc.ts";
+import { parseManifest, discoverManifests } from "./extension-manifest.ts";
+import { installExtension, removeExtension, devLinkExtension, ensureExtensionsDir } from "./extension-installer.ts";
+import { registerVscodeCompatHandlers } from "./extension-rpc-handlers.ts";
+
+const PPM_DIR = process.env.PPM_HOME || resolve(homedir(), ".ppm");
+const EXTENSIONS_DIR = resolve(PPM_DIR, "extensions");
+
+class ExtensionService {
+  private worker: Worker | null = null;
+  private rpc: RpcChannel | null = null;
+  private activatedIds = new Set<string>();
+  private workerReady = false;
+  private installing = new Set<string>();
+
+  // --- Worker lifecycle ---
+
+  private ensureWorker(): { worker: Worker; rpc: RpcChannel } {
+    if (this.worker && this.rpc) return { worker: this.worker, rpc: this.rpc };
+
+    const workerPath = new URL("./extension-host-worker.ts", import.meta.url).href;
+    this.worker = new Worker(workerPath, { type: "module" });
+    this.rpc = new RpcChannel((msg) => this.worker!.postMessage(msg));
+
+    this.rpc.onRequest("storage:set", async (params) => {
+      const [extId, scope, key, value] = params as [string, string, string, string | null];
+      setExtensionStorageValue(extId, scope, key, value);
+      return { ok: true };
+    });
+
+    // Register vscode-compat API handlers (commands, window, workspace, fs)
+    registerVscodeCompatHandlers(this.rpc);
+
+    this.rpc.onEvent("worker:ready", () => {
+      this.workerReady = true;
+      console.log("[ExtService] Extension host worker ready");
+    });
+
+    this.worker.addEventListener("message", (event: MessageEvent<RpcMessage>) => {
+      this.rpc!.handleMessage(event.data);
+    });
+    this.worker.addEventListener("error", (event) => {
+      console.error("[ExtService] Worker error:", event.message);
+    });
+
+    return { worker: this.worker, rpc: this.rpc };
+  }
+
+  private async terminateWorker(): Promise<void> {
+    if (this.rpc) { this.rpc.dispose(); this.rpc = null; }
+    if (this.worker) { this.worker.terminate(); this.worker = null; }
+    this.workerReady = false;
+    this.activatedIds.clear();
+    contributionRegistry.clear();
+  }
+
+  // --- Public API ---
+
+  parseManifest(pkg: Record<string, unknown>): ExtensionManifest | null {
+    return parseManifest(pkg);
+  }
+
+  async discover(): Promise<ExtensionManifest[]> {
+    ensureExtensionsDir(EXTENSIONS_DIR);
+    return discoverManifests(EXTENSIONS_DIR);
+  }
+
+  async install(name: string): Promise<ExtensionManifest> {
+    if (this.installing.has(name)) throw new Error(`Already installing ${name}`);
+    this.installing.add(name);
+    try {
+      return await installExtension(name, EXTENSIONS_DIR);
+    } finally {
+      this.installing.delete(name);
+    }
+  }
+
+  async remove(id: string): Promise<void> {
+    if (this.activatedIds.has(id)) await this.deactivate(id);
+    await removeExtension(id, EXTENSIONS_DIR);
+    contributionRegistry.unregister(id);
+  }
+
+  async activate(id: string): Promise<void> {
+    if (this.activatedIds.has(id)) return;
+
+    const row = getExtensionById(id);
+    if (!row) throw new Error(`Extension ${id} not found in DB`);
+    if (!row.enabled) throw new Error(`Extension ${id} is disabled`);
+
+    const manifest: ExtensionManifest = JSON.parse(row.manifest);
+    const extDir = resolve(EXTENSIONS_DIR, "node_modules", id);
+    const entryPath = resolve(extDir, manifest.main);
+    if (!existsSync(entryPath)) throw new Error(`Entry point not found: ${entryPath}`);
+
+    const { rpc } = this.ensureWorker();
+
+    // Hydrate persisted state so extensions can read it after activation
+    const globalStorage = getExtensionStorage(id, "global");
+    const workspaceStorage = getExtensionStorage(id, "workspace");
+    const storedState = {
+      global: Object.fromEntries(globalStorage.map((r) => [r.key, r.value])),
+      workspace: Object.fromEntries(workspaceStorage.map((r) => [r.key, r.value])),
+    };
+
+    // Pass server base URL so extensions can make fetch() calls in the Worker
+    const { configService: cfg } = await import("./config.service.ts");
+    const port = cfg.get("port") ?? 8080;
+    const baseUrl = `http://localhost:${port}`;
+
+    const result = await rpc.sendRequest<{ ok: boolean; error?: string }>(
+      "ext:activate", id, entryPath, extDir, storedState, baseUrl,
+    );
+    if (!result.ok) throw new Error(`Failed to activate ${id}: ${result.error}`);
+
+    this.activatedIds.add(id);
+    if (manifest.contributes) contributionRegistry.register(id, manifest.contributes);
+    this.broadcastContributions();
+    console.log(`[ExtService] Activated ${id}`);
+  }
+
+  async deactivate(id: string): Promise<void> {
+    if (!this.activatedIds.has(id)) return;
+    if (this.rpc) {
+      try { await this.rpc.sendRequest("ext:deactivate", id); } catch (e) {
+        console.error(`[ExtService] Error deactivating ${id}:`, e);
+      }
+    }
+    this.activatedIds.delete(id);
+    contributionRegistry.unregister(id);
+    this.broadcastContributions();
+    console.log(`[ExtService] Deactivated ${id}`);
+  }
+
+  list(): ExtensionInfo[] {
+    return getExtensions().map((row) => ({
+      id: row.id,
+      version: row.version,
+      displayName: row.display_name || row.id,
+      description: row.description || "",
+      icon: row.icon || "",
+      enabled: row.enabled === 1,
+      activated: this.activatedIds.has(row.id),
+      manifest: JSON.parse(row.manifest) as ExtensionManifest,
+    }));
+  }
+
+  get(id: string): ExtensionInfo | null {
+    const row = getExtensionById(id);
+    if (!row) return null;
+    return {
+      id: row.id,
+      version: row.version,
+      displayName: row.display_name || row.id,
+      description: row.description || "",
+      icon: row.icon || "",
+      enabled: row.enabled === 1,
+      activated: this.activatedIds.has(row.id),
+      manifest: JSON.parse(row.manifest) as ExtensionManifest,
+    };
+  }
+
+  async setEnabled(id: string, enabled: boolean): Promise<void> {
+    const row = getExtensionById(id);
+    if (!row) throw new Error(`Extension ${id} not found`);
+    const { updateExtension } = await import("./db.service.ts");
+    updateExtension(id, { enabled: enabled ? 1 : 0 });
+    if (enabled && !this.activatedIds.has(id)) await this.activate(id);
+    else if (!enabled && this.activatedIds.has(id)) await this.deactivate(id);
+  }
+
+  async devLink(localPath: string): Promise<ExtensionManifest> {
+    const manifest = devLinkExtension(localPath, EXTENSIONS_DIR);
+    // Auto-activate after dev-link (DB record is created with enabled=1)
+    if (!this.activatedIds.has(manifest.id)) {
+      try { await this.activate(manifest.id); } catch (e) {
+        console.error(`[ExtService] Auto-activate after dev-link failed:`, e);
+      }
+    }
+    return manifest;
+  }
+
+  async startup(): Promise<void> {
+    ensureExtensionsDir(EXTENSIONS_DIR);
+    const manifests = await this.discover();
+    for (const m of manifests) {
+      if (!getExtensionById(m.id)) {
+        insertExtension({
+          id: m.id, version: m.version,
+          display_name: m.displayName ?? null, description: m.description ?? null,
+          icon: m.icon ?? null, enabled: 1, manifest: JSON.stringify(m),
+        });
+      }
+    }
+    for (const row of getExtensions()) {
+      if (row.enabled !== 1) continue;
+      try { await this.activate(row.id); } catch (e) {
+        console.error(`[ExtService] Failed to activate ${row.id} on startup:`, e);
+      }
+    }
+  }
+
+  async shutdown(): Promise<void> {
+    for (const id of [...this.activatedIds]) {
+      try { await this.deactivate(id); } catch {}
+    }
+    await this.terminateWorker();
+  }
+
+  isActivated(id: string): boolean { return this.activatedIds.has(id); }
+  getExtensionsDir(): string { return EXTENSIONS_DIR; }
+
+  /** Push current contributions to all connected browser clients */
+  private broadcastContributions(): void {
+    try {
+      const { broadcastExtMsg } = require("../server/ws/extensions.ts");
+      broadcastExtMsg({ type: "contributions:update", contributions: contributionRegistry.getAll() });
+    } catch {}
+  }
+}
+
+export const extensionService = new ExtensionService();

package/src/services/mcp-config.service.ts

@@ -27,13 +27,22 @@ export class McpConfigService {
 
   /** List all MCP servers as Record (SDK-compatible format) */
   list(): Record<string, McpServerConfig> {
-    const rows = this.db.query("SELECT name, config FROM mcp_servers ORDER BY name").all() as { name: string; config: string }[];
-    const result: Record<string, McpServerConfig> = {};
-    for (const row of rows) {
-      const parsed = safeParse(row.config, row.name);
-      if (parsed) result[row.name] = parsed;
+    try {
+      const rows = this.db.query("SELECT name, config FROM mcp_servers ORDER BY name").all() as { name: string; config: string }[];
+      const result: Record<string, McpServerConfig> = {};
+      for (const row of rows) {
+        const parsed = safeParse(row.config, row.name);
+        if (parsed) result[row.name] = parsed;
+      }
+      return result;
+    } catch (e) {
+      const msg = (e as Error).message ?? String(e);
+      if (msg.includes("no such table")) {
+        console.warn("[mcp] mcp_servers table not found — returning empty list");
+        return {};
+      }
+      throw e;
     }
-    return result;
   }
 
   /** List as array with metadata (for UI) */