@hienlh/ppm 0.9.85 → 0.9.87

package/packages/vscode-compat/src/index.ts

@@ -21,11 +21,13 @@ export {
   type RpcClient,
 } from "./types.ts";
 export { type ExtensionContext, Memento } from "./context.ts";
+export { ProcessService, type SpawnResult, type SpawnOptions } from "./process.ts";
 
 // Service imports
 import { CommandService } from "./commands.ts";
 import { WindowService } from "./window.ts";
 import { WorkspaceService } from "./workspace.ts";
+import { ProcessService } from "./process.ts";
 import { createExtensionContext, type ExtensionContext } from "./context.ts";
 import { createEnvNamespace } from "./env.ts";
 import { createNotSupported } from "./not-supported.ts";
@@ -55,12 +57,14 @@ export function createVscodeCompat(options: CreateVscodeCompatOptions) {
   const commands = new CommandService(rpc, extensionId);
   const window = new WindowService(rpc, extensionId);
   const workspace = new WorkspaceService(rpc, extensionId);
+  const process = new ProcessService(rpc);
 
   return {
     // Active API namespaces
     commands,
     window,
     workspace,
+    process,
     env: createEnvNamespace(options.appName ?? "PPM", options.machineId ?? "ppm-local"),
 
     // Classes & utilities

package/packages/vscode-compat/src/process.ts

@@ -0,0 +1,25 @@
+import type { RpcClient } from "./types.ts";
+
+export interface SpawnResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+export interface SpawnOptions {
+  timeout?: number;
+  env?: Record<string, string>;
+}
+
+/** Process namespace — spawn subprocesses via RPC to main process */
+export class ProcessService {
+  private rpc: RpcClient;
+
+  constructor(rpc: RpcClient) {
+    this.rpc = rpc;
+  }
+
+  async spawn(cmd: string, args: string[], cwd: string, options?: SpawnOptions): Promise<SpawnResult> {
+    return this.rpc.request<SpawnResult>("process:spawn", cmd, args, cwd, options);
+  }
+}

package/packages/vscode-compat/src/window.ts

@@ -184,6 +184,16 @@ export class WindowService {
     });
   }
 
+  // --- Open PPM Tab ---
+
+  async openTab(tabType: string, title: string, projectId: string | null, metadata?: Record<string, unknown>): Promise<void> {
+    await this.rpc.request("window:openTab", tabType, title, projectId, metadata);
+  }
+
+  async switchProject(projectName: string): Promise<void> {
+    await this.rpc.request("window:switchProject", projectName);
+  }
+
   // --- Webview Panel ---
 
   createWebviewPanel(viewType: string, title: string, showOptions: ViewColumn): unknown {

package/src/cli/commands/ext-cmd.ts

@@ -63,6 +63,7 @@ export function registerExtCommands(program: Command): void {
     .description("List installed extensions")
     .action(async () => {
       const { extensionService } = await import("../../services/extension.service.ts");
+      await extensionService.discover(); // populate bundledIds for source column
       const extensions = extensionService.list();
       if (extensions.length === 0) {
         console.log(`${C.dim}No extensions installed.${C.reset}`);
@@ -71,10 +72,11 @@ export function registerExtCommands(program: Command): void {
       const rows = extensions.map((e) => [
         e.id,
         e.version,
+        extensionService.isBundled(e.id) ? `${C.cyan}bundled${C.reset}` : "user",
         e.enabled ? `${C.green}enabled${C.reset}` : `${C.dim}disabled${C.reset}`,
         e.activated ? `${C.green}active${C.reset}` : `${C.dim}inactive${C.reset}`,
       ]);
-      printTable(["ID", "Version", "Enabled", "Status"], rows);
+      printTable(["ID", "Version", "Source", "Enabled", "Status"], rows);
     });
 
   ext

package/src/server/ws/extensions.ts

@@ -71,21 +71,51 @@ async function handleMessage(ws: ExtWsSocket, raw: string | Buffer): Promise<voi
 
   switch (msg.type) {
     case "ready": {
-      // Send current contributions on connect
+      // Send current contributions + any activation errors on connect
       const contributions = contributionRegistry.getAll();
-      ws.send(JSON.stringify({ type: "contributions:update", contributions } satisfies ExtServerMsg));
+      const { extensionService } = await import("../../services/extension.service.ts");
+      const activationErrors = Object.fromEntries(extensionService.getActivationErrors());
+      const readyMsg: ExtServerMsg = Object.keys(activationErrors).length > 0
+        ? { type: "contributions:update", contributions, activationErrors }
+        : { type: "contributions:update", contributions };
+      ws.send(JSON.stringify(readyMsg));
       break;
     }
 
     case "command:execute": {
       try {
         const { extensionService } = await import("../../services/extension.service.ts");
-        // Forward to extension host worker via RPC
         if (extensionService["rpc"]) {
-          await extensionService["rpc"].sendRequest("ext:command:execute", msg.command, ...(msg.args ?? []));
+          console.log(`[ExtWS] command:execute "${msg.command}"`);
+          const result = await extensionService["rpc"].sendRequest<{ ok: boolean; error?: string }>(
+            "ext:command:execute", msg.command, ...(msg.args ?? []),
+          );
+          if (!result?.ok) {
+            console.error(`[ExtWS] command:execute failed: ${result?.error ?? "unknown"}`);
+            broadcastExtMsg({
+              type: "notification",
+              id: `cmd-error-${Date.now()}`,
+              level: "error",
+              message: `Extension command failed: ${result?.error ?? "unknown error"}`,
+            });
+          }
+        } else {
+          console.error(`[ExtWS] command:execute: extension host not ready`);
+          broadcastExtMsg({
+            type: "notification",
+            id: `cmd-error-${Date.now()}`,
+            level: "error",
+            message: `Extension host not ready. Try reloading the page.`,
+          });
         }
       } catch (e) {
         console.error(`[ExtWS] command:execute error:`, e);
+        broadcastExtMsg({
+          type: "notification",
+          id: `cmd-error-${Date.now()}`,
+          level: "error",
+          message: `Extension command error: ${e instanceof Error ? e.message : String(e)}`,
+        });
       }
       break;
     }

package/src/services/contribution-registry.ts

@@ -1,4 +1,4 @@
-import type { ExtensionContributes, ContributedCommand, ContributedView, ContributedMenu } from "../types/extension.ts";
+import type { ExtensionContributes, ContributedCommand, ContributedView, ContributedMenu, ContributedKeybinding } from "../types/extension.ts";
 
 /**
  * In-memory registry of all contribution points from enabled extensions.
@@ -9,6 +9,7 @@ class ContributionRegistry {
   private views = new Map<string, Map<string, ContributedView & { extId: string }>>();
   private configs = new Map<string, Record<string, unknown>>();
   private menus = new Map<string, Array<ContributedMenu & { extId: string }>>();
+  private keybindings: Array<ContributedKeybinding & { extId: string }> = [];
 
   register(extId: string, contributes: ExtensionContributes): void {
     if (contributes.commands) {
@@ -37,6 +38,11 @@ class ContributionRegistry {
         }
       }
     }
+    if (contributes.keybindings) {
+      for (const kb of contributes.keybindings) {
+        this.keybindings.push({ ...kb, extId });
+      }
+    }
   }
 
   unregister(extId: string): void {
@@ -51,6 +57,7 @@ class ContributionRegistry {
     for (const [location, items] of this.menus) {
       this.menus.set(location, items.filter((m) => m.extId !== extId));
     }
+    this.keybindings = this.keybindings.filter((kb) => kb.extId !== extId);
     this.configs.delete(extId);
   }
 
@@ -73,6 +80,10 @@ class ContributionRegistry {
     return [...this.views.keys()];
   }
 
+  getKeybindings(): Array<ContributedKeybinding & { extId: string }> {
+    return [...this.keybindings];
+  }
+
   getConfiguration(extId?: string): Record<string, Record<string, unknown>> {
     if (extId) {
       const cfg = this.configs.get(extId);
@@ -95,6 +106,7 @@ class ContributionRegistry {
       commands: this.getCommands(),
       views: viewsByLocation,
       menus: menusByLocation,
+      keybindings: this.getKeybindings(),
       configuration: this.getConfiguration(),
     };
   }
@@ -104,6 +116,7 @@ class ContributionRegistry {
     this.views.clear();
     this.configs.clear();
     this.menus.clear();
+    this.keybindings = [];
   }
 }
 

package/src/services/extension-host-worker.ts

@@ -29,6 +29,7 @@ self.addEventListener("message", (event: MessageEvent<RpcMessage>) => {
 
 rpc.onRequest("ext:activate", async (params) => {
   const [extId, entryPath, extensionPath, storedState, baseUrl] = params as [string, string, string, Record<string, Record<string, string | null>>?, string?];
+  console.log(`[ExtHost] activating ${extId} from ${entryPath}`);
   if (activeExtensions.has(extId)) return { ok: true, already: true };
 
   // Expose server base URL so extensions can use fetch() with absolute URLs
@@ -68,6 +69,7 @@ rpc.onRequest("ext:activate", async (params) => {
       window: api.window as WindowService,
       commands: api.commands as CommandService,
     });
+    console.log(`[ExtHost] activated ${extId} (${activeExtensions.size} total)`);
     return { ok: true };
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
@@ -101,16 +103,23 @@ rpc.onRequest("ext:deactivate", async (params) => {
 
 rpc.onRequest("ext:command:execute", async (params) => {
   const [command, ...args] = params as [string, ...unknown[]];
-  for (const [, ext] of activeExtensions) {
+  console.log(`[ExtHost] command:execute "${command}" (${activeExtensions.size} extensions active)`);
+  for (const [extId, ext] of activeExtensions) {
     if (ext.commands) {
+      const hasLocal = (ext.commands as any).localHandlers?.has(command);
+      if (!hasLocal) continue;
+      console.log(`[ExtHost] routing "${command}" → ${extId}`);
       try {
         const result = await (ext.commands as any).executeCommand(command, ...args);
         return { ok: true, result };
-      } catch {
-        // Command not found in this extension, try next
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(`[ExtHost] command "${command}" in ${extId} threw:`, msg);
+        return { ok: false, error: msg };
       }
     }
   }
+  console.warn(`[ExtHost] command not found: "${command}"`);
   return { ok: false, error: `Command not found: ${command}` };
 });
 

package/src/services/extension-manifest.ts

@@ -38,7 +38,7 @@ export function readManifestAt(dir: string): ExtensionManifest | null {
   }
 }
 
-/** Scan extensions directory for all valid manifests */
+/** Scan extensions directory (node_modules) for all valid manifests */
 export async function discoverManifests(extensionsDir: string): Promise<ExtensionManifest[]> {
   const manifests: ExtensionManifest[] = [];
   if (!existsSync(extensionsDir)) return manifests;
@@ -63,3 +63,20 @@ export async function discoverManifests(extensionsDir: string): Promise<Extensio
   }
   return manifests;
 }
+
+export type BundledManifest = ExtensionManifest & { _dir: string };
+
+/** Scan packages directory for bundled extensions (ext-* dirs) */
+export async function discoverBundledManifests(packagesDir: string): Promise<BundledManifest[]> {
+  const manifests: BundledManifest[] = [];
+  if (!existsSync(packagesDir)) return manifests;
+
+  const entries = await readdir(packagesDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.startsWith("ext-")) continue;
+    const dir = resolve(packagesDir, entry.name);
+    const manifest = readManifestAt(dir);
+    if (manifest) manifests.push({ ...manifest, _dir: dir });
+  }
+  return manifests;
+}

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

@@ -112,6 +112,22 @@ export function registerVscodeCompatHandlers(rpc: RpcChannel): void {
     return { ok: true };
   });
 
+  // --- open PPM tab (generic, any extension can use) ---
+  rpc.onRequest("window:openTab", async (params) => {
+    const [tabType, title, projectId, metadata] = params as [
+      string, string, string | null, Record<string, unknown> | undefined,
+    ];
+    broadcastExtMsg({ type: "tab:open", tabType, title, projectId, closable: true, metadata });
+    return { ok: true };
+  });
+
+  // --- switch PPM project ---
+  rpc.onRequest("window:switchProject", async (params) => {
+    const [projectName] = params as [string];
+    broadcastExtMsg({ type: "project:switch", projectName });
+    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[]];
@@ -155,9 +171,11 @@ export function registerVscodeCompatHandlers(rpc: RpcChannel): void {
   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)
+    // Allow: CWD, ~/.ppm/extensions/, and all registered project paths
     const { getPpmDir } = await import("./ppm-dir.ts");
-    const allowedRoots = [resolve(process.cwd()), resolve(getPpmDir(), "extensions")];
+    const { configService } = await import("./config.service.ts");
+    const projectPaths = configService.get("projects").map((p: { path: string }) => resolve(p.path));
+    const allowedRoots = [resolve(process.cwd()), resolve(getPpmDir(), "extensions"), ...projectPaths];
     const isSafe = allowedRoots.some((root) => {
       const rel = relative(root, resolved);
       return !rel.startsWith("..") && !rel.startsWith("/");
@@ -221,6 +239,54 @@ export function registerVscodeCompatHandlers(rpc: RpcChannel): void {
     }
     return results;
   });
+
+  // --- process spawn (for extensions needing subprocess access) ---
+
+  const ALLOWED_SPAWN_COMMANDS = new Set(["git", "node", "bun", "npx", "sqlite3"]);
+  const BLOCKED_ENV_KEYS = new Set(["PATH", "HOME", "LD_PRELOAD", "DYLD_INSERT_LIBRARIES", "LD_LIBRARY_PATH"]);
+
+  rpc.onRequest("process:spawn", async (params) => {
+    const [cmd, args, cwd, options] = params as [string, string[], string, { timeout?: number; env?: Record<string, string> }?];
+
+    // Security: command allowlist
+    const baseName = cmd.split("/").pop() || cmd;
+    if (!ALLOWED_SPAWN_COMMANDS.has(baseName)) {
+      throw new Error(`process:spawn: command "${cmd}" not allowed. Allowed: ${[...ALLOWED_SPAWN_COMMANDS].join(", ")}`);
+    }
+
+    // Security: CWD must be within allowed roots
+    const safeCwd = await assertSafePath(cwd);
+
+    // Security: block dangerous env overrides
+    const safeEnv = { ...process.env };
+    if (options?.env) {
+      for (const [key, val] of Object.entries(options.env)) {
+        if (!BLOCKED_ENV_KEYS.has(key)) safeEnv[key] = val;
+      }
+    }
+
+    const timeout = options?.timeout ?? 30_000;
+    const proc = Bun.spawn([cmd, ...args], {
+      cwd: safeCwd,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: safeEnv,
+    });
+
+    const timer = setTimeout(() => { try { proc.kill(); } catch {} }, timeout);
+    try {
+      const [stdout, stderr] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+      ]);
+      const exitCode = await proc.exited;
+      clearTimeout(timer);
+      return { stdout, stderr, exitCode };
+    } catch (e) {
+      clearTimeout(timer);
+      throw new Error(`process:spawn failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  });
 }
 
 /** Get a nested value from an object by dot-separated key */

package/src/services/extension.service.ts

@@ -1,10 +1,10 @@
 import { resolve } from "node:path";
 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 { getExtensions, getExtensionById, insertExtension, updateExtension, 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 { parseManifest, discoverManifests, discoverBundledManifests } from "./extension-manifest.ts";
 import { installExtension, removeExtension, devLinkExtension, ensureExtensionsDir } from "./extension-installer.ts";
 import { registerVscodeCompatHandlers } from "./extension-rpc-handlers.ts";
 import { getPpmDir } from "./ppm-dir.ts";
@@ -13,8 +13,11 @@ class ExtensionService {
   private worker: Worker | null = null;
   private rpc: RpcChannel | null = null;
   private activatedIds = new Set<string>();
+  private activationErrors = new Map<string, string>();
   private workerReady = false;
   private installing = new Set<string>();
+  private extensionPaths = new Map<string, string>();
+  private bundledIds = new Set<string>();
 
   // --- Worker lifecycle ---
 
@@ -54,6 +57,9 @@ class ExtensionService {
     if (this.worker) { this.worker.terminate(); this.worker = null; }
     this.workerReady = false;
     this.activatedIds.clear();
+    this.activationErrors.clear();
+    this.extensionPaths.clear();
+    this.bundledIds.clear();
     contributionRegistry.clear();
   }
 
@@ -65,7 +71,29 @@ class ExtensionService {
 
   async discover(): Promise<ExtensionManifest[]> {
     ensureExtensionsDir(resolve(getPpmDir(), "extensions"));
-    return discoverManifests(resolve(getPpmDir(), "extensions"));
+
+    // Discover bundled extensions from packages/ext-*
+    const bundledDir = resolve(import.meta.dir, "../../packages");
+    const bundled = await discoverBundledManifests(bundledDir);
+    for (const m of bundled) {
+      this.extensionPaths.set(m.id, m._dir);
+      this.bundledIds.add(m.id);
+    }
+
+    // Discover user-installed extensions
+    const userExtDir = resolve(getPpmDir(), "extensions");
+    const userManifests = await discoverManifests(userExtDir);
+    for (const m of userManifests) {
+      this.extensionPaths.set(m.id, resolve(userExtDir, "node_modules", m.id));
+    }
+
+    // Merge: user overrides bundled if same id (strip _dir to avoid leaking paths)
+    const byId = new Map(bundled.map((m) => {
+      const { _dir, ...manifest } = m;
+      return [m.id, manifest as ExtensionManifest];
+    }));
+    for (const m of userManifests) byId.set(m.id, m);
+    return [...byId.values()];
   }
 
   async install(name: string): Promise<ExtensionManifest> {
@@ -79,6 +107,9 @@ class ExtensionService {
   }
 
   async remove(id: string): Promise<void> {
+    if (this.bundledIds.has(id)) {
+      throw new Error(`Cannot remove bundled extension "${id}". Use 'ppm ext disable ${id}' instead.`);
+    }
     if (this.activatedIds.has(id)) await this.deactivate(id);
     await removeExtension(id, resolve(getPpmDir(), "extensions"));
     contributionRegistry.unregister(id);
@@ -92,7 +123,8 @@ class ExtensionService {
     if (!row.enabled) throw new Error(`Extension ${id} is disabled`);
 
     const manifest: ExtensionManifest = JSON.parse(row.manifest);
-    const extDir = resolve(resolve(getPpmDir(), "extensions"), "node_modules", id);
+    const extDir = this.extensionPaths.get(id)
+      ?? resolve(resolve(getPpmDir(), "extensions"), "node_modules", id);
     const entryPath = resolve(extDir, manifest.main);
     if (!existsSync(entryPath)) throw new Error(`Entry point not found: ${entryPath}`);
 
@@ -111,15 +143,20 @@ class ExtensionService {
     const port = cfg.get("port") ?? 8080;
     const baseUrl = `http://localhost:${port}`;
 
+    console.log(`[ExtService] activating ${id} (entry: ${entryPath})`);
     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}`);
+    if (!result.ok) {
+      this.activationErrors.set(id, result.error ?? "Unknown activation error");
+      throw new Error(`Failed to activate ${id}: ${result.error}`);
+    }
 
+    this.activationErrors.delete(id);
     this.activatedIds.add(id);
     if (manifest.contributes) contributionRegistry.register(id, manifest.contributes);
     this.broadcastContributions();
-    console.log(`[ExtService] Activated ${id}`);
+    console.log(`[ExtService] activated ${id} successfully`);
   }
 
   async deactivate(id: string): Promise<void> {
@@ -166,7 +203,6 @@ class ExtensionService {
   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);
@@ -187,17 +223,29 @@ class ExtensionService {
     ensureExtensionsDir(resolve(getPpmDir(), "extensions"));
     const manifests = await this.discover();
     for (const m of manifests) {
-      if (!getExtensionById(m.id)) {
+      const existing = getExtensionById(m.id);
+      if (!existing) {
         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),
         });
+      } else {
+        // Always sync manifest from disk so new contributes (keybindings, etc.) are picked up
+        updateExtension(m.id, {
+          version: m.version,
+          display_name: m.displayName ?? null,
+          description: m.description ?? null,
+          icon: m.icon ?? null,
+          manifest: JSON.stringify(m),
+        });
       }
     }
     for (const row of getExtensions()) {
       if (row.enabled !== 1) continue;
+      console.log(`[ExtService] startup: activating ${row.id}...`);
       try { await this.activate(row.id); } catch (e) {
+        this.activationErrors.set(row.id, e instanceof Error ? e.message : String(e));
         console.error(`[ExtService] Failed to activate ${row.id} on startup:`, e);
       }
     }
@@ -211,13 +259,19 @@ class ExtensionService {
   }
 
   isActivated(id: string): boolean { return this.activatedIds.has(id); }
+  isBundled(id: string): boolean { return this.bundledIds.has(id); }
   getExtensionsDir(): string { return resolve(getPpmDir(), "extensions"); }
+  getActivationErrors(): Map<string, string> { return new Map(this.activationErrors); }
 
   /** 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() });
+      const contributions = contributionRegistry.getAll();
+      broadcastExtMsg(this.activationErrors.size > 0
+        ? { type: "contributions:update", contributions, activationErrors: Object.fromEntries(this.activationErrors) }
+        : { type: "contributions:update", contributions },
+      );
     } catch {}
   }
 }

package/src/types/extension-messages.ts

@@ -49,7 +49,9 @@ export type ExtServerMsg =
   | { type: "webview:html"; panelId: string; html: string }
   | { type: "webview:dispose"; panelId: string }
   | { type: "webview:postMessage"; panelId: string; message: unknown }
-  | { type: "contributions:update"; contributions: ExtensionContributes };
+  | { type: "tab:open"; tabType: string; title: string; projectId: string | null; closable?: boolean; metadata?: Record<string, unknown> }
+  | { type: "project:switch"; projectName: string }
+  | { type: "contributions:update"; contributions: ExtensionContributes; activationErrors?: Record<string, string> };
 
 // --- Client → Server messages ---
 

package/src/types/extension.ts

@@ -23,6 +23,7 @@ export interface ExtensionContributes {
   views?: Record<string, ContributedView[]>;
   configuration?: { properties?: Record<string, ConfigProperty> };
   menus?: Record<string, ContributedMenu[]>;
+  keybindings?: ContributedKeybinding[];
 }
 
 export interface ContributedCommand {
@@ -52,6 +53,13 @@ export interface ContributedMenu {
   group?: string;
 }
 
+export interface ContributedKeybinding {
+  command: string;
+  key: string;
+  mac?: string;
+  when?: string;
+}
+
 /** Runtime extension info returned by API */
 export interface ExtensionInfo {
   id: string;

package/src/web/components/editor/code-editor.tsx

@@ -340,22 +340,28 @@ export function CodeEditor({ metadata, tabId }: CodeEditorProps) {
       );
     }
 
-    // Register CodeLens for inline Run buttons on .sql files
+    // Register CodeLens for inline Run buttons on .sql files (scoped to this editor's model)
     if (isSql) {
       codeLensDisposable.current.forEach((d) => d.dispose());
       codeLensDisposable.current = [];
 
+      const thisModel = editor.getModel();
       const cmdId = editor.addCommand(0, (_accessor: unknown, sql: string) => {
         if (sql) runSqlRef.current(sql);
       });
 
-      if (cmdId) {
+      if (cmdId && thisModel) {
         const provider = monaco.languages.registerCodeLensProvider("sql", {
           provideCodeLenses: (model: MonacoType.editor.ITextModel) => {
+            // Only provide lenses for THIS editor's model, not all SQL models
+            if (model !== thisModel) return { lenses: [], dispose: () => {} };
+
             const lenses: MonacoType.languages.CodeLens[] = [];
-            const lines = model.getValue().split("\n");
+            const text = model.getValue();
+            const lines = text.split("\n");
             let stmtStartLine = -1;
             let stmtLines: string[] = [];
+            let dollarBlock = false; // Track DO $$ ... $$ blocks
 
             const addLens = (line: number, stmt: string) => {
               const trimmed = stmt.trim();
@@ -374,7 +380,13 @@ export function CodeEditor({ metadata, tabId }: CodeEditorProps) {
                 stmtLines = [];
               }
               stmtLines.push(lines[i]!);
-              if (trimmed.endsWith(";")) {
+
+              // Detect $$ dollar-quoted block start/end
+              const dollarMatches = (trimmed.match(/\$\$/g) || []).length;
+              if (dollarMatches % 2 === 1) dollarBlock = !dollarBlock;
+
+              // Only split on ; when NOT inside a $$ block
+              if (!dollarBlock && trimmed.endsWith(";")) {
                 addLens(stmtStartLine, stmtLines.join("\n"));
                 stmtStartLine = -1;
                 stmtLines = [];