@spooky-sync/devtools-mcp 0.0.1-canary.34 → 0.0.1-canary.37

package/dist/bridge.js

@@ -15,7 +15,7 @@ export class Bridge {
         return Array.from(this.connectedTabs.values());
     }
     start() {
-        const port = parseInt(process.env.SP00KY_MCP_PORT || '', 10) || BRIDGE_PORT;
+        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`);
@@ -124,6 +124,7 @@ export class Bridge {
                 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));
         });
     }

package/dist/index.js

@@ -1,11 +1,24 @@
 #!/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 server = createServer(bridge);
+    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');

package/dist/server.d.ts

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

package/dist/server.js

@@ -1,120 +1,204 @@
 import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import { BRIDGE_METHODS } from './protocol.js';
-export function createServer(bridge) {
+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 () => {
-        const tabs = bridge.getConnectedTabs();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        connected: bridge.isConnected,
-                        tabs,
-                    }, null, 2),
-                },
-            ],
-        };
+        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 { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        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 }) => {
-        const result = await bridge.request(BRIDGE_METHODS.RUN_QUERY, { query, target }, tabId);
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        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 }) => {
-        const state = (await bridge.request(BRIDGE_METHODS.GET_STATE, {}, tabId));
-        const tables = state?.database?.tables ?? [];
-        return { content: [{ type: 'text', text: JSON.stringify(tables, null, 2) }] };
+        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 all records from a database table', {
+    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, tabId }) => {
-        const result = await bridge.request(BRIDGE_METHODS.GET_TABLE_DATA, { tableName }, tabId);
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }, 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().describe('Name of the table'),
-        recordId: z.string().describe('Record ID to update'),
+        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 }) => {
-        const result = await bridge.request(BRIDGE_METHODS.UPDATE_TABLE_ROW, { tableName, recordId, updates }, tabId);
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        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().describe('Name of the table'),
-        recordId: z.string().describe('Record ID to delete'),
+        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 }) => {
-        const result = await bridge.request(BRIDGE_METHODS.DELETE_TABLE_ROW, { tableName, recordId }, tabId);
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        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 }) => {
-        const state = (await bridge.request(BRIDGE_METHODS.GET_STATE, {}, tabId));
-        const queries = state?.activeQueries ?? [];
-        return { content: [{ type: 'text', text: JSON.stringify(queries, null, 2) }] };
+        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_events', 'Get event history, optionally filtered by type', {
         eventType: z.string().optional().describe('Filter by event type'),
-        limit: z.number().optional().describe('Max number of events to return'),
+        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 }) => {
-        const state = (await bridge.request(BRIDGE_METHODS.GET_STATE, {}, tabId));
-        let events = state?.eventsHistory ?? [];
-        if (eventType) {
-            events = events.filter((e) => e.eventType === eventType);
+        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 (limit) {
-            events = events.slice(-limit);
+        if (surreal) {
+            const result = await surreal.query(`SELECT * FROM _00_events ORDER BY timestamp DESC LIMIT ${limit};`);
+            return json(result);
         }
-        return { content: [{ type: 'text', text: JSON.stringify(events, null, 2) }] };
+        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));
-        const auth = state?.auth ?? null;
-        return { content: [{ type: 'text', text: JSON.stringify(auth, null, 2) }] };
+        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.' }] };
     });
     // --- 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) => {
-        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 (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;
-        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 (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) => {
-        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 (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) => {
-        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 (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/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/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/devtools-mcp",
-  "version": "0.0.1-canary.34",
+  "version": "0.0.1-canary.37",
   "description": "MCP server for Sp00ky Sync devtools",
   "license": "MIT",
   "type": "module",
@@ -12,7 +12,8 @@
   ],
   "scripts": {
     "build": "tsc",
-    "dev": "tsc --watch"
+    "dev": "tsc --watch",
+    "test": "vitest run"
   },
   "repository": {
     "type": "git",
@@ -29,6 +30,7 @@
   },
   "devDependencies": {
     "@types/ws": "^8.18.0",
-    "typescript": "^5.6.2"
+    "typescript": "^5.6.2",
+    "vitest": "^1.0.0"
   }
 }