@hienlh/ppm 0.9.0-beta.9 → 0.9.2

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),
+    });
+  }
+}

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;
+}