@hienlh/ppm 0.9.0-beta.8 → 0.9.1

package/docs/system-architecture.md

@@ -140,10 +140,24 @@ POST   /api/db/connections/:id/query              → Execute query (readonly ch
 PATCH  /api/db/connections/:id/cell               → Update cell value (single)
 GET    /api/upgrade/status                        → Get current + available versions, install method
 POST   /api/upgrade/apply                         → Install new version, trigger supervisor self-replace
+GET    /api/project/:name/workspace               → Get saved workspace layout + metadata
+PUT    /api/project/:name/workspace               → Save workspace layout (layout JSON)
 WS     /ws/project/:name/chat/:sessionId          → Chat streaming
 WS     /ws/project/:name/terminal/:id             → Terminal I/O
 ```
 
+**URL Format (Deterministic Tabs, v0.8.77+):**
+```
+/project/{name}                          → Project root (project switcher)
+/project/{name}/editor/{filePath}        → Open editor tab (e.g., src/index.ts)
+/project/{name}/chat/{provider}/{sessionId} → Open chat tab
+/project/{name}/terminal/{index}         → Open terminal tab
+/project/{name}/database/{connId}/{table} → Open database browser
+/project/{name}/git-graph                → Git history graph (singleton)
+/project/{name}/settings                 → Settings panel (singleton)
+```
+Tab IDs are deterministic: `{type}:{identifier}` (e.g., `editor:src/index.ts`, `chat:claude/abc123`). Deep links auto-create missing tabs.
+
 ---
 
 ### Service Layer (Business Logic)
@@ -161,7 +175,7 @@ WS     /ws/project/:name/terminal/:id             → Terminal I/O
 |---------|---------|-------------|
 | **ChatService** | Session management, message streaming | createSession, streamMessage, getHistory |
 | **ConfigService** | Config loading (YAML→SQLite migration) | load, save, getToken |
-| **DbService** | SQLite persistence (9 tables, WAL, connections/accounts CRUD) | getDb, openTestDb, getConnections, insertConnection, deleteConnection, getTableCache |
+| **DbService** | SQLite persistence (10 tables, WAL, connections/accounts/workspace CRUD) | getDb, openTestDb, getWorkspace, setWorkspace, getConnections, insertConnection, deleteConnection, getTableCache |
 | **TableCacheService** | Cache table metadata, search tables | syncTables, searchTables, invalidateCache |
 | **GitService** | Git command execution | status, diff, commit, stage, branch |
 | **FileService** | File operations with validation | read, write, tree, delete, mkdir |
@@ -260,11 +274,11 @@ PPM supports multiple AI providers through a generic `AIProvider` interface and
 - Enforce security (no parent directory access)
 
 **Key Patterns:**
-- SQLite: WAL mode, foreign keys, lazy init, schema v1 with 6 tables
+- SQLite: WAL mode, foreign keys, lazy init, schema v10 (10 tables: config, connections, accounts, usage_history, session_logs, push_subscriptions, session_map, table_metadata, session_logs, workspace_state)
 - Path validation: `projectPath/relativePath` only, reject `..`
 - Caching: Directory trees cached with TTL
 - Error handling: Descriptive messages (file not found, permission denied)
-- Migration: Automatic YAML→SQLite migration on first run with new db.service
+- Migration: Automatic YAML→SQLite migration on first run with new db.service; schema auto-upgrade on version bump
 
 ---
 
@@ -284,6 +298,24 @@ PPM supports multiple AI providers through a generic `AIProvider` interface and
 const messages = chatStore((s) => s.messages); // Subscribe to messages only
 ```
 
+#### Workspace Sync (v0.8.77+)
+
+**Deterministic Tab IDs & URL Routing:**
+- Tab IDs derived from type + metadata: `deriveTabId(type, metadata) → {type}:{identifier}`
+- Examples: `editor:src/index.ts`, `chat:claude/abc123`, `terminal:1`, `git-graph`
+- URLs rebuilt from active tab: `/project/{name}/{type}/{identifier}`
+- Deep linking: URL → `parseUrlState()` → auto-create tabs if missing
+
+**Workspace Persistence:**
+1. **Client**: PanelStore layout (grid, panels, tabs) cached in localStorage per project
+2. **Server**: Workspace JSON persisted in `workspace_state` SQLite table
+3. **Sync Flow:**
+   - User loads project → fetch workspace from server (GET `/api/project/:name/workspace`)
+   - Latest-wins: server `updated_at` vs client localStorage timestamp
+   - Panel layout changes debounced (1.5s) → POST to server
+   - On reconnect: server layout restored, client edits queued
+4. **Cross-Device:** Any device can load workspace, browser restores exact grid + active tabs
+
 ---
 
 ## Communication Protocols
@@ -1066,6 +1098,403 @@ const queryConfig = {
 const query = new Query(messages, queryConfig);
 ```
 
+---
+
+## Extension System (v0.9.0+)
+
+### Overview
+
+PPM Extension System enables VSCode-compatible, npm-installable extensions that run in isolated Bun Worker threads. Crash-safe, permission-based, with RPC messaging between main process and worker, and WebSocket bridge for real-time UI updates.
+
+**Architecture (3-tier):**
+```
+Extension Code (Bun Worker)        ← @ppm/vscode-compat API
+  │ RPC (postMessage)
+  ▼
+Main Process (Hono/Bun)            ← extension-rpc-handlers.ts
+  │ WebSocket (/ws/extensions)
+  ▼
+Browser (React)                    ← Zustand store + React components
+```
+
+**Key components:**
+- **Package Format:** npm packages (`@ppm/ext-database`, `@ppm/ext-docker`, etc.)
+- **Installation:** `~/.ppm/extensions/node_modules/{id}/`
+- **Lifecycle:** Install → Enable → Activate → Deactivate → Remove
+- **Worker Isolation:** Each activated extension runs in a Bun Worker (crash-safe, 10s activation timeout)
+- **Communication:** RPC (Worker↔Main) + WebSocket (Main↔Browser)
+- **API Shim:** `@ppm/vscode-compat` — VSCode-compatible API (commands, window, workspace)
+- **State Storage:** globalState + workspaceState in SQLite via Memento
+- **UI Bridge:** StatusBar, TreeView, WebviewPanel, QuickPick, InputBox, Notifications
+- **Contributions:** Commands, views, configuration contributed via manifest
+
+### Manifest Format
+
+Extension metadata defined in `package.json` under `ppm` key:
+
+```json
+{
+  "name": "@ppm/ext-database",
+  "version": "1.0.0",
+  "main": "dist/extension.js",
+  "ppm": {
+    "displayName": "Database Browser",
+    "description": "Browse and query databases",
+    "icon": "database.svg",
+    "engines": { "ppm": ">=0.9.0" },
+    "activationEvents": ["onView:databases"],
+    "contributes": {
+      "commands": [
+        {
+          "command": "ppm.database.openConnection",
+          "title": "Open Database Connection",
+          "category": "Database"
+        }
+      ],
+      "views": {
+        "explorer": [
+          {
+            "id": "databases",
+            "name": "Databases",
+            "type": "tree"
+          }
+        ]
+      },
+      "configuration": {
+        "properties": {
+          "ppm.database.maxRows": {
+            "type": "number",
+            "default": 1000,
+            "description": "Max rows to fetch per query"
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+**Fields:**
+- `engines.ppm` — PPM version requirement
+- `activationEvents` — When extension activates (e.g., `onView:databases`, `onCommand:ext.activate`)
+- `contributes` — UI elements + commands contributed by extension
+
+### Installation & Lifecycle
+
+**Installation** (`ppm ext install @ppm/ext-database`):
+1. Fetch package from npm
+2. Extract to `~/.ppm/extensions/node_modules/{id}/`
+3. Parse manifest from `package.json`
+4. Store in SQLite `extensions` table (enabled=1)
+5. Discover contributions
+
+**Activation** (`ppm ext enable @ppm/ext-database` or automatic):
+1. Load manifest + entry point from disk
+2. Spawn Bun Worker (process isolation)
+3. Create scoped `@ppm/vscode-compat` API instance (RPC-backed)
+4. Call `activate(context, vscodeApi)` with 10s timeout
+5. Register contributions in `contributionRegistry`
+6. Broadcast `contributions:update` via WS to all connected browsers
+7. Mark as activated
+
+**Deactivation:**
+1. Unregister contributions
+2. Terminate worker
+3. Clear persisted state if needed
+
+**Removal** (`ppm ext remove @ppm/ext-database`):
+1. Deactivate if active
+2. Delete from `~/.ppm/extensions/`
+3. Remove from SQLite
+4. Unregister contributions
+
+### RPC Protocol (Extension ↔ Main Process)
+
+**Message Types:**
+
+1. **Request** (extension → main)
+   ```json
+   {
+     "type": "request",
+     "id": 1,
+     "method": "storage:get",
+     "params": ["extId", "global", "key"]
+   }
+   ```
+
+2. **Response** (main → extension)
+   ```json
+   {
+     "type": "response",
+     "id": 1,
+     "result": "value"
+   }
+   ```
+
+3. **Event** (both directions)
+   ```json
+   {
+     "type": "event",
+     "event": "file:changed",
+     "data": { "path": "/path/to/file" }
+   }
+   ```
+
+**Built-in Methods:**
+- `storage:get(extId, scope, key)` — Get persistent value
+- `storage:set(extId, scope, key, value)` — Set persistent value
+- `storage:delete(extId, scope, key)` — Delete key
+- Extension can define custom RPC methods via `rpc.onRequest(method, handler)`
+
+### State Storage
+
+**Database Schema:**
+
+```sql
+CREATE TABLE extension_storage (
+  ext_id TEXT NOT NULL,
+  scope TEXT NOT NULL,  -- 'global' | 'workspace'
+  key TEXT NOT NULL,
+  value TEXT,           -- JSON-serialized
+  PRIMARY KEY (ext_id, scope, key)
+);
+```
+
+**Scopes:**
+- **globalState** — Persists across all projects (e.g., user settings, cache)
+- **workspaceState** — Project-specific state (e.g., open panel state)
+
+**API** (inside extension):
+```typescript
+// In activate(context: ExtensionContext)
+const globalVal = context.globalState.get("lastConnection", "default");
+await context.globalState.update("lastConnection", "my-db");
+
+const wsVal = context.workspaceState.get("selectedTable");
+await context.workspaceState.update("selectedTable", "users");
+```
+
+### WebSocket Bridge (Extension ↔ Browser)
+
+Extensions interact with the browser UI via a dedicated WebSocket at `/ws/extensions`. The main process translates between Worker RPC and WS messages.
+
+**Server → Client (ExtServerMsg):** `tree:update`, `tree:refresh`, `statusbar:update/remove`, `notification`, `quickpick:show`, `inputbox:show`, `webview:create/html/dispose/postMessage`, `contributions:update`
+
+**Client → Server (ExtClientMsg):** `ready`, `command:execute`, `tree:expand/click`, `webview:message`, `quickpick:resolve`, `inputbox:resolve`, `notification:action`
+
+**Message routing:**
+- Extension calls `vscode.window.showInformationMessage()` → RPC → `extension-rpc-handlers.ts` → `broadcastExtMsg()` → WS → `use-extension-ws` hook → toast notification
+- Browser user clicks tree item → WS `tree:click` → `extensions.ts` → Worker RPC `ext:command:execute` → CommandService → extension handler
+- Webview iframe postMessage → parent → CustomEvent → WS `webview:message` → Worker RPC `ext:webview:message` → EventEmitter → extension's `onDidReceiveMessage` handler
+
+**Request/response pattern:** QuickPick, InputBox, and notification actions use `requestFromBrowser(msg, trackingId, 30s timeout)` — sends WS message and awaits browser response via pending Promise map.
+
+### UI Components
+
+Extension UI state lives in Zustand (`extension-store.ts`) and renders via React:
+- **StatusBar** — Fixed bottom bar with left/right aligned items
+- **TreeView** — Recursive tree with expand/collapse, renders in sidebar for `ext:*` tabs
+- **WebviewPanel** — Sandboxed iframe (`allow-scripts` only), `acquireVsCodeApi()` shim auto-injected
+- **QuickPick** — Filterable picker with keyboard nav, bottom-sheet on mobile
+- **InputBox** — Text input dialog with password mode support
+- **Command Palette** — Extension commands merged with built-in commands
+
+### Contribution Registry
+
+**Purpose:** Central registry of all extension contributions (commands, views, etc.)
+
+**Storage:** In-memory map during runtime
+
+**Endpoints:**
+- `GET /api/extensions/contributions` — List all active contributions
+
+**Contribution Types:**
+1. **Commands** — Callable actions (e.g., `ppm.database.openConnection`)
+   - Registered: `registry.registerCommand(extId, command)`
+   - Invoked: `POST /api/extensions/{extId}/commands/{command}`
+
+2. **Views** — Sidebar panels or tree views
+   - Registered: `registry.registerView(extId, view)`
+   - Rendered in UI based on `type` (tree, webview)
+
+3. **Configuration** — Settings schema
+   - Registered: `registry.registerConfig(extId, schema)`
+   - Merged with global settings
+
+### CLI Commands
+
+```bash
+ppm ext list                      # List installed extensions
+ppm ext install @ppm/ext-database # Install from npm
+ppm ext remove @ppm/ext-database  # Uninstall
+ppm ext enable @ppm/ext-database  # Enable extension
+ppm ext disable @ppm/ext-database # Disable extension
+ppm ext dev /path/to/ext-src      # Symlink local extension for dev
+ppm ext config <ext-id> <key> <value> # Set config value
+```
+
+**Dev Mode** (`ppm ext dev /path/to/src`):
+- Symlinks local extension to `~/.ppm/extensions/node_modules/`
+- Auto-reloads on file change
+- Extension runs from source (TypeScript not compiled)
+
+### REST API
+
+**Endpoints** (`src/server/routes/extensions.ts`):
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| **GET** | `/api/extensions` | List installed extensions |
+| **POST** | `/api/extensions` | Install extension (body: {name, version?}) |
+| **GET** | `/api/extensions/:id` | Get extension info (manifest, status) |
+| **DELETE** | `/api/extensions/:id` | Remove extension |
+| **PATCH** | `/api/extensions/:id` | Update extension (body: {enabled}) |
+| **GET** | `/api/extensions/contributions` | List all contributions (commands, views, config) |
+| **POST** | `/api/extensions/:id/commands/:cmd` | Invoke extension command |
+
+**Example: Install Extension**
+```bash
+POST /api/extensions
+Content-Type: application/json
+
+{ "name": "@ppm/ext-database", "version": "1.0.0" }
+
+# Response
+{
+  "ok": true,
+  "data": {
+    "id": "@ppm/ext-database",
+    "version": "1.0.0",
+    "displayName": "Database Browser",
+    "enabled": true,
+    "activated": false
+  }
+}
+```
+
+### Service Layer
+
+**ExtensionService** (`src/services/extension.service.ts`):
+- `discover()` — Scan `~/.ppm/extensions/` for installed packages
+- `install(name)` — Fetch from npm, install locally
+- `remove(id)` — Uninstall extension
+- `activate(id)` — Load + run extension in worker
+- `deactivate(id)` — Terminate worker, cleanup
+- `parseManifest(pkg)` — Extract manifest from package.json
+- `setExtensionState(extId, scope, key, value)` — Persist state
+
+**ExtensionInstaller** (`src/services/extension-installer.ts`):
+- `installExtension(name, dir)` — npm install + verify
+- `removeExtension(id, dir)` — rm -rf extension directory
+- `devLinkExtension(localPath)` — Symlink for local dev
+
+**ExtensionManifest** (`src/services/extension-manifest.ts`):
+- `parseManifest(pkg)` — Validate + parse ppm section
+- `discoverManifests(dir)` — Scan all installed extensions
+
+**RpcChannel** (`src/services/extension-rpc.ts`):
+- Bidirectional RPC messaging
+- Request/response matching by ID
+- Event broadcasting
+- Timeout handling
+
+### Worker Integration
+
+**ExtensionHostWorker** (`src/services/extension-host-worker.ts`):
+- Worker-side code that loads + activates extension
+- Loads extension code into worker context
+- Exposes ExtensionContext API (globalState, workspaceState, subscriptions)
+- Handles incoming RPC messages
+- Communicates back to main process
+
+**Design:**
+```
+Main Process                Worker
+     ↓                         ↓
+ ExtensionService    ExtensionHostWorker
+     ↓                         ↓
+ RpcChannel ←────────────→ RpcChannel
+     ↓                         ↓
+ Sends: {                Extension Code
+   type: "request",      (User's ext.ts)
+   method: "..."        ↓
+ }                   activate(context)
+     ↓                   ↓
+ Handlers respond  context.storage.get()
+     ↑                   ↑
+     └─────────────────┘
+```
+
+### Dev Workflow
+
+**Creating an Extension:**
+
+1. Create npm package:
+   ```bash
+   npm init -y @ppm/ext-my-feature
+   npm install @ppm/extension-api
+   ```
+
+2. Write `src/extension.ts`:
+   ```typescript
+   import type { ExtensionContext } from "@ppm/extension-api";
+
+   export async function activate(context: ExtensionContext) {
+     console.log(`Extension ${context.extensionId} activated!`);
+     
+     const val = context.globalState.get("count", 0);
+     await context.globalState.update("count", val + 1);
+   }
+
+   export function deactivate() {
+     console.log("Extension deactivated");
+   }
+   ```
+
+3. Add to `package.json`:
+   ```json
+   {
+     "ppm": {
+       "displayName": "My Feature",
+       "main": "dist/extension.js",
+       "contributes": {
+         "commands": [...]
+       }
+     }
+   }
+   ```
+
+4. Install locally for dev:
+   ```bash
+   ppm ext dev /path/to/ext-my-feature
+   ```
+
+5. Extension auto-activates based on `activationEvents`, state persists
+
+### Crash Safety
+
+**Worker Isolation:**
+- Each extension in isolated Bun Worker thread
+- Worker crash doesn't crash main process
+- Error events logged, extension marked as failed
+- Main process continues operating
+
+**Cleanup:**
+- Worker terminates → cleanup timer expires after 5min
+- Persisted state preserved in SQLite (not lost on crash)
+- Next activation reloads from disk, state auto-restored
+
+### Future Enhancements (Phase 2+)
+
+- **UI Webview Support** — Extensions define HTML/React UI panels
+- **Extension Settings UI** — Auto-generate UI from `contributes.configuration`
+- **Hot Reload** — Auto-reload extension on file change during dev
+- **Marketplace** — Browse, rate, publish extensions (v1.0+)
+- **Permissions** — User prompt for sensitive operations
+- **Inter-Extension API** — Extensions can call each other via RPC
+
+---
+
 **Tool Allow List:**
 - All MCP tools automatically allowed via wildcard `mcp__*`
 - MCP server connection failures don't block chat (logged as warning)

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "@hienlh/ppm",
-  "version": "0.9.0-beta.8",
+  "version": "0.9.1",
   "description": "Personal Project Manager — mobile-first web IDE with AI assistance",
   "author": "hienlh",
   "license": "MIT",
   "module": "src/index.ts",
   "type": "module",
+  "workspaces": ["packages/*"],
   "bin": {
     "ppm": "src/index.ts"
   },
   "scripts": {
     "dev": "concurrently \"bun run dev:server\" \"bun run dev:web\"",
-    "dev:server": "bun run --hot src/index.ts start --profile dev -f",
+    "dev:server": "bun run --hot src/server/index.ts __serve__ 8081 0.0.0.0 '' dev",
     "dev:web": "bun run vite --config vite.config.ts",
     "build:web": "bun run vite build --config vite.config.ts",
     "build": "bun run build:web && bun build src/index.ts --compile --outfile dist/ppm",
@@ -32,7 +33,8 @@
     "esbuild": "^0.27.4",
     "tailwindcss": "^4.2.1",
     "vite": "^8.0.0",
-    "vite-plugin-pwa": "^1.2.0"
+    "vite-plugin-pwa": "^1.2.0",
+    "workbox-precaching": "^7.4.0"
   },
   "peerDependencies": {
     "typescript": "^5.9.3"
@@ -60,6 +62,7 @@
     "lucide-react": "^0.577.0",
     "marked": "^17.0.4",
     "mermaid": "^11.13.0",
+    "monaco-editor": "0.55.1",
     "next-themes": "^0.4.6",
     "postgres": "^3.4.8",
     "qrcode-terminal": "^0.12.0",

package/packages/ext-database/package.json

@@ -0,0 +1,41 @@
+{
+  "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" }
+    ],
+    "views": {
+      "sidebar": [
+        { "id": "ppm-db.connections", "name": "DB Connections", "type": "tree" }
+      ]
+    },
+    "menus": {
+      "commandPalette": [
+        { "command": "ppm-db.openViewer" },
+        { "command": "ppm-db.runQuery" }
+      ],
+      "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

@@ -0,0 +1,142 @@
+/**
+ * TreeDataProvider for database connections → tables → columns.
+ * Fetches data from PPM REST API (/api/db/*).
+ */
+
+interface ConnectionNode {
+  id: string;
+  name: string;
+  type: "connection" | "table" | "column";
+  connectionId?: number;
+  connectionName?: string;
+  connectionType?: string;
+  connectionColor?: string | null;
+  schemaName?: string;
+  dataType?: string;
+}
+
+interface ApiConnection {
+  id: number;
+  name: string;
+  type: string;
+  color: 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.getConnections();
+    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 isTable = element.type === "table";
+    const isCol = element.type === "column";
+
+    return {
+      id: element.id,
+      label: element.name,
+      description: isCol ? element.dataType : undefined,
+      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: isConn ? (element.connectionType === "postgres" ? "PG" : "DB") : undefined,
+      actions: isConn ? [
+        { icon: "refresh", tooltip: "Refresh tables", command: "ppm-db.refreshConnection", commandArgs: [element.connectionId] },
+      ] : undefined,
+    };
+  }
+
+  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,
+      }));
+    } 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,
+      }));
+    } 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 [];
+    }
+  }
+}