@spooky-sync/cli 0.0.1-canary.35 → 0.0.1-canary.37

package/devtools-mcp/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/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/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/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/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/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/server.js

@@ -0,0 +1,204 @@
+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_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.' }] };
+    });
+    // --- 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/cli",
-  "version": "0.0.1-canary.35",
+  "version": "0.0.1-canary.37",
   "description": "Generate TypeScript/Dart types from SurrealDB schema files",
   "type": "module",
   "main": "./dist/syncgen.cjs",
@@ -18,16 +18,16 @@
   },
   "files": [
     "dist",
-    "mcp-proxy"
+    "devtools-mcp"
   ],
   "scripts": {
     "dev": "vite",
     "build:rust": "cargo build --release",
     "build:vite": "vite build",
     "build:types": "tsc --emitDeclarationOnly --declaration --declarationDir dist",
-    "build:mcp-proxy": "cd ../mcp-proxy && npm run build && cp -r dist ../cli/mcp-proxy",
+    "build:devtools-mcp": "cd ../devtools-mcp && npm run build && cp -r dist ../cli/devtools-mcp",
     "build:js": "npm run build:vite && npm run build:types",
-    "build": "npm run build:rust && npm run build:mcp-proxy && npm run build:js",
+    "build": "npm run build:rust && npm run build:devtools-mcp && npm run build:js",
     "preview": "vite preview",
     "test": "vitest",
     "lint": "eslint src",
@@ -58,10 +58,10 @@
     "vitest": "^1.0.0"
   },
   "optionalDependencies": {
-    "@spooky-sync/cli-darwin-arm64": "0.0.1-canary.35",
-    "@spooky-sync/cli-darwin-x64": "0.0.1-canary.35",
-    "@spooky-sync/cli-linux-arm64": "0.0.1-canary.35",
-    "@spooky-sync/cli-linux-x64": "0.0.1-canary.35",
-    "@spooky-sync/cli-win32-x64": "0.0.1-canary.35"
+    "@spooky-sync/cli-darwin-arm64": "0.0.1-canary.37",
+    "@spooky-sync/cli-darwin-x64": "0.0.1-canary.37",
+    "@spooky-sync/cli-linux-arm64": "0.0.1-canary.37",
+    "@spooky-sync/cli-linux-x64": "0.0.1-canary.37",
+    "@spooky-sync/cli-win32-x64": "0.0.1-canary.37"
   }
 }

package/mcp-proxy/dist/index.js

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { SurrealClient } from './surreal.js';
-import { createServer } from './server.js';
-function main() {
-    const surreal = new SurrealClient({
-        url: process.env.SURREAL_URL ?? 'http://localhost:8666',
-        namespace: process.env.SURREAL_NS ?? 'main',
-        database: process.env.SURREAL_DB ?? 'main',
-        username: process.env.SURREAL_USER ?? 'root',
-        password: process.env.SURREAL_PASS ?? 'root',
-    });
-    const server = createServer(surreal);
-    const transport = new StdioServerTransport();
-    server.connect(transport).then(() => {
-        process.stderr.write('[sp00ky-mcp-proxy] MCP server running on stdio\n');
-    });
-    const cleanup = async () => {
-        process.stderr.write('[sp00ky-mcp-proxy] Shutting down...\n');
-        process.exit(0);
-    };
-    process.on('SIGINT', cleanup);
-    process.on('SIGTERM', cleanup);
-}
-main();

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

@@ -1,3 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { SurrealClient } from './surreal.js';
-export declare function createServer(surreal: SurrealClient): McpServer;

package/mcp-proxy/dist/server.js

@@ -1,74 +0,0 @@
-import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-export function createServer(surreal) {
-    const server = new McpServer({
-        name: 'sp00ky-mcp-proxy',
-        version: '0.0.1',
-    });
-    // --- Tools ---
-    server.tool('run_query', 'Execute a SurrealQL query against the database', {
-        query: z.string().describe('SurrealQL query to execute'),
-    }, async ({ query }) => {
-        const result = await surreal.query(query);
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    });
-    server.tool('list_tables', 'List all database tables', {}, async () => {
-        const result = await surreal.query('INFO FOR DB;');
-        const info = result;
-        const tables = info?.[0]?.result?.tables ?? info?.[0]?.tables ?? {};
-        const tableNames = Object.keys(tables);
-        return { content: [{ type: 'text', text: JSON.stringify(tableNames, null, 2) }] };
-    });
-    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'),
-    }, async ({ tableName, limit }) => {
-        const result = await surreal.query(`SELECT * FROM \`${tableName}\` LIMIT ${limit};`);
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    });
-    server.tool('update_table_row', 'Update a record in a database table', {
-        recordId: z.string().describe('Record ID to update (e.g. "users:abc123")'),
-        updates: z.record(z.unknown()).describe('Fields to update'),
-    }, async ({ recordId, updates }) => {
-        const result = await surreal.query(`UPDATE ${recordId} MERGE ${JSON.stringify(updates)};`);
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    });
-    server.tool('delete_table_row', 'Delete a record from a database table', {
-        recordId: z.string().describe('Record ID to delete (e.g. "users:abc123")'),
-    }, async ({ recordId }) => {
-        const result = await surreal.query(`DELETE ${recordId};`);
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    });
-    server.tool('get_active_queries', 'Get all active live queries registered with the SSP', {}, async () => {
-        const result = await surreal.query('SELECT * FROM _00_query;');
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    });
-    server.tool('get_events', 'Get event history, optionally limited', {
-        limit: z.number().optional().default(50).describe('Max number of events to return'),
-    }, async ({ limit }) => {
-        const result = await surreal.query(`SELECT * FROM _00_events ORDER BY timestamp DESC LIMIT ${limit};`);
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    });
-    // --- Resources ---
-    server.resource('tables', 'sp00ky://tables', { description: 'List of database tables' }, async (uri) => {
-        const result = await surreal.query('INFO FOR DB;');
-        const info = result;
-        const tables = info?.[0]?.result?.tables ?? info?.[0]?.tables ?? {};
-        const tableNames = Object.keys(tables);
-        return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(tableNames, null, 2) }] };
-    });
-    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 surreal.query(`SELECT * FROM \`${tableName}\` LIMIT 100;`);
-        return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(result, null, 2) }] };
-    });
-    server.resource('queries', 'sp00ky://queries', { description: 'Active live queries' }, async (uri) => {
-        const result = await surreal.query('SELECT * FROM _00_query;');
-        return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(result, null, 2) }] };
-    });
-    server.resource('events', 'sp00ky://events', { description: 'Event history' }, async (uri) => {
-        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) }] };
-    });
-    return server;
-}

package/mcp-proxy/index.d.ts

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

package/mcp-proxy/index.js

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { SurrealClient } from './surreal.js';
-import { createServer } from './server.js';
-function main() {
-    const surreal = new SurrealClient({
-        url: process.env.SURREAL_URL ?? 'http://localhost:8666',
-        namespace: process.env.SURREAL_NS ?? 'main',
-        database: process.env.SURREAL_DB ?? 'main',
-        username: process.env.SURREAL_USER ?? 'root',
-        password: process.env.SURREAL_PASS ?? 'root',
-    });
-    const server = createServer(surreal);
-    const transport = new StdioServerTransport();
-    server.connect(transport).then(() => {
-        process.stderr.write('[sp00ky-mcp-proxy] MCP server running on stdio\n');
-    });
-    const cleanup = async () => {
-        process.stderr.write('[sp00ky-mcp-proxy] Shutting down...\n');
-        process.exit(0);
-    };
-    process.on('SIGINT', cleanup);
-    process.on('SIGTERM', cleanup);
-}
-main();

package/mcp-proxy/server.d.ts

@@ -1,3 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { SurrealClient } from './surreal.js';
-export declare function createServer(surreal: SurrealClient): McpServer;

package/mcp-proxy/server.js

@@ -1,74 +0,0 @@
-import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-export function createServer(surreal) {
-    const server = new McpServer({
-        name: 'sp00ky-mcp-proxy',
-        version: '0.0.1',
-    });
-    // --- Tools ---
-    server.tool('run_query', 'Execute a SurrealQL query against the database', {
-        query: z.string().describe('SurrealQL query to execute'),
-    }, async ({ query }) => {
-        const result = await surreal.query(query);
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    });
-    server.tool('list_tables', 'List all database tables', {}, async () => {
-        const result = await surreal.query('INFO FOR DB;');
-        const info = result;
-        const tables = info?.[0]?.result?.tables ?? info?.[0]?.tables ?? {};
-        const tableNames = Object.keys(tables);
-        return { content: [{ type: 'text', text: JSON.stringify(tableNames, null, 2) }] };
-    });
-    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'),
-    }, async ({ tableName, limit }) => {
-        const result = await surreal.query(`SELECT * FROM \`${tableName}\` LIMIT ${limit};`);
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    });
-    server.tool('update_table_row', 'Update a record in a database table', {
-        recordId: z.string().describe('Record ID to update (e.g. "users:abc123")'),
-        updates: z.record(z.unknown()).describe('Fields to update'),
-    }, async ({ recordId, updates }) => {
-        const result = await surreal.query(`UPDATE ${recordId} MERGE ${JSON.stringify(updates)};`);
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    });
-    server.tool('delete_table_row', 'Delete a record from a database table', {
-        recordId: z.string().describe('Record ID to delete (e.g. "users:abc123")'),
-    }, async ({ recordId }) => {
-        const result = await surreal.query(`DELETE ${recordId};`);
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    });
-    server.tool('get_active_queries', 'Get all active live queries registered with the SSP', {}, async () => {
-        const result = await surreal.query('SELECT * FROM _00_query;');
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    });
-    server.tool('get_events', 'Get event history, optionally limited', {
-        limit: z.number().optional().default(50).describe('Max number of events to return'),
-    }, async ({ limit }) => {
-        const result = await surreal.query(`SELECT * FROM _00_events ORDER BY timestamp DESC LIMIT ${limit};`);
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    });
-    // --- Resources ---
-    server.resource('tables', 'sp00ky://tables', { description: 'List of database tables' }, async (uri) => {
-        const result = await surreal.query('INFO FOR DB;');
-        const info = result;
-        const tables = info?.[0]?.result?.tables ?? info?.[0]?.tables ?? {};
-        const tableNames = Object.keys(tables);
-        return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(tableNames, null, 2) }] };
-    });
-    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 surreal.query(`SELECT * FROM \`${tableName}\` LIMIT 100;`);
-        return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(result, null, 2) }] };
-    });
-    server.resource('queries', 'sp00ky://queries', { description: 'Active live queries' }, async (uri) => {
-        const result = await surreal.query('SELECT * FROM _00_query;');
-        return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(result, null, 2) }] };
-    });
-    server.resource('events', 'sp00ky://events', { description: 'Event history' }, async (uri) => {
-        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) }] };
-    });
-    return server;
-}

package/mcp-proxy/surreal.d.ts

@@ -1,13 +0,0 @@
-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/mcp-proxy/surreal.js

@@ -1,27 +0,0 @@
-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();
-    }
-}