@hienlh/ppm 0.13.48 → 0.13.50

package/src/services/db.service.ts

@@ -610,6 +610,34 @@ function runMigrations(database: Database): void {
     try { database.exec("ALTER TABLE session_metadata ADD COLUMN last_known_title TEXT"); } catch { /* column exists */ }
     database.exec("PRAGMA user_version = 23");
   }
+
+  if (current < 25) {
+    // Re-create extension tables if missing (e.g. after accidental drop)
+    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 = 25;
+    `);
+  }
 }
 
 // ---------------------------------------------------------------------------

package/src/types/extension.ts

@@ -1,6 +1,6 @@
 /** Extension manifest — parsed from package.json of an installed extension */
 export interface ExtensionManifest {
-  id: string; // npm package name, e.g. @ppm/ext-database
+  id: string; // npm package name, e.g. @ppm/ext-myext
   version: string;
   main: string; // JS entry point relative to extension root
   displayName?: string;

package/src/web/components/settings/extension-manager-section.tsx

@@ -97,7 +97,7 @@ export function ExtensionManagerSection() {
             value={installName}
             onChange={(e) => setInstallName(e.target.value)}
             onKeyDown={(e) => { if (e.key === "Enter") handleInstall(); }}
-            placeholder="npm package name (e.g. @ppm/ext-database)"
+            placeholder="npm package name (e.g. @ppm/ext-myext)"
             className="h-8 text-xs flex-1"
           />
           <Button
@@ -122,7 +122,7 @@ export function ExtensionManagerSection() {
             <Input
               value={devPath}
               onChange={(e) => setDevPath(e.target.value)}
-              placeholder="Local path (e.g. ./packages/ext-database)"
+              placeholder="Local path (e.g. ./packages/ext-myext)"
               className="h-8 text-xs flex-1"
             />
             <Button

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

@@ -323,6 +323,11 @@ export const usePanelStore = create<PanelStore>()((set, get) => {
       if (!panel) return;
       const pid = panel.id;
 
+      // Clear persisted terminal session so reopening creates a fresh PTY
+      if (tabId.startsWith("terminal:")) {
+        try { localStorage.removeItem(`ppm:terminal-session:${tabId}`); } catch { /* */ }
+      }
+
       set((s) => {
         const p = s.panels[pid]!;
         const newTabs = p.tabs.filter((t) => t.id !== tabId);

package/dist/web/assets/keybindings-store-Dn9ANcCK.js

@@ -1 +0,0 @@
-import"./vendor-markdown-0Mxgxy0L.js";import"./api-client-DIhJ5qVW.js";import{T as e}from"./index-hxAGD2rx.js";export{e as useKeybindingsStore};

package/dist/web/assets/notification-store-DyVQiPv9.js

@@ -1 +0,0 @@
-import"./vendor-markdown-0Mxgxy0L.js";import"./api-client-DIhJ5qVW.js";import{j as e}from"./index-hxAGD2rx.js";export{e as useNotificationStore};

package/packages/ext-database/package.json

@@ -1,48 +0,0 @@
-{
-  "name": "@ppm/ext-database",
-  "version": "0.1.0",
-  "main": "src/extension.ts",
-  "engines": { "ppm": ">=0.9.0" },
-  "activationEvents": ["onCommand:ppm-db.openViewer", "onView:ppm-db.connections"],
-  "contributes": {
-    "commands": [
-      { "command": "ppm-db.openViewer", "title": "Database: Open Viewer" },
-      { "command": "ppm-db.runQuery", "title": "Database: Run SQL Query" },
-      { "command": "ppm-db.refreshConnections", "title": "Database: Refresh Connections", "icon": "refresh" },
-      { "command": "ppm-db.addConnection", "title": "Add connection", "icon": "plus" },
-      { "command": "ppm-db.editConnection", "title": "Database: Edit Connection" },
-      { "command": "ppm-db.deleteConnection", "title": "Database: Delete Connection" },
-      { "command": "ppm-db.testConnection", "title": "Database: Test Connection" },
-      { "command": "ppm-db.exportConnections", "title": "Database: Export Connections" },
-      { "command": "ppm-db.importConnections", "title": "Database: Import Connections" }
-    ],
-    "views": {
-      "sidebar": [
-        { "id": "ppm-db.connections", "name": "DB Connections", "type": "tree" }
-      ]
-    },
-    "menus": {
-      "commandPalette": [
-        { "command": "ppm-db.openViewer" },
-        { "command": "ppm-db.runQuery" },
-        { "command": "ppm-db.exportConnections" },
-        { "command": "ppm-db.importConnections" }
-      ],
-      "view/title": [
-        { "command": "ppm-db.refreshConnections", "when": "view == ppm-db.connections", "group": "navigation" },
-        { "command": "ppm-db.addConnection", "when": "view == ppm-db.connections", "group": "navigation" }
-      ]
-    },
-    "configuration": {
-      "properties": {
-        "ppm-db.maxRows": { "type": "number", "default": 100, "description": "Max rows to display" },
-        "ppm-db.autoConnect": { "type": "boolean", "default": true, "description": "Auto-connect on open" }
-      }
-    }
-  },
-  "ppm": {
-    "displayName": "Database Viewer",
-    "icon": "database",
-    "webviewDir": "webview"
-  }
-}

package/packages/ext-database/src/connection-tree.ts

@@ -1,201 +0,0 @@
-/**
- * TreeDataProvider for database connections → tables → columns.
- * Fetches data from PPM REST API (/api/db/*).
- */
-
-interface ConnectionNode {
-  id: string;
-  name: string;
-  type: "connection" | "group" | "table" | "column";
-  connectionId?: number;
-  connectionName?: string;
-  connectionType?: string;
-  connectionColor?: string | null;
-  connectionReadonly?: number;
-  groupName?: string | null;
-  schemaName?: string;
-  dataType?: string;
-  rowCount?: number;
-  children?: ConnectionNode[];
-}
-
-interface ApiConnection {
-  id: number;
-  name: string;
-  type: string;
-  color: string | null;
-  readonly: number;
-  group_name: string | null;
-}
-
-interface ApiTable {
-  name: string;
-  schema: string;
-  rowCount: number;
-}
-
-interface ApiColumn {
-  name: string;
-  type: string;
-  nullable: boolean;
-  pk: boolean;
-  defaultValue: string | null;
-}
-
-export class ConnectionTreeProvider {
-  private _onDidChange: { fire: (el?: ConnectionNode) => void; event: unknown };
-  private baseUrl: string;
-
-  constructor(eventEmitter: { fire: (el?: ConnectionNode) => void; event: unknown }, baseUrl = "") {
-    this._onDidChange = eventEmitter;
-    this.baseUrl = baseUrl;
-  }
-
-  get onDidChangeTreeData() {
-    return this._onDidChange.event;
-  }
-
-  refresh(): void {
-    this._onDidChange.fire(undefined);
-  }
-
-  async getChildren(element?: ConnectionNode): Promise<ConnectionNode[]> {
-    if (!element) return this.getRootNodes();
-    if (element.type === "group") return element.children ?? [];
-    if (element.type === "connection") return this.getTables(element);
-    if (element.type === "table") return this.getColumns(element);
-    return [];
-  }
-
-  getTreeItem(element: ConnectionNode): Record<string, unknown> {
-    const isConn = element.type === "connection";
-    const isGroup = element.type === "group";
-    const isTable = element.type === "table";
-    const isCol = element.type === "column";
-
-    // Table description: row count
-    let description: string | undefined;
-    if (isCol) description = element.dataType;
-    else if (isTable && element.rowCount !== undefined) description = `${element.rowCount.toLocaleString()} rows`;
-
-    // Connection badge: type + readonly
-    let badge: string | undefined;
-    if (isConn) {
-      badge = element.connectionType === "postgres" ? "PG" : "DB";
-      if (element.connectionReadonly === 1) badge += " 🔒";
-    }
-
-    return {
-      id: element.id,
-      label: element.name,
-      description,
-      collapsibleState: isCol ? "none" : "collapsed",
-      contextValue: element.type,
-      command: isTable ? "ppm-db.openViewer" : undefined,
-      commandArgs: isTable
-        ? [element.connectionId, element.connectionName ?? "Database", element.name, element.schemaName ?? "public"]
-        : undefined,
-      color: isConn ? (element.connectionColor ?? undefined) : undefined,
-      badge,
-      actions: isConn ? [
-        { icon: "refresh", tooltip: "Refresh tables", command: "ppm-db.refreshConnection", commandArgs: [element.connectionId] },
-        { icon: "edit", tooltip: "Edit connection", command: "ppm-db.editConnection", commandArgs: [element.connectionId] },
-        { icon: "trash", tooltip: "Delete connection", command: "ppm-db.deleteConnection", commandArgs: [element.connectionId, element.name] },
-      ] : isGroup ? [] : undefined,
-    };
-  }
-
-  /** Build root tree: group nodes wrapping connection nodes, or flat if no groups */
-  private async getRootNodes(): Promise<ConnectionNode[]> {
-    const connections = await this.getConnections();
-    // Group by group_name
-    const groups = new Map<string, ConnectionNode[]>();
-    for (const conn of connections) {
-      const key = conn.groupName ?? "__ungrouped__";
-      const list = groups.get(key) ?? [];
-      list.push(conn);
-      groups.set(key, list);
-    }
-    // If only one group (ungrouped), return connections flat
-    if (groups.size <= 1 && groups.has("__ungrouped__")) {
-      return connections;
-    }
-    // Build group nodes
-    const result: ConnectionNode[] = [];
-    const sortedKeys = Array.from(groups.keys()).sort((a, b) => {
-      if (a === "__ungrouped__") return 1;
-      if (b === "__ungrouped__") return -1;
-      return a.localeCompare(b);
-    });
-    for (const key of sortedKeys) {
-      const label = key === "__ungrouped__" ? "Ungrouped" : key;
-      result.push({
-        id: `group:${key}`,
-        name: label,
-        type: "group",
-        children: groups.get(key) ?? [],
-      });
-    }
-    return result;
-  }
-
-  private async getConnections(): Promise<ConnectionNode[]> {
-    try {
-      const res = await fetch(`${this.baseUrl}/api/db/connections`);
-      const json = await res.json() as { ok: boolean; data?: ApiConnection[] };
-      if (!json.ok || !json.data) return [];
-      return json.data.map((c) => ({
-        id: `conn:${c.id}`,
-        name: c.name,
-        type: "connection" as const,
-        connectionId: c.id,
-        connectionType: c.type,
-        connectionColor: c.color,
-        connectionReadonly: c.readonly,
-        groupName: c.group_name,
-      }));
-    } catch {
-      return [];
-    }
-  }
-
-  private async getTables(conn: ConnectionNode): Promise<ConnectionNode[]> {
-    try {
-      const res = await fetch(`${this.baseUrl}/api/db/connections/${conn.connectionId}/tables`);
-      const json = await res.json() as { ok: boolean; data?: ApiTable[] };
-      if (!json.ok || !json.data) return [];
-      return json.data.map((t) => ({
-        id: `table:${conn.connectionId}:${t.schema}.${t.name}`,
-        name: t.name,
-        type: "table" as const,
-        connectionId: conn.connectionId,
-        connectionName: conn.name,
-        connectionType: conn.connectionType,
-        schemaName: t.schema,
-        rowCount: t.rowCount,
-      }));
-    } catch {
-      return [];
-    }
-  }
-
-  private async getColumns(table: ConnectionNode): Promise<ConnectionNode[]> {
-    try {
-      const schema = table.schemaName ?? "public";
-      const res = await fetch(
-        `${this.baseUrl}/api/db/connections/${table.connectionId}/schema?table=${encodeURIComponent(table.name)}&schema=${schema}`,
-      );
-      const json = await res.json() as { ok: boolean; data?: ApiColumn[] };
-      if (!json.ok || !json.data) return [];
-      return json.data.map((c) => ({
-        id: `col:${table.connectionId}:${table.name}.${c.name}`,
-        name: c.name,
-        type: "column" as const,
-        connectionId: table.connectionId,
-        dataType: c.type + (c.pk ? " PK" : ""),
-      }));
-    } catch {
-      return [];
-    }
-  }
-}