@daylight-labs/sharedb-mcp 0.1.0

package/dist/api-client.d.ts

@@ -0,0 +1,175 @@
+export interface Database {
+    id: string;
+    name: string;
+    display_name: string;
+    environment: string;
+    created_at: string;
+}
+export interface SchemaChange {
+    id: string;
+    database_id: string;
+    migration_id: string | null;
+    change_type: string;
+    table_name: string;
+    column_name: string | null;
+    ddl: string;
+    reverse_ddl: string | null;
+    is_reversible: boolean;
+    change_order: number;
+    created_at: string;
+}
+export interface Migration {
+    id: string;
+    database_id: string;
+    version: number;
+    description: string;
+    status: string;
+    applied_at: string;
+    rolled_back_at: string | null;
+}
+export interface ColumnInfo {
+    column_name: string;
+    data_type: string;
+    is_nullable: boolean;
+    column_default: string | null;
+}
+export interface TableSchema {
+    table_name: string;
+    columns: ColumnInfo[];
+    indexes: Array<{
+        index_name: string;
+        column_name: string;
+        is_unique: boolean;
+        is_primary: boolean;
+    }>;
+    constraints: Array<{
+        constraint_name: string;
+        constraint_type: string;
+        column_name: string | null;
+        foreign_table_name: string | null;
+        foreign_column_name: string | null;
+    }>;
+    rls_enabled: boolean;
+    rls_policies: Array<{
+        policy_name: string;
+        command: string;
+        using_expression: string | null;
+        with_check_expression: string | null;
+        roles: string[];
+    }>;
+}
+export interface DatabaseSchema {
+    database: string;
+    tables: TableSchema[];
+    functions: Array<{
+        function_name: string;
+        return_type: string;
+        arguments: string;
+    }>;
+    message?: string;
+}
+export interface PostgRESTInfo {
+    postgrestUrl: string | null;
+    status: string;
+    port?: number;
+    containerName?: string;
+    startedAt?: string;
+}
+export declare const api: {
+    databases: {
+        list: () => Promise<{
+            databases: Database[];
+        }>;
+        get: (id: string) => Promise<{
+            database: Database;
+        }>;
+        create: (data: {
+            name: string;
+            displayName: string;
+            environment: string;
+        }) => Promise<{
+            database: Database;
+        }>;
+        schema: (id: string) => Promise<DatabaseSchema>;
+        tableDetails: (dbId: string, table: string) => Promise<TableSchema>;
+        rlsPolicies: (id: string) => Promise<{
+            policies: Array<{
+                table_name: string;
+                policy_name: string;
+                command: string;
+                using_expression: string | null;
+                with_check_expression: string | null;
+                roles: string[];
+            }>;
+        }>;
+        functions: (id: string) => Promise<{
+            functions: Array<{
+                function_name: string;
+                return_type: string;
+                arguments: string;
+                definition: string;
+            }>;
+        }>;
+        postgrest: (id: string) => Promise<PostgRESTInfo>;
+        startPostgrest: (id: string) => Promise<PostgRESTInfo & {
+            message: string;
+        }>;
+        restartPostgrest: (id: string) => Promise<PostgRESTInfo & {
+            message: string;
+        }>;
+    };
+    changes: {
+        list: (dbId: string) => Promise<{
+            changes: SchemaChange[];
+        }>;
+        stage: (dbId: string, operation: string, params: Record<string, unknown>) => Promise<{
+            staged: SchemaChange[];
+        }>;
+        preview: (dbId: string) => Promise<{
+            preview: {
+                database: string;
+                changeCount: number;
+                hasIrreversibleChanges: boolean;
+                summary: Array<{
+                    type: string;
+                    table: string;
+                    column: string | null;
+                    reversible: boolean;
+                }>;
+                ddlStatements: string[];
+            } | null;
+            message?: string;
+        }>;
+        apply: (dbId: string, description?: string) => Promise<{
+            migration: Migration;
+        }>;
+        unstage: (dbId: string, changeId: string) => Promise<{
+            deleted: SchemaChange;
+        }>;
+    };
+    migrations: {
+        list: (dbId: string) => Promise<{
+            migrations: Migration[];
+        }>;
+        get: (dbId: string, migrationId: string) => Promise<{
+            migration: Migration & {
+                changes: SchemaChange[];
+            };
+        }>;
+        rollback: (dbId: string, migrationId: string) => Promise<{
+            rolledBack: {
+                migrationId: string;
+                version: number;
+                changesReverted: number;
+            };
+        }>;
+    };
+    auth: {
+        config: () => Promise<{
+            endpoints: Record<string, string>;
+            jwtStructure: Record<string, string>;
+            sessionVariable: string;
+            helperFunction: string;
+        }>;
+    };
+};

package/dist/api-client.js

@@ -0,0 +1,65 @@
+import { config } from './config.js';
+async function request(path, options) {
+    const response = await fetch(`${config.adminApiUrl}${path}`, {
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${config.token}`,
+            ...options?.headers,
+        },
+    });
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: 'Request failed' }));
+        throw new Error(error.error || `Request failed: ${response.status}`);
+    }
+    return response.json();
+}
+export const api = {
+    databases: {
+        list: () => request('/admin/databases'),
+        get: (id) => request(`/admin/databases/${id}`),
+        create: (data) => request('/admin/databases', {
+            method: 'POST',
+            body: JSON.stringify(data),
+        }),
+        schema: (id) => request(`/admin/databases/${id}/schema`),
+        tableDetails: (dbId, table) => request(`/admin/databases/${dbId}/schema/tables/${table}`),
+        rlsPolicies: (id) => request(`/admin/databases/${id}/schema/rls-policies`),
+        functions: (id) => request(`/admin/databases/${id}/schema/functions`),
+        postgrest: (id) => request(`/admin/databases/${id}/postgrest`),
+        startPostgrest: (id) => request(`/admin/databases/${id}/postgrest/start`, {
+            method: 'POST',
+            body: JSON.stringify({}),
+        }),
+        restartPostgrest: (id) => request(`/admin/databases/${id}/postgrest/restart`, {
+            method: 'POST',
+            body: JSON.stringify({}),
+        }),
+    },
+    changes: {
+        list: (dbId) => request(`/admin/databases/${dbId}/changes`),
+        stage: (dbId, operation, params) => request(`/admin/databases/${dbId}/changes`, {
+            method: 'POST',
+            body: JSON.stringify({ operation, params }),
+        }),
+        preview: (dbId) => request(`/admin/databases/${dbId}/changes/preview`, {
+            method: 'POST',
+            body: JSON.stringify({}),
+        }),
+        apply: (dbId, description) => request(`/admin/databases/${dbId}/changes/apply`, {
+            method: 'POST',
+            body: JSON.stringify({ description }),
+        }),
+        unstage: (dbId, changeId) => request(`/admin/databases/${dbId}/changes/${changeId}`, {
+            method: 'DELETE',
+        }),
+    },
+    migrations: {
+        list: (dbId) => request(`/admin/databases/${dbId}/migrations`),
+        get: (dbId, migrationId) => request(`/admin/databases/${dbId}/migrations/${migrationId}`),
+        rollback: (dbId, migrationId) => request(`/admin/databases/${dbId}/migrations/${migrationId}/rollback`, { method: 'POST' }),
+    },
+    auth: {
+        config: () => request('/admin/auth/config'),
+    },
+};

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+export declare const config: {
+    adminApiUrl: string;
+    authApiUrl: string;
+    token: string;
+};

package/dist/config.js

@@ -0,0 +1,5 @@
+export const config = {
+    adminApiUrl: process.env.SHAREDB_API_URL || 'http://localhost:3002',
+    authApiUrl: process.env.SHAREDB_AUTH_URL || 'http://localhost:3000',
+    token: process.env.SHAREDB_TOKEN || '',
+};

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { schemaTools, handleSchemaTool } from './tools/schema.js';
+import { migrationTools, handleMigrationTool } from './tools/migrations.js';
+import { authTools, handleAuthTool } from './tools/auth.js';
+import { dataTools, handleDataTool } from './tools/data.js';
+import { resources, readResource } from './resources/index.js';
+const server = new Server({
+    name: 'sharedb',
+    version: '0.1.0',
+}, {
+    capabilities: {
+        tools: {},
+        resources: {},
+    },
+});
+const allTools = [...schemaTools, ...migrationTools, ...authTools, ...dataTools];
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: allTools };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const schemaTool = schemaTools.find((t) => t.name === name);
+    if (schemaTool) {
+        return handleSchemaTool(name, args || {});
+    }
+    const migrationTool = migrationTools.find((t) => t.name === name);
+    if (migrationTool) {
+        return handleMigrationTool(name, args || {});
+    }
+    const authTool = authTools.find((t) => t.name === name);
+    if (authTool) {
+        return handleAuthTool(name, args || {});
+    }
+    const dataTool = dataTools.find((t) => t.name === name);
+    if (dataTool) {
+        return handleDataTool(name, args || {});
+    }
+    return {
+        content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+        isError: true,
+    };
+});
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return { resources };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    return readResource(uri);
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('ShareDB MCP server running on stdio');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/resources/index.d.ts

@@ -0,0 +1,13 @@
+export declare const resources: {
+    uri: string;
+    name: string;
+    description: string;
+    mimeType: string;
+}[];
+export declare function readResource(uri: string): {
+    contents: Array<{
+        uri: string;
+        mimeType: string;
+        text: string;
+    }>;
+};