@hienlh/ppm 0.9.0-beta.8 → 0.9.1

package/src/services/cloud.service.ts

@@ -354,6 +354,7 @@ export async function sendHeartbeat(tunnelUrl: string): Promise<boolean> {
         secret_key: device.secret_key,
         tunnel_url: tunnelUrl,
         status: "online",
+        name: device.name,
       }),
     });
     return res.ok;
@@ -362,12 +363,16 @@ export async function sendHeartbeat(tunnelUrl: string): Promise<boolean> {
   }
 }
 
-let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+// Survive Bun --hot reloads: persist timer ref across module re-evaluations
+const CLOUD_HOT_KEY = "__PPM_CLOUD_HEARTBEAT__" as const;
+const cloudHotState = ((globalThis as any)[CLOUD_HOT_KEY] ??= {
+  heartbeatTimer: null as ReturnType<typeof setInterval> | null,
+}) as { heartbeatTimer: ReturnType<typeof setInterval> | null };
 
 /** Start periodic heartbeat (call once after tunnel URL is obtained) */
 export function startHeartbeat(tunnelUrl: string): void {
   // Clear any existing heartbeat to prevent duplicates on restart
-  if (heartbeatTimer) clearInterval(heartbeatTimer);
+  if (cloudHotState.heartbeatTimer) clearInterval(cloudHotState.heartbeatTimer);
 
   // Initial heartbeat immediately
   sendHeartbeat(tunnelUrl).then((ok) => {
@@ -376,16 +381,16 @@ export function startHeartbeat(tunnelUrl: string): void {
   });
 
   // Periodic heartbeat every 5 minutes
-  heartbeatTimer = setInterval(() => {
+  cloudHotState.heartbeatTimer = setInterval(() => {
     sendHeartbeat(tunnelUrl).catch(() => {});
   }, HEARTBEAT_INTERVAL_MS);
 }
 
 /** Stop periodic heartbeat */
 export function stopHeartbeat(): void {
-  if (heartbeatTimer) {
-    clearInterval(heartbeatTimer);
-    heartbeatTimer = null;
+  if (cloudHotState.heartbeatTimer) {
+    clearInterval(cloudHotState.heartbeatTimer);
+    cloudHotState.heartbeatTimer = null;
   }
 }
 

package/src/services/contribution-registry.ts

@@ -0,0 +1,110 @@
+import type { ExtensionContributes, ContributedCommand, ContributedView, ContributedMenu } from "../types/extension.ts";
+
+/**
+ * In-memory registry of all contribution points from enabled extensions.
+ * Populated when extensions activate, cleared when they deactivate.
+ */
+class ContributionRegistry {
+  private commands = new Map<string, ContributedCommand & { extId: string }>();
+  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 }>>();
+
+  register(extId: string, contributes: ExtensionContributes): void {
+    if (contributes.commands) {
+      for (const cmd of contributes.commands) {
+        this.commands.set(cmd.command, { ...cmd, extId });
+      }
+    }
+    if (contributes.views) {
+      for (const [location, views] of Object.entries(contributes.views)) {
+        if (!this.views.has(location)) this.views.set(location, new Map());
+        const locationMap = this.views.get(location)!;
+        for (const view of views) {
+          locationMap.set(view.id, { ...view, extId });
+        }
+      }
+    }
+    if (contributes.configuration?.properties) {
+      this.configs.set(extId, contributes.configuration.properties);
+    }
+    if (contributes.menus) {
+      for (const [location, items] of Object.entries(contributes.menus)) {
+        if (!this.menus.has(location)) this.menus.set(location, []);
+        const list = this.menus.get(location)!;
+        for (const item of items) {
+          list.push({ ...item, extId });
+        }
+      }
+    }
+  }
+
+  unregister(extId: string): void {
+    for (const [key, cmd] of this.commands) {
+      if (cmd.extId === extId) this.commands.delete(key);
+    }
+    for (const [, locationMap] of this.views) {
+      for (const [key, view] of locationMap) {
+        if (view.extId === extId) locationMap.delete(key);
+      }
+    }
+    for (const [location, items] of this.menus) {
+      this.menus.set(location, items.filter((m) => m.extId !== extId));
+    }
+    this.configs.delete(extId);
+  }
+
+  getCommands(): Array<ContributedCommand & { extId: string }> {
+    return [...this.commands.values()];
+  }
+
+  getViews(location?: string): Array<ContributedView & { extId: string }> {
+    if (location) {
+      return [...(this.views.get(location)?.values() ?? [])];
+    }
+    const all: Array<ContributedView & { extId: string }> = [];
+    for (const locationMap of this.views.values()) {
+      all.push(...locationMap.values());
+    }
+    return all;
+  }
+
+  getViewLocations(): string[] {
+    return [...this.views.keys()];
+  }
+
+  getConfiguration(extId?: string): Record<string, Record<string, unknown>> {
+    if (extId) {
+      const cfg = this.configs.get(extId);
+      return cfg ? { [extId]: cfg } : {};
+    }
+    return Object.fromEntries(this.configs);
+  }
+
+  /** Get all contributions as a single object (for API responses) */
+  getAll() {
+    const viewsByLocation: Record<string, Array<ContributedView & { extId: string }>> = {};
+    for (const location of this.views.keys()) {
+      viewsByLocation[location] = this.getViews(location);
+    }
+    const menusByLocation: Record<string, Array<ContributedMenu & { extId: string }>> = {};
+    for (const [location, items] of this.menus) {
+      menusByLocation[location] = items;
+    }
+    return {
+      commands: this.getCommands(),
+      views: viewsByLocation,
+      menus: menusByLocation,
+      configuration: this.getConfiguration(),
+    };
+  }
+
+  clear(): void {
+    this.commands.clear();
+    this.views.clear();
+    this.configs.clear();
+    this.menus.clear();
+  }
+}
+
+export const contributionRegistry = new ContributionRegistry();

package/src/services/db.service.ts

@@ -4,7 +4,7 @@ import { homedir } from "node:os";
 import { mkdirSync, existsSync } from "node:fs";
 
 const PPM_DIR = process.env.PPM_HOME || resolve(homedir(), ".ppm");
-const CURRENT_SCHEMA_VERSION = 8;
+const CURRENT_SCHEMA_VERSION = 12;
 
 let db: Database | null = null;
 let dbProfile: string | null = null;
@@ -248,6 +248,95 @@ function runMigrations(database: Database): void {
       PRAGMA user_version = 8;
     `);
   }
+
+  if (current < 9) {
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS session_pins (
+        session_id TEXT PRIMARY KEY,
+        pinned_at TEXT DEFAULT (datetime('now'))
+      );
+
+      PRAGMA user_version = 9;
+    `);
+  }
+
+  if (current < 10) {
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS workspace_state (
+        project_name TEXT PRIMARY KEY,
+        layout_json  TEXT NOT NULL,
+        updated_at   TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      PRAGMA user_version = 10;
+    `);
+  }
+
+  if (current < 11) {
+    try {
+      database.exec(`ALTER TABLE session_map ADD COLUMN project_path TEXT`);
+    } catch {
+      // Column may already exist
+    }
+    // Backfill project_path from projects table where project_name matches
+    database.exec(`
+      UPDATE session_map SET project_path = (
+        SELECT path FROM projects WHERE projects.name = session_map.project_name
+      ) WHERE project_path IS NULL AND project_name IS NOT NULL
+    `);
+    database.exec(`PRAGMA user_version = 11`);
+  }
+
+  if (current < 12) {
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS extensions (
+        id TEXT PRIMARY KEY,
+        version TEXT NOT NULL,
+        display_name TEXT,
+        description TEXT,
+        icon TEXT,
+        enabled INTEGER DEFAULT 1,
+        manifest TEXT NOT NULL,
+        installed_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS extension_storage (
+        ext_id TEXT NOT NULL,
+        scope TEXT NOT NULL,
+        key TEXT NOT NULL,
+        value TEXT,
+        PRIMARY KEY (ext_id, scope, key),
+        FOREIGN KEY (ext_id) REFERENCES extensions(id) ON DELETE CASCADE
+      );
+
+      PRAGMA user_version = 12;
+    `);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Workspace helpers
+// ---------------------------------------------------------------------------
+
+export interface WorkspaceRow {
+  project_name: string;
+  layout_json: string;
+  updated_at: string;
+}
+
+export function getWorkspace(projectName: string): WorkspaceRow | null {
+  return getDb().query(
+    "SELECT project_name, layout_json, updated_at FROM workspace_state WHERE project_name = ?",
+  ).get(projectName) as WorkspaceRow | null;
+}
+
+export function setWorkspace(projectName: string, layoutJson: string): string {
+  const now = new Date().toISOString();
+  getDb().query(
+    "INSERT INTO workspace_state (project_name, layout_json, updated_at) VALUES (?, ?, ?) ON CONFLICT(project_name) DO UPDATE SET layout_json = excluded.layout_json, updated_at = excluded.updated_at",
+  ).run(projectName, layoutJson, now);
+  return now;
 }
 
 // ---------------------------------------------------------------------------
@@ -318,10 +407,15 @@ export function getSessionMapping(ppmId: string): string | null {
   return row?.sdk_id ?? null;
 }
 
-export function setSessionMapping(ppmId: string, sdkId: string, projectName?: string): void {
+export function getSessionProjectPath(ppmId: string): string | null {
+  const row = getDb().query("SELECT project_path FROM session_map WHERE ppm_id = ?").get(ppmId) as { project_path: string } | null;
+  return row?.project_path ?? null;
+}
+
+export function setSessionMapping(ppmId: string, sdkId: string, projectName?: string, projectPath?: string): void {
   getDb().query(
-    "INSERT INTO session_map (ppm_id, sdk_id, project_name) VALUES (?, ?, ?) ON CONFLICT(ppm_id) DO UPDATE SET sdk_id = excluded.sdk_id, project_name = excluded.project_name",
-  ).run(ppmId, sdkId, projectName ?? null);
+    "INSERT INTO session_map (ppm_id, sdk_id, project_name, project_path) VALUES (?, ?, ?, ?) ON CONFLICT(ppm_id) DO UPDATE SET sdk_id = excluded.sdk_id, project_name = COALESCE(excluded.project_name, session_map.project_name), project_path = COALESCE(excluded.project_path, session_map.project_path)",
+  ).run(ppmId, sdkId, projectName ?? null, projectPath ?? null);
 }
 
 export function getAllSessionMappings(): Record<string, string> {
@@ -358,6 +452,33 @@ export function getSessionTitles(sessionIds: string[]): Record<string, string> {
   return result;
 }
 
+// ---------------------------------------------------------------------------
+// Session pin helpers
+// ---------------------------------------------------------------------------
+
+export function pinSession(sessionId: string): void {
+  getDb().query(
+    "INSERT INTO session_pins (session_id, pinned_at) VALUES (?, datetime('now')) ON CONFLICT(session_id) DO UPDATE SET pinned_at = datetime('now')",
+  ).run(sessionId);
+}
+
+export function unpinSession(sessionId: string): void {
+  getDb().query("DELETE FROM session_pins WHERE session_id = ?").run(sessionId);
+}
+
+export function getPinnedSessionIds(): Set<string> {
+  const rows = getDb().query("SELECT session_id FROM session_pins ORDER BY pinned_at DESC").all() as { session_id: string }[];
+  return new Set(rows.map((r) => r.session_id));
+}
+
+export function deleteSessionMapping(ppmId: string): void {
+  getDb().query("DELETE FROM session_map WHERE ppm_id = ?").run(ppmId);
+}
+
+export function deleteSessionTitle(sessionId: string): void {
+  getDb().query("DELETE FROM session_titles WHERE session_id = ?").run(sessionId);
+}
+
 // ---------------------------------------------------------------------------
 // Push subscription helpers
 // ---------------------------------------------------------------------------
@@ -717,5 +838,61 @@ export function incrementAccountRequests(id: string): void {
   getDb().query("UPDATE accounts SET total_requests = total_requests + 1 WHERE id = ?").run(id);
 }
 
+// ---------------------------------------------------------------------------
+// Extension helpers
+// ---------------------------------------------------------------------------
+
+import type { ExtensionRow, ExtensionStorageRow } from "../types/extension.ts";
+
+export function getExtensions(): ExtensionRow[] {
+  return getDb().query("SELECT * FROM extensions ORDER BY display_name, id").all() as ExtensionRow[];
+}
+
+export function getExtensionById(id: string): ExtensionRow | null {
+  return getDb().query("SELECT * FROM extensions WHERE id = ?").get(id) as ExtensionRow | null;
+}
+
+export function insertExtension(row: Omit<ExtensionRow, "installed_at" | "updated_at">): void {
+  getDb().query(
+    `INSERT INTO extensions (id, version, display_name, description, icon, enabled, manifest)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+  ).run(row.id, row.version, row.display_name, row.description, row.icon, row.enabled, row.manifest);
+}
+
+export function updateExtension(id: string, updates: Partial<Pick<ExtensionRow, "version" | "display_name" | "description" | "icon" | "enabled" | "manifest">>): void {
+  const sets: string[] = [];
+  const vals: unknown[] = [];
+  if (updates.version !== undefined) { sets.push("version = ?"); vals.push(updates.version); }
+  if (updates.display_name !== undefined) { sets.push("display_name = ?"); vals.push(updates.display_name); }
+  if (updates.description !== undefined) { sets.push("description = ?"); vals.push(updates.description); }
+  if (updates.icon !== undefined) { sets.push("icon = ?"); vals.push(updates.icon); }
+  if (updates.enabled !== undefined) { sets.push("enabled = ?"); vals.push(updates.enabled); }
+  if (updates.manifest !== undefined) { sets.push("manifest = ?"); vals.push(updates.manifest); }
+  if (sets.length === 0) return;
+  sets.push("updated_at = datetime('now')");
+  vals.push(id);
+  getDb().query(`UPDATE extensions SET ${sets.join(", ")} WHERE id = ?`).run(...(vals as SQLQueryBindings[]));
+}
+
+export function deleteExtension(id: string): void {
+  getDb().query("DELETE FROM extensions WHERE id = ?").run(id);
+}
+
+export function getExtensionStorage(extId: string, scope: string): ExtensionStorageRow[] {
+  return getDb().query("SELECT * FROM extension_storage WHERE ext_id = ? AND scope = ?").all(extId, scope) as ExtensionStorageRow[];
+}
+
+export function setExtensionStorageValue(extId: string, scope: string, key: string, value: string | null): void {
+  getDb().query(
+    `INSERT INTO extension_storage (ext_id, scope, key, value)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(ext_id, scope, key) DO UPDATE SET value = excluded.value`,
+  ).run(extId, scope, key, value);
+}
+
+export function deleteExtensionStorage(extId: string): void {
+  getDb().query("DELETE FROM extension_storage WHERE ext_id = ?").run(extId);
+}
+
 // Auto-close on process exit
 process.on("beforeExit", closeDb);

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

@@ -0,0 +1,160 @@
+/**
+ * Extension Host Worker — runs inside a Bun Worker thread.
+ * Loads, activates, and deactivates extensions in isolation.
+ * Communicates with the main process via typed RPC (postMessage).
+ */
+import { RpcChannel } from "./extension-rpc.ts";
+import { createVscodeCompat } from "@ppm/vscode-compat";
+import type { WindowService } from "@ppm/vscode-compat/src/window.ts";
+import type { CommandService } from "@ppm/vscode-compat/src/commands.ts";
+import type { Disposable, RpcMessage } from "../types/extension.ts";
+
+// Active extension instances: id → { module, context, deactivate, services }
+const activeExtensions = new Map<string, {
+  deactivate?: () => void | Promise<void>;
+  context: { subscriptions: Disposable[] };
+  window?: WindowService;
+  commands?: CommandService;
+}>();
+
+const rpc = new RpcChannel((msg) => postMessage(msg));
+
+// Listen for messages from main process
+declare const self: Worker;
+self.addEventListener("message", (event: MessageEvent<RpcMessage>) => {
+  rpc.handleMessage(event.data);
+});
+
+// --- RPC handlers ---
+
+rpc.onRequest("ext:activate", async (params) => {
+  const [extId, entryPath, extensionPath, storedState, baseUrl] = params as [string, string, string, Record<string, Record<string, string | null>>?, string?];
+  if (activeExtensions.has(extId)) return { ok: true, already: true };
+
+  // Expose server base URL so extensions can use fetch() with absolute URLs
+  if (baseUrl) (globalThis as any).__PPM_BASE_URL__ = baseUrl;
+
+  // Create RpcClient adapter for vscode-compat (Worker's RPC → vscode-compat interface)
+  const rpcClient = {
+    request: <T = unknown>(method: string, ...p: unknown[]) => rpc.sendRequest<T>(method, ...p),
+    notify: (event: string, data: unknown) => rpc.sendEvent(event, data),
+  };
+
+  // Create vscode-compat API scoped to this extension
+  const api = createVscodeCompat({
+    extensionId: extId,
+    extensionPath,
+    storagePath: `${extensionPath}/.storage`,
+    rpc: rpcClient,
+    storedState: storedState as { global?: Record<string, string | null>; workspace?: Record<string, string | null> },
+  });
+
+  const context = api._createContext();
+
+  try {
+    const mod = await import(entryPath);
+    const activateFn = mod.activate || mod.default?.activate;
+    if (typeof activateFn === "function") {
+      // Activation timeout: 10s max to prevent hanging extensions
+      const activatePromise = Promise.resolve(activateFn(context, api));
+      const timeoutPromise = new Promise((_, reject) =>
+        setTimeout(() => reject(new Error(`Activation timeout (10s) for ${extId}`)), 10_000),
+      );
+      await Promise.race([activatePromise, timeoutPromise]);
+    }
+    activeExtensions.set(extId, {
+      deactivate: mod.deactivate || mod.default?.deactivate,
+      context,
+      window: api.window as WindowService,
+      commands: api.commands as CommandService,
+    });
+    return { ok: true };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`[ExtHost] Failed to activate ${extId}:`, msg);
+    return { ok: false, error: msg };
+  }
+});
+
+rpc.onRequest("ext:deactivate", async (params) => {
+  const [extId] = params as [string];
+  const ext = activeExtensions.get(extId);
+  if (!ext) return { ok: true, already: true };
+
+  try {
+    if (typeof ext.deactivate === "function") {
+      await ext.deactivate();
+    }
+    // Dispose all subscriptions
+    for (const sub of ext.context.subscriptions) {
+      try { (sub as Disposable).dispose(); } catch {}
+    }
+    activeExtensions.delete(extId);
+    return { ok: true };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`[ExtHost] Failed to deactivate ${extId}:`, msg);
+    activeExtensions.delete(extId);
+    return { ok: false, error: msg };
+  }
+});
+
+rpc.onRequest("ext:command:execute", async (params) => {
+  const [command, ...args] = params as [string, ...unknown[]];
+  for (const [, ext] of activeExtensions) {
+    if (ext.commands) {
+      try {
+        const result = await (ext.commands as any).executeCommand(command, ...args);
+        return { ok: true, result };
+      } catch {
+        // Command not found in this extension, try next
+      }
+    }
+  }
+  return { ok: false, error: `Command not found: ${command}` };
+});
+
+// Deliver webview messages from browser → extension's onDidReceiveMessage
+rpc.onRequest("ext:webview:message", async (params) => {
+  const [panelId, message] = params as [string, unknown];
+  for (const [, ext] of activeExtensions) {
+    if (!ext.window) continue;
+    try {
+      if ((ext.window as any)._deliverWebviewMessage(panelId, message)) {
+        return { ok: true };
+      }
+    } catch (e) {
+      console.error(`[ExtHost] webview:message error (${panelId}):`, e);
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  return { ok: false, error: `No handler for panel ${panelId}` };
+});
+
+// Handle tree:expand — get children for a tree node
+rpc.onRequest("ext:tree:expand", async (params) => {
+  const [viewId, itemId] = params as [string, string | undefined];
+  for (const [, ext] of activeExtensions) {
+    if (ext.window) {
+      try {
+        const items = await (ext.window as any)._getTreeChildren(viewId, itemId);
+        if (items.length > 0) return { ok: true, items };
+      } catch (e) {
+        console.error(`[ExtHost] tree:expand error (${viewId}):`, e);
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+      }
+    }
+  }
+  return { ok: true, items: [] };
+});
+
+rpc.onRequest("ext:list-active", () => {
+  return [...activeExtensions.keys()];
+});
+
+rpc.onRequest("ext:ping", () => "pong");
+
+// ExtensionContext is now created by @ppm/vscode-compat's createVscodeCompat()._createContext()
+
+// Notify main process that worker is ready
+rpc.sendEvent("worker:ready", {});

package/src/services/extension-installer.ts

@@ -0,0 +1,112 @@
+import { resolve } from "node:path";
+import { existsSync, mkdirSync, writeFileSync, rmSync, symlinkSync } from "node:fs";
+import type { ExtensionManifest } from "../types/extension.ts";
+import { getExtensionById, insertExtension, updateExtension, deleteExtension, deleteExtensionStorage } from "./db.service.ts";
+import { readManifestAt } from "./extension-manifest.ts";
+
+const INSTALL_TIMEOUT = 60_000;
+const NPM_PACKAGE_RE = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*(@[^@]+)?$/;
+
+/** Ensure ~/.ppm/extensions/ dir + isolated package.json exist */
+export function ensureExtensionsDir(extensionsDir: string): void {
+  if (!existsSync(extensionsDir)) {
+    mkdirSync(extensionsDir, { recursive: true });
+  }
+  const pkgJsonPath = resolve(extensionsDir, "package.json");
+  if (!existsSync(pkgJsonPath)) {
+    writeFileSync(pkgJsonPath, JSON.stringify({ name: "ppm-extensions", private: true, dependencies: {} }, null, 2));
+  }
+}
+
+/** Install an npm package into the extensions directory and persist to DB */
+export async function installExtension(name: string, extensionsDir: string): Promise<ExtensionManifest> {
+  if (!NPM_PACKAGE_RE.test(name)) throw new Error(`Invalid package name: ${name}`);
+  ensureExtensionsDir(extensionsDir);
+
+  const proc = Bun.spawn(["bun", "add", name], {
+    cwd: extensionsDir,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const timeout = setTimeout(() => proc.kill(), INSTALL_TIMEOUT);
+  const exitCode = await proc.exited;
+  clearTimeout(timeout);
+
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`Install failed (exit ${exitCode}): ${stderr.slice(0, 500)}`);
+  }
+
+  const pkgDir = resolve(extensionsDir, "node_modules", name);
+  const manifest = readManifestAt(pkgDir);
+  if (!manifest) throw new Error(`Installed ${name} but no valid manifest found`);
+
+  upsertExtensionInDb(manifest);
+  console.log(`[ExtService] Installed ${manifest.id}@${manifest.version}`);
+  return manifest;
+}
+
+/** Remove an extension from disk + DB */
+export async function removeExtension(id: string, extensionsDir: string): Promise<void> {
+  try {
+    const proc = Bun.spawn(["bun", "remove", id], {
+      cwd: extensionsDir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    await proc.exited;
+  } catch (e) {
+    console.error(`[ExtService] npm remove ${id} failed (DB record still removed):`, e);
+  }
+
+  deleteExtensionStorage(id);
+  deleteExtension(id);
+  console.log(`[ExtService] Removed ${id}`);
+}
+
+/** Symlink a local extension path for development */
+export function devLinkExtension(localPath: string, extensionsDir: string): ExtensionManifest {
+  const absPath = resolve(localPath);
+  const manifest = readManifestAt(absPath);
+  if (!manifest) throw new Error(`No valid package.json at ${absPath}`);
+
+  ensureExtensionsDir(extensionsDir);
+  const nodeModules = resolve(extensionsDir, "node_modules");
+  if (!existsSync(nodeModules)) mkdirSync(nodeModules, { recursive: true });
+
+  const targetDir = resolve(nodeModules, manifest.id);
+  const parentDir = resolve(targetDir, "..");
+  if (!existsSync(parentDir)) mkdirSync(parentDir, { recursive: true });
+
+  if (existsSync(targetDir)) rmSync(targetDir, { recursive: true, force: true });
+  symlinkSync(absPath, targetDir, "dir");
+
+  upsertExtensionInDb(manifest);
+  console.log(`[ExtService] Dev-linked ${manifest.id} → ${absPath}`);
+  return manifest;
+}
+
+/** Insert or update extension record in DB */
+function upsertExtensionInDb(manifest: ExtensionManifest): void {
+  const existing = getExtensionById(manifest.id);
+  if (existing) {
+    updateExtension(manifest.id, {
+      version: manifest.version,
+      display_name: manifest.displayName ?? null,
+      description: manifest.description ?? null,
+      icon: manifest.icon ?? null,
+      manifest: JSON.stringify(manifest),
+    });
+  } else {
+    insertExtension({
+      id: manifest.id,
+      version: manifest.version,
+      display_name: manifest.displayName ?? null,
+      description: manifest.description ?? null,
+      icon: manifest.icon ?? null,
+      enabled: 1,
+      manifest: JSON.stringify(manifest),
+    });
+  }
+}