@daylight-labs/popdb-mcp 0.1.7

package/dist/api-client.d.ts

@@ -0,0 +1,348 @@
+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 interface LogEntry {
+    id: string;
+    database_id: string;
+    level: 'error' | 'debug';
+    message: string;
+    metadata: Record<string, unknown>;
+    source: 'admin-api' | 'admin-ui' | 'user-app' | 'postgrest';
+    request_id: string | null;
+    created_at: string;
+}
+export interface LogQueryOptions {
+    level?: string;
+    source?: string;
+    since?: string;
+    until?: string;
+    limit?: number;
+}
+export interface App {
+    id: string;
+    name: string;
+    display_name: string;
+    created_at: string;
+    updated_at: string;
+    databases: {
+        staging?: {
+            id: string;
+            name: string;
+            environment: string;
+        };
+        production?: {
+            id: string;
+            name: string;
+            environment: string;
+        };
+    };
+}
+export interface PromotionPreview {
+    staging: {
+        id: string;
+        name: string;
+        migrationVersion: number;
+    };
+    production: {
+        id: string;
+        name: string;
+        migrationVersion: number;
+    };
+    migrationsToApply: Array<{
+        id: string;
+        version: number;
+        description: string;
+        changeCount: number;
+    }>;
+    destructiveChanges: Array<{
+        changeType: string;
+        tableName: string;
+        columnName: string | null;
+        description: string;
+    }>;
+    warnings: string[];
+    totalMigrations: number;
+    totalChanges: number;
+    hasDestructiveChanges: boolean;
+}
+export interface DeploymentInfo {
+    id: string;
+    version: number;
+    fileCount: number;
+    totalSizeBytes: number;
+}
+export interface HostingStatus {
+    enabled: boolean;
+    url: string | null;
+    deployment: {
+        id: string;
+        version: number;
+        fileCount: number;
+        totalSizeBytes: number;
+        deployedAt: string;
+    } | null;
+    customDomains: Array<{
+        id: string;
+        domain: string;
+        status: string;
+        verified_at: string | null;
+        created_at: string;
+    }>;
+}
+export interface CustomDomainResult {
+    domain: {
+        id: string;
+        domain: string;
+        status: string;
+    };
+    dns: {
+        type: string;
+        name: string;
+        value: string;
+        instructions: string;
+    };
+}
+export declare const api: {
+    apps: {
+        list: () => Promise<{
+            apps: Array<{
+                id: string;
+                name: string;
+                display_name: string;
+                databases: Array<{
+                    id: string;
+                    name: string;
+                    environment: string;
+                    postgrest_status: string | null;
+                    postgrestUrl: string | null;
+                }>;
+            }>;
+        }>;
+        get: (id: string) => Promise<{
+            app: App;
+        }>;
+        create: (data: {
+            name: string;
+            displayName: string;
+        }) => Promise<{
+            app: App;
+        }>;
+        delete: (id: string) => Promise<{
+            deleted: {
+                app: App;
+            };
+        }>;
+        startPostgrest: (id: string) => Promise<{
+            results: Record<string, {
+                status: string;
+                postgrestUrl: string | null;
+            }>;
+        }>;
+        promotePreview: (id: string) => Promise<{
+            preview: PromotionPreview | null;
+            message?: string;
+        }>;
+    };
+    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;
+        }>;
+    };
+    hosting: {
+        deploy: (appId: string, tarPath: string) => Promise<{
+            deployment: DeploymentInfo;
+            url: string | null;
+        }>;
+        status: (appId: string) => Promise<{
+            hosting: HostingStatus;
+        }>;
+        addDomain: (appId: string, domain: string) => Promise<CustomDomainResult>;
+        removeDomain: (appId: string, domainId: string) => Promise<{
+            deleted: {
+                id: string;
+                domain: string;
+            };
+        }>;
+    };
+    logs: {
+        query: (dbId: string, options?: LogQueryOptions) => Promise<{
+            logs: LogEntry[];
+            total: number;
+            limit: number;
+            offset: number;
+        }>;
+        get: (dbId: string, logId: string) => Promise<{
+            log: LogEntry;
+        }>;
+    };
+};
+export declare function resolveStagingDatabase(identifier: string): Promise<{
+    databaseId: string;
+    isApp: boolean;
+    appId?: string;
+}>;

package/dist/api-client.js

@@ -0,0 +1,143 @@
+import fs from 'node:fs';
+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();
+}
+async function uploadFile(path, filePath) {
+    const fileBuffer = fs.readFileSync(filePath);
+    const blob = new Blob([fileBuffer], { type: 'application/gzip' });
+    const formData = new FormData();
+    formData.append('file', blob, 'bundle.tar.gz');
+    const response = await fetch(`${config.adminApiUrl}${path}`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${config.token}`,
+        },
+        body: formData,
+    });
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: 'Upload failed' }));
+        throw new Error(error.error || `Upload failed: ${response.status}`);
+    }
+    return response.json();
+}
+export const api = {
+    apps: {
+        list: () => request('/admin/apps'),
+        get: (id) => request(`/admin/apps/${id}`),
+        create: (data) => request('/admin/apps', {
+            method: 'POST',
+            body: JSON.stringify(data),
+        }),
+        delete: (id) => request(`/admin/apps/${id}`, {
+            method: 'DELETE',
+        }),
+        startPostgrest: (id) => request(`/admin/apps/${id}/start-postgrest`, { method: 'POST', body: JSON.stringify({}) }),
+        promotePreview: (id) => request(`/admin/apps/${id}/promote/preview`),
+    },
+    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'),
+    },
+    hosting: {
+        deploy: (appId, tarPath) => uploadFile(`/admin/apps/${appId}/deploy`, tarPath),
+        status: (appId) => request(`/admin/apps/${appId}/hosting`),
+        addDomain: (appId, domain) => request(`/admin/apps/${appId}/domains`, {
+            method: 'POST',
+            body: JSON.stringify({ domain }),
+        }),
+        removeDomain: (appId, domainId) => request(`/admin/apps/${appId}/domains/${domainId}`, { method: 'DELETE' }),
+    },
+    logs: {
+        query: (dbId, options = {}) => {
+            const params = new URLSearchParams();
+            if (options.level)
+                params.append('level', options.level);
+            if (options.source)
+                params.append('source', options.source);
+            if (options.since)
+                params.append('since', options.since);
+            if (options.until)
+                params.append('until', options.until);
+            if (options.limit)
+                params.append('limit', options.limit.toString());
+            const query = params.toString();
+            return request(`/admin/databases/${dbId}/logs${query ? `?${query}` : ''}`);
+        },
+        get: (dbId, logId) => request(`/admin/databases/${dbId}/logs/${logId}`),
+    },
+};
+export async function resolveStagingDatabase(identifier) {
+    try {
+        const { app } = await api.apps.get(identifier);
+        if (app.databases.staging) {
+            return {
+                databaseId: app.databases.staging.id,
+                isApp: true,
+                appId: app.id,
+            };
+        }
+        throw new Error(`App "${identifier}" has no staging database`);
+    }
+    catch {
+        return {
+            databaseId: identifier,
+            isApp: false,
+        };
+    }
+}

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,6 @@
+const domain = process.env.POPDB_DOMAIN;
+export const config = {
+    adminApiUrl: process.env.POPDB_API_URL || (domain ? `https://${domain}/api` : 'http://localhost:3002'),
+    authApiUrl: process.env.POPDB_AUTH_URL || (domain ? `https://${domain}/api` : 'http://localhost:3000'),
+    token: process.env.POPDB_TOKEN || '',
+};

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,71 @@
+#!/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 { logsTools, handleLogsTool } from './tools/logs.js';
+import { hostingTools, handleHostingTool } from './tools/hosting.js';
+import { resources, readResource } from './resources/index.js';
+const server = new Server({
+    name: 'popdb',
+    version: '0.1.0',
+}, {
+    capabilities: {
+        tools: {},
+        resources: {},
+    },
+});
+const allTools = [...schemaTools, ...migrationTools, ...authTools, ...dataTools, ...logsTools, ...hostingTools];
+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 || {});
+    }
+    const logsTool = logsTools.find((t) => t.name === name);
+    if (logsTool) {
+        return handleLogsTool(name, args || {});
+    }
+    const hostingTool = hostingTools.find((t) => t.name === name);
+    if (hostingTool) {
+        return handleHostingTool(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('PopDB 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;
+    }>;
+};