@spooky-sync/cli 0.0.1-canary.69 → 0.0.1-canary.71

package/devtools-mcp/dist/bridge.d.ts

@@ -0,0 +1,23 @@
+interface ConnectedTab {
+    tabId: number;
+    url?: string;
+    title?: string;
+}
+export declare class Bridge {
+    private wss;
+    private extensionSocket;
+    private connectedTabs;
+    private pendingRequests;
+    private requestCounter;
+    private pingInterval;
+    get isConnected(): boolean;
+    getConnectedTabs(): ConnectedTab[];
+    start(): Promise<void>;
+    private startPing;
+    private stopPing;
+    private handleMessage;
+    request(method: string, params?: Record<string, unknown>, tabId?: number): Promise<unknown>;
+    private getDefaultTabId;
+    stop(): Promise<void>;
+}
+export {};

package/devtools-mcp/dist/bridge.js

@@ -0,0 +1,155 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import { isBridgeResponse, isBridgeNotification, BRIDGE_PORT, } from './protocol.js';
+const REQUEST_TIMEOUT_MS = 10_000;
+export class Bridge {
+    wss = null;
+    extensionSocket = null;
+    connectedTabs = new Map();
+    pendingRequests = new Map();
+    requestCounter = 0;
+    pingInterval = null;
+    get isConnected() {
+        return this.extensionSocket?.readyState === WebSocket.OPEN;
+    }
+    getConnectedTabs() {
+        return Array.from(this.connectedTabs.values());
+    }
+    start() {
+        const port = Number.parseInt(process.env.SP00KY_MCP_PORT || '', 10) || BRIDGE_PORT;
+        return new Promise((resolve, reject) => {
+            this.wss = new WebSocketServer({ host: '127.0.0.1', port }, () => {
+                process.stderr.write(`[sp00ky-mcp] Bridge listening on ws://127.0.0.1:${port}\n`);
+                resolve();
+            });
+            this.wss.on('error', (err) => {
+                process.stderr.write(`[sp00ky-mcp] Bridge error: ${err.message}\n`);
+                reject(err);
+            });
+            this.wss.on('connection', (ws) => {
+                process.stderr.write('[sp00ky-mcp] Extension connected\n');
+                // Only allow one extension connection at a time
+                if (this.extensionSocket) {
+                    this.extensionSocket.close();
+                }
+                this.extensionSocket = ws;
+                // Start keepalive pings
+                this.startPing(ws);
+                ws.on('message', (data) => {
+                    try {
+                        const msg = JSON.parse(data.toString());
+                        this.handleMessage(msg);
+                    }
+                    catch (err) {
+                        process.stderr.write(`[sp00ky-mcp] Bad message: ${err}\n`);
+                    }
+                });
+                ws.on('close', () => {
+                    process.stderr.write('[sp00ky-mcp] Extension disconnected\n');
+                    if (this.extensionSocket === ws) {
+                        this.extensionSocket = null;
+                        this.connectedTabs.clear();
+                        this.stopPing();
+                        // Reject all pending requests
+                        for (const [id, pending] of this.pendingRequests) {
+                            pending.reject(new Error('Extension disconnected'));
+                            clearTimeout(pending.timer);
+                            this.pendingRequests.delete(id);
+                        }
+                    }
+                });
+                ws.on('error', (err) => {
+                    process.stderr.write(`[sp00ky-mcp] Socket error: ${err.message}\n`);
+                });
+            });
+        });
+    }
+    startPing(ws) {
+        this.stopPing();
+        this.pingInterval = setInterval(() => {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.ping();
+            }
+        }, 20_000);
+    }
+    stopPing() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+    }
+    handleMessage(msg) {
+        // Handle response to a pending request
+        if (isBridgeResponse(msg)) {
+            const pending = this.pendingRequests.get(msg.id);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.pendingRequests.delete(msg.id);
+                if (msg.error) {
+                    pending.reject(new Error(msg.error.message));
+                }
+                else {
+                    pending.resolve(msg.result);
+                }
+            }
+            return;
+        }
+        // Handle notifications from extension
+        if (isBridgeNotification(msg)) {
+            if (msg.method === 'tabsChanged') {
+                this.connectedTabs.clear();
+                const tabs = msg.params.tabs;
+                for (const tab of tabs) {
+                    this.connectedTabs.set(tab.tabId, tab);
+                }
+            }
+            return;
+        }
+    }
+    async request(method, params = {}, tabId) {
+        if (!this.extensionSocket || this.extensionSocket.readyState !== WebSocket.OPEN) {
+            throw new Error('No extension connected. Make sure the Sp00ky DevTools extension is running and has a page with Sp00ky open.');
+        }
+        const id = `mcp-${++this.requestCounter}`;
+        const resolvedTabId = tabId ?? this.getDefaultTabId();
+        const request = {
+            jsonrpc: '2.0',
+            id,
+            method,
+            params,
+            ...(resolvedTabId !== undefined ? { tabId: resolvedTabId } : {}),
+        };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Request timed out after ${REQUEST_TIMEOUT_MS}ms: ${method}`));
+            }, REQUEST_TIMEOUT_MS);
+            this.pendingRequests.set(id, { resolve, reject, timer });
+            // oxlint-disable-next-line no-non-null-assertion
+            this.extensionSocket.send(JSON.stringify(request));
+        });
+    }
+    getDefaultTabId() {
+        const tabs = this.getConnectedTabs();
+        return tabs.length > 0 ? tabs[0].tabId : undefined;
+    }
+    async stop() {
+        this.stopPing();
+        for (const [id, pending] of this.pendingRequests) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error('Bridge shutting down'));
+            this.pendingRequests.delete(id);
+        }
+        if (this.extensionSocket) {
+            this.extensionSocket.close();
+            this.extensionSocket = null;
+        }
+        return new Promise((resolve) => {
+            if (this.wss) {
+                this.wss.close(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+}

package/devtools-mcp/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/devtools-mcp/dist/index.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { Bridge } from './bridge.js';
+import { SurrealClient } from './surreal.js';
+import { createServer } from './server.js';
+async function main() {
+    const bridge = new Bridge();
+    await bridge.start();
+    const surreal = process.env.SURREAL_URL
+        ? new SurrealClient({
+            url: process.env.SURREAL_URL,
+            namespace: process.env.SURREAL_NS ?? 'main',
+            database: process.env.SURREAL_DB ?? 'main',
+            username: process.env.SURREAL_USER ?? 'root',
+            password: process.env.SURREAL_PASS ?? 'root',
+        })
+        : null;
+    if (surreal) {
+        process.stderr.write(`[sp00ky-mcp] Direct DB mode enabled (${process.env.SURREAL_URL})\n`);
+    }
+    const server = createServer(bridge, surreal);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    process.stderr.write('[sp00ky-mcp] MCP server running on stdio\n');
+    // Graceful shutdown
+    const cleanup = async () => {
+        process.stderr.write('[sp00ky-mcp] Shutting down...\n');
+        await bridge.stop();
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+}
+main().catch((err) => {
+    process.stderr.write(`[sp00ky-mcp] Fatal error: ${err.message}\n`);
+    process.exit(1);
+});

package/devtools-mcp/dist/protocol.d.ts

@@ -0,0 +1,34 @@
+export interface BridgeRequest {
+    jsonrpc: '2.0';
+    id: string;
+    method: string;
+    params: Record<string, unknown>;
+    tabId?: number;
+}
+export interface BridgeResponse {
+    jsonrpc: '2.0';
+    id: string;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+    };
+}
+export interface BridgeNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params: Record<string, unknown>;
+}
+export type BridgeMessage = BridgeRequest | BridgeResponse | BridgeNotification;
+export declare const BRIDGE_METHODS: {
+    readonly GET_STATE: "getState";
+    readonly RUN_QUERY: "runQuery";
+    readonly GET_TABLE_DATA: "getTableData";
+    readonly UPDATE_TABLE_ROW: "updateTableRow";
+    readonly DELETE_TABLE_ROW: "deleteTableRow";
+    readonly CLEAR_HISTORY: "clearHistory";
+};
+export declare const BRIDGE_PORT = 9315;
+export declare function isBridgeResponse(msg: unknown): msg is BridgeResponse;
+export declare function isBridgeRequest(msg: unknown): msg is BridgeRequest;
+export declare function isBridgeNotification(msg: unknown): msg is BridgeNotification;

package/devtools-mcp/dist/protocol.js

@@ -0,0 +1,37 @@
+// Shared message types for MCP Server <-> Chrome Extension bridge (JSON-RPC 2.0 style)
+// Methods the MCP server can call on the extension
+export const BRIDGE_METHODS = {
+    GET_STATE: 'getState',
+    RUN_QUERY: 'runQuery',
+    GET_TABLE_DATA: 'getTableData',
+    UPDATE_TABLE_ROW: 'updateTableRow',
+    DELETE_TABLE_ROW: 'deleteTableRow',
+    CLEAR_HISTORY: 'clearHistory',
+};
+export const BRIDGE_PORT = 9315;
+export function isBridgeResponse(msg) {
+    return (typeof msg === 'object' &&
+        msg !== null &&
+        'jsonrpc' in msg &&
+        msg.jsonrpc === '2.0' &&
+        'id' in msg &&
+        ('result' in msg || 'error' in msg));
+}
+export function isBridgeRequest(msg) {
+    return (typeof msg === 'object' &&
+        msg !== null &&
+        'jsonrpc' in msg &&
+        msg.jsonrpc === '2.0' &&
+        'method' in msg &&
+        'id' in msg &&
+        !('result' in msg) &&
+        !('error' in msg));
+}
+export function isBridgeNotification(msg) {
+    return (typeof msg === 'object' &&
+        msg !== null &&
+        'jsonrpc' in msg &&
+        msg.jsonrpc === '2.0' &&
+        'method' in msg &&
+        !('id' in msg));
+}

package/devtools-mcp/dist/server.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { Bridge } from './bridge.js';
+import type { SurrealClient } from './surreal.js';
+export declare function createServer(bridge: Bridge, surreal?: SurrealClient | null): McpServer;

package/devtools-mcp/dist/server.js

@@ -0,0 +1,319 @@
+import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { BRIDGE_METHODS } from './protocol.js';
+function json(data) {
+    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+}
+export function createServer(bridge, surreal) {
+    const server = new McpServer({
+        name: 'sp00ky-devtools',
+        version: '0.0.1',
+    });
+    // --- Tools ---
+    server.tool('list_connections', 'List browser tabs connected to Sp00ky DevTools', {}, async () => {
+        return json({ connected: bridge.isConnected, tabs: bridge.getConnectedTabs() });
+    });
+    server.tool('get_state', 'Get the full Sp00ky DevTools state (events, queries, auth, database)', { tabId: z.number().optional().describe('Browser tab ID (uses first connected tab if omitted)') }, async ({ tabId }) => {
+        if (!bridge.isConnected) {
+            throw new Error('No extension connected. get_state requires the Sp00ky DevTools browser extension.');
+        }
+        const result = await bridge.request(BRIDGE_METHODS.GET_STATE, {}, tabId);
+        return json(result);
+    });
+    server.tool('run_query', 'Execute a SurrealQL query against the database', {
+        query: z.string().describe('SurrealQL query to execute'),
+        target: z.enum(['local', 'remote']).optional().default('remote').describe('Query target: local or remote database'),
+        tabId: z.number().optional().describe('Browser tab ID'),
+    }, async ({ query, target, tabId }) => {
+        if (bridge.isConnected) {
+            const result = await bridge.request(BRIDGE_METHODS.RUN_QUERY, { query, target }, tabId);
+            return json(result);
+        }
+        if (surreal) {
+            const result = await surreal.query(query);
+            return json(result);
+        }
+        throw new Error('No extension connected and no direct database configured. Set SURREAL_URL or connect the browser extension.');
+    });
+    server.tool('list_tables', 'List all database tables', { tabId: z.number().optional().describe('Browser tab ID') }, async ({ tabId }) => {
+        if (bridge.isConnected) {
+            const state = (await bridge.request(BRIDGE_METHODS.GET_STATE, {}, tabId));
+            const tables = state?.database?.tables ?? [];
+            return json(tables);
+        }
+        if (surreal) {
+            const result = await surreal.query('INFO FOR DB;');
+            const info = result;
+            const tables = info?.[0]?.result?.tables ?? info?.[0]?.tables ?? {};
+            return json(Object.keys(tables));
+        }
+        throw new Error('No extension connected and no direct database configured.');
+    });
+    server.tool('get_table_data', 'Fetch records from a database table', {
+        tableName: z.string().describe('Name of the table'),
+        limit: z.number().optional().default(100).describe('Max number of records to return'),
+        tabId: z.number().optional().describe('Browser tab ID'),
+    }, async ({ tableName, limit, tabId }) => {
+        if (bridge.isConnected) {
+            const result = await bridge.request(BRIDGE_METHODS.GET_TABLE_DATA, { tableName }, tabId);
+            return json(result);
+        }
+        if (surreal) {
+            const result = await surreal.query(`SELECT * FROM \`${tableName}\` LIMIT ${limit};`);
+            return json(result);
+        }
+        throw new Error('No extension connected and no direct database configured.');
+    });
+    server.tool('update_table_row', 'Update a record in a database table', {
+        tableName: z.string().optional().describe('Name of the table (used when browser extension is connected)'),
+        recordId: z.string().describe('Record ID to update (e.g. "users:abc123")'),
+        updates: z.record(z.unknown()).describe('Fields to update'),
+        tabId: z.number().optional().describe('Browser tab ID'),
+    }, async ({ tableName, recordId, updates, tabId }) => {
+        if (bridge.isConnected) {
+            const result = await bridge.request(BRIDGE_METHODS.UPDATE_TABLE_ROW, { tableName, recordId, updates }, tabId);
+            return json(result);
+        }
+        if (surreal) {
+            const result = await surreal.query(`UPDATE ${recordId} MERGE ${JSON.stringify(updates)};`);
+            return json(result);
+        }
+        throw new Error('No extension connected and no direct database configured.');
+    });
+    server.tool('delete_table_row', 'Delete a record from a database table', {
+        tableName: z.string().optional().describe('Name of the table (used when browser extension is connected)'),
+        recordId: z.string().describe('Record ID to delete (e.g. "users:abc123")'),
+        tabId: z.number().optional().describe('Browser tab ID'),
+    }, async ({ tableName, recordId, tabId }) => {
+        if (bridge.isConnected) {
+            const result = await bridge.request(BRIDGE_METHODS.DELETE_TABLE_ROW, { tableName, recordId }, tabId);
+            return json(result);
+        }
+        if (surreal) {
+            const result = await surreal.query(`DELETE ${recordId};`);
+            return json(result);
+        }
+        throw new Error('No extension connected and no direct database configured.');
+    });
+    server.tool('get_active_queries', 'Get all active live queries and their data', { tabId: z.number().optional().describe('Browser tab ID') }, async ({ tabId }) => {
+        if (bridge.isConnected) {
+            const state = (await bridge.request(BRIDGE_METHODS.GET_STATE, {}, tabId));
+            return json(state?.activeQueries ?? []);
+        }
+        if (surreal) {
+            const result = await surreal.query('SELECT * FROM _00_query;');
+            return json(result);
+        }
+        throw new Error('No extension connected and no direct database configured.');
+    });
+    server.tool('get_query_timings', 'Per-query processing-time breakdown for debugging: SSP phases (parse/plan/snapshot at registration; store-apply/circuit-step/transform per ingest, plus whole-ingest `ssp` wall time), local & remote record-fetch, and frontend reconcile — each as { lastMs, p50, p90, p99, count } — sorted slowest-first. Requires the Sp00ky DevTools browser extension. The SurrealDB fallback only exposes persisted materialization percentiles (the per-phase samples are in-memory).', { tabId: z.number().optional().describe('Browser tab ID') }, async ({ tabId }) => {
+        if (bridge.isConnected) {
+            const state = (await bridge.request(BRIDGE_METHODS.GET_STATE, {}, tabId));
+            const queries = state?.activeQueries
+                ? Object.values(state.activeQueries)
+                : [];
+            // Rank by the dominant phases' p90 (fall back to last) so the slowest
+            // query/phase surfaces first.
+            const scoreOf = (t) => ['ssp', 'localFetch', 'remoteFetch', 'frontend'].reduce((s, k) => s + (t?.[k]?.p90 ?? t?.[k]?.lastMs ?? 0), 0);
+            const rows = queries
+                .map((q) => ({
+                queryHash: q.queryHash,
+                query: q.query,
+                updateCount: q.timings?.updateCount ?? q.updateCount,
+                errorCount: q.timings?.errorCount,
+                timings: q.timings ?? null,
+                _score: scoreOf(q.timings),
+            }))
+                .sort((a, b) => b._score - a._score)
+                // oxlint-disable-next-line no-unused-vars -- strip the internal sort key
+                .map(({ _score, ...rest }) => rest);
+            return json(rows);
+        }
+        if (surreal) {
+            const result = await surreal.query('SELECT * FROM _00_query;');
+            return json(result);
+        }
+        throw new Error('No extension connected and no direct database configured.');
+    });
+    server.tool('get_events', 'Get event history, optionally filtered by type', {
+        eventType: z.string().optional().describe('Filter by event type'),
+        limit: z.number().optional().default(50).describe('Max number of events to return'),
+        tabId: z.number().optional().describe('Browser tab ID'),
+    }, async ({ eventType, limit, tabId }) => {
+        if (bridge.isConnected) {
+            const state = (await bridge.request(BRIDGE_METHODS.GET_STATE, {}, tabId));
+            let events = state?.eventsHistory ?? [];
+            if (eventType) {
+                events = events.filter((e) => e.eventType === eventType);
+            }
+            if (limit) {
+                events = events.slice(-limit);
+            }
+            return json(events);
+        }
+        if (surreal) {
+            const result = await surreal.query(`SELECT * FROM _00_events ORDER BY timestamp DESC LIMIT ${limit};`);
+            return json(result);
+        }
+        throw new Error('No extension connected and no direct database configured.');
+    });
+    server.tool('get_auth_state', 'Get the current authentication state', { tabId: z.number().optional().describe('Browser tab ID') }, async ({ tabId }) => {
+        if (!bridge.isConnected) {
+            throw new Error('No extension connected. get_auth_state requires the Sp00ky DevTools browser extension.');
+        }
+        const state = (await bridge.request(BRIDGE_METHODS.GET_STATE, {}, tabId));
+        return json(state?.auth ?? null);
+    });
+    server.tool('clear_history', 'Clear the event history', { tabId: z.number().optional().describe('Browser tab ID') }, async ({ tabId }) => {
+        if (!bridge.isConnected) {
+            throw new Error('No extension connected. clear_history requires the Sp00ky DevTools browser extension.');
+        }
+        await bridge.request(BRIDGE_METHODS.CLEAR_HISTORY, {}, tabId);
+        return { content: [{ type: 'text', text: 'History cleared.' }] };
+    });
+    server.tool('describe_schema', 'Describe all tables with columns, types, and sp00ky annotations (@crdt, @parent). Stitches INFO FOR DB with parsed schema metadata. With the browser extension this returns @crdt/@parent semantics; direct-DB mode returns raw column info only.', { tabId: z.number().optional().describe('Browser tab ID') }, async ({ tabId }) => {
+        if (bridge.isConnected) {
+            const state = (await bridge.request(BRIDGE_METHODS.GET_STATE, {}, tabId));
+            const dbState = state?.database ?? {};
+            return json({
+                source: 'extension',
+                tables: dbState.tables ?? [],
+                relationships: dbState.relationships ?? [],
+            });
+        }
+        if (surreal) {
+            const dbInfo = (await surreal.query('INFO FOR DB;'));
+            const tablesObj = dbInfo?.[0]?.result?.tables ?? dbInfo?.[0]?.tables ?? {};
+            const tableNames = Object.keys(tablesObj);
+            const tables = await Promise.all(tableNames.map(async (name) => {
+                try {
+                    const info = (await surreal.query(`INFO FOR TABLE \`${name}\`;`));
+                    const fieldsObj = info?.[0]?.result?.fields ?? info?.[0]?.fields ?? {};
+                    const columns = Object.entries(fieldsObj).map(([fname, def]) => ({
+                        name: fname,
+                        definition: typeof def === 'string' ? def : JSON.stringify(def),
+                    }));
+                    return { name, columns };
+                }
+                catch (e) {
+                    return { name, columns: [], error: e instanceof Error ? e.message : String(e) };
+                }
+            }));
+            return json({
+                source: 'direct-db',
+                note: '@crdt / @parent annotations are not visible in direct-DB mode; connect the browser extension to see them.',
+                tables,
+            });
+        }
+        throw new Error('No extension connected and no direct database configured.');
+    });
+    server.tool('lint_query', 'Validate a SurrealQL query without running it. Sends EXPLAIN <query> through the connected channel; returns parse / plan errors with location when SurrealDB provides them.', {
+        query: z.string().describe('SurrealQL query to validate'),
+        target: z
+            .enum(['local', 'remote'])
+            .optional()
+            .default('remote')
+            .describe('When using the extension: lint against local (cache) or remote DB'),
+        tabId: z.number().optional().describe('Browser tab ID'),
+    }, async ({ query, target, tabId }) => {
+        const trimmed = query.trim().replace(/;\s*$/, '');
+        const explainQuery = /^\s*EXPLAIN\b/i.test(trimmed) ? trimmed : `EXPLAIN ${trimmed};`;
+        const parseError = (msg) => {
+            const m = msg.match(/line\s+(\d+)(?:[,\s]+col(?:umn)?\s+(\d+))?/i);
+            return {
+                ok: false,
+                errors: [
+                    {
+                        message: msg,
+                        line: m ? Number(m[1]) : undefined,
+                        column: m && m[2] ? Number(m[2]) : undefined,
+                    },
+                ],
+            };
+        };
+        const inspectResult = (raw) => {
+            const arr = Array.isArray(raw) ? raw : [raw];
+            const errors = arr
+                .map((r) => (r && r.status === 'ERR' ? r.result ?? r.message : null))
+                .filter(Boolean);
+            if (errors.length > 0) {
+                return { ok: false, errors: errors.map((m) => parseError(m).errors[0]) };
+            }
+            return { ok: true, plan: arr };
+        };
+        try {
+            if (bridge.isConnected) {
+                const result = await bridge.request(BRIDGE_METHODS.RUN_QUERY, { query: explainQuery, target }, tabId);
+                return json(inspectResult(result));
+            }
+            if (surreal) {
+                const result = await surreal.query(explainQuery);
+                return json(inspectResult(result));
+            }
+            throw new Error('No extension connected and no direct database configured.');
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return json(parseError(msg));
+        }
+    });
+    // --- Resources ---
+    server.resource('state', 'sp00ky://state', { description: 'Full Sp00ky DevTools state' }, async (uri) => {
+        if (!bridge.isConnected) {
+            throw new Error('No extension connected. State resource requires the browser extension.');
+        }
+        const state = await bridge.request(BRIDGE_METHODS.GET_STATE);
+        return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(state, null, 2) }] };
+    });
+    server.resource('tables', 'sp00ky://tables', { description: 'List of database tables' }, async (uri) => {
+        if (bridge.isConnected) {
+            const state = (await bridge.request(BRIDGE_METHODS.GET_STATE));
+            const tables = state?.database?.tables ?? [];
+            return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(tables, null, 2) }] };
+        }
+        if (surreal) {
+            const result = await surreal.query('INFO FOR DB;');
+            const info = result;
+            const tables = info?.[0]?.result?.tables ?? info?.[0]?.tables ?? {};
+            return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(Object.keys(tables), null, 2) }] };
+        }
+        throw new Error('No extension connected and no direct database configured.');
+    });
+    server.resource('table-data', new ResourceTemplate('sp00ky://tables/{tableName}', { list: undefined }), { description: 'Contents of a specific database table' }, async (uri, variables) => {
+        const tableName = variables.tableName;
+        if (bridge.isConnected) {
+            const result = await bridge.request(BRIDGE_METHODS.GET_TABLE_DATA, { tableName });
+            return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(result, null, 2) }] };
+        }
+        if (surreal) {
+            const result = await surreal.query(`SELECT * FROM \`${tableName}\` LIMIT 100;`);
+            return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(result, null, 2) }] };
+        }
+        throw new Error('No extension connected and no direct database configured.');
+    });
+    server.resource('queries', 'sp00ky://queries', { description: 'Active live queries' }, async (uri) => {
+        if (bridge.isConnected) {
+            const state = (await bridge.request(BRIDGE_METHODS.GET_STATE));
+            const queries = state?.activeQueries ?? [];
+            return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(queries, null, 2) }] };
+        }
+        if (surreal) {
+            const result = await surreal.query('SELECT * FROM _00_query;');
+            return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(result, null, 2) }] };
+        }
+        throw new Error('No extension connected and no direct database configured.');
+    });
+    server.resource('events', 'sp00ky://events', { description: 'Event history' }, async (uri) => {
+        if (bridge.isConnected) {
+            const state = (await bridge.request(BRIDGE_METHODS.GET_STATE));
+            const events = state?.eventsHistory ?? [];
+            return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(events, null, 2) }] };
+        }
+        if (surreal) {
+            const result = await surreal.query('SELECT * FROM _00_events ORDER BY timestamp DESC LIMIT 50;');
+            return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(result, null, 2) }] };
+        }
+        throw new Error('No extension connected and no direct database configured.');
+    });
+    return server;
+}

package/devtools-mcp/dist/surreal.d.ts

@@ -0,0 +1,13 @@
+export interface SurrealConfig {
+    url: string;
+    namespace: string;
+    database: string;
+    username: string;
+    password: string;
+}
+export declare class SurrealClient {
+    private config;
+    private authHeader;
+    constructor(config: SurrealConfig);
+    query(surql: string): Promise<unknown[]>;
+}

package/devtools-mcp/dist/surreal.js

@@ -0,0 +1,27 @@
+export class SurrealClient {
+    config;
+    authHeader;
+    constructor(config) {
+        this.config = config;
+        this.authHeader =
+            'Basic ' + Buffer.from(`${config.username}:${config.password}`).toString('base64');
+    }
+    async query(surql) {
+        const res = await fetch(`${this.config.url}/sql`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: this.authHeader,
+                'surreal-ns': this.config.namespace,
+                'surreal-db': this.config.database,
+                Accept: 'application/json',
+            },
+            body: surql,
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`SurrealDB query failed (${res.status}): ${text}`);
+        }
+        return res.json();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/cli",
-  "version": "0.0.1-canary.69",
+  "version": "0.0.1-canary.71",
   "description": "Generate TypeScript/Dart types from SurrealDB schema files",
   "type": "module",
   "main": "./dist/syncgen.cjs",
@@ -61,10 +61,10 @@
     "vitest": "^1.0.0"
   },
   "optionalDependencies": {
-    "@spooky-sync/cli-darwin-arm64": "0.0.1-canary.69",
-    "@spooky-sync/cli-darwin-x64": "0.0.1-canary.69",
-    "@spooky-sync/cli-linux-arm64": "0.0.1-canary.69",
-    "@spooky-sync/cli-linux-x64": "0.0.1-canary.69",
-    "@spooky-sync/cli-win32-x64": "0.0.1-canary.69"
+    "@spooky-sync/cli-darwin-arm64": "0.0.1-canary.71",
+    "@spooky-sync/cli-darwin-x64": "0.0.1-canary.71",
+    "@spooky-sync/cli-linux-arm64": "0.0.1-canary.71",
+    "@spooky-sync/cli-linux-x64": "0.0.1-canary.71",
+    "@spooky-sync/cli-win32-x64": "0.0.1-canary.71"
   }
 }