@daylight-labs/sharedb-mcp 0.1.2 → 0.1.3

package/dist/api-client.d.ts

@@ -139,6 +139,43 @@ export interface PromotionPreview {
     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<{
@@ -276,6 +313,22 @@ export declare const api: {
             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[];

package/dist/api-client.js

@@ -1,3 +1,4 @@
+import fs from 'node:fs';
 import { config } from './config.js';
 async function request(path, options) {
     const response = await fetch(`${config.adminApiUrl}${path}`, {
@@ -14,6 +15,24 @@ async function request(path, options) {
     }
     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'),
@@ -75,6 +94,15 @@ export const api = {
     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();

package/dist/index.js

@@ -7,6 +7,7 @@ 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: 'sharedb',
@@ -17,7 +18,7 @@ const server = new Server({
         resources: {},
     },
 });
-const allTools = [...schemaTools, ...migrationTools, ...authTools, ...dataTools, ...logsTools];
+const allTools = [...schemaTools, ...migrationTools, ...authTools, ...dataTools, ...logsTools, ...hostingTools];
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return { tools: allTools };
 });
@@ -43,6 +44,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     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,

package/dist/tools/hosting.d.ts

@@ -0,0 +1,81 @@
+export declare const hostingTools: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            app_id: {
+                type: string;
+                description: string;
+            };
+            dist_path: {
+                type: string;
+                description: string;
+            };
+            domain?: undefined;
+            domain_id?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            app_id: {
+                type: string;
+                description: string;
+            };
+            dist_path?: undefined;
+            domain?: undefined;
+            domain_id?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            app_id: {
+                type: string;
+                description: string;
+            };
+            domain: {
+                type: string;
+                description: string;
+            };
+            dist_path?: undefined;
+            domain_id?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            app_id: {
+                type: string;
+                description: string;
+            };
+            domain_id: {
+                type: string;
+                description: string;
+            };
+            dist_path?: undefined;
+            domain?: undefined;
+        };
+        required: string[];
+    };
+})[];
+export declare function handleHostingTool(name: string, args: Record<string, unknown>): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}>;

package/dist/tools/hosting.js

@@ -0,0 +1,224 @@
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { api } from '../api-client.js';
+export const hostingTools = [
+    {
+        name: 'deploy_app',
+        description: 'Deploy a local directory (e.g., a Vite dist folder) as a static hosted app. Creates a tar.gz of the directory and uploads it. The app will be accessible at <app-name>.<tenant-domain>.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                app_id: {
+                    type: 'string',
+                    description: 'The app ID or name',
+                },
+                dist_path: {
+                    type: 'string',
+                    description: 'Absolute path to the local dist/build directory to deploy (e.g., /path/to/my-app/dist)',
+                },
+            },
+            required: ['app_id', 'dist_path'],
+        },
+    },
+    {
+        name: 'get_hosting_status',
+        description: 'Get the hosting status for an app, including the live URL, current deployment info, and custom domains.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                app_id: {
+                    type: 'string',
+                    description: 'The app ID or name',
+                },
+            },
+            required: ['app_id'],
+        },
+    },
+    {
+        name: 'add_custom_domain',
+        description: 'Add a custom domain to a hosted app. Returns DNS configuration instructions. SSL is provisioned automatically via on-demand TLS once DNS propagates.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                app_id: {
+                    type: 'string',
+                    description: 'The app ID or name',
+                },
+                domain: {
+                    type: 'string',
+                    description: 'The custom domain to add (e.g., "myapp.com" or "app.mycompany.com")',
+                },
+            },
+            required: ['app_id', 'domain'],
+        },
+    },
+    {
+        name: 'remove_custom_domain',
+        description: 'Remove a custom domain from a hosted app.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                app_id: {
+                    type: 'string',
+                    description: 'The app ID or name',
+                },
+                domain_id: {
+                    type: 'string',
+                    description: 'The domain ID to remove',
+                },
+            },
+            required: ['app_id', 'domain_id'],
+        },
+    },
+];
+export async function handleHostingTool(name, args) {
+    try {
+        switch (name) {
+            case 'deploy_app': {
+                const appId = args.app_id;
+                const distPath = args.dist_path;
+                if (!fs.existsSync(distPath)) {
+                    return {
+                        content: [{ type: 'text', text: `Error: Directory not found: ${distPath}` }],
+                        isError: true,
+                    };
+                }
+                const stat = fs.statSync(distPath);
+                if (!stat.isDirectory()) {
+                    return {
+                        content: [{ type: 'text', text: `Error: Path is not a directory: ${distPath}` }],
+                        isError: true,
+                    };
+                }
+                const tarPath = path.join(path.dirname(distPath), `.deploy-${Date.now()}.tar.gz`);
+                try {
+                    execSync(`tar -czf "${tarPath}" -C "${distPath}" .`, { stdio: 'pipe' });
+                    const result = await api.hosting.deploy(appId, tarPath);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `App deployed successfully!
+
+**Deployment Details:**
+- Version: v${result.deployment.version}
+- Files: ${result.deployment.fileCount}
+- Size: ${formatBytes(result.deployment.totalSizeBytes)}
+${result.url ? `\n**Live URL:** ${result.url}` : ''}
+
+The app is now live and serving static files.`,
+                            },
+                        ],
+                    };
+                }
+                finally {
+                    try {
+                        fs.unlinkSync(tarPath);
+                    }
+                    catch { }
+                }
+            }
+            case 'get_hosting_status': {
+                const appId = args.app_id;
+                const { hosting } = await api.hosting.status(appId);
+                if (!hosting.enabled) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Hosting is not yet enabled for this app. Deploy a build using deploy_app to enable hosting.`,
+                            },
+                        ],
+                    };
+                }
+                const domainsList = hosting.customDomains?.length
+                    ? hosting.customDomains
+                        .map((d) => `- ${d.domain} (${d.status})`)
+                        .join('\n')
+                    : '_No custom domains configured_';
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `## Hosting Status
+
+**URL:** ${hosting.url || 'N/A'}
+**Enabled:** ${hosting.enabled}
+
+### Current Deployment
+${hosting.deployment
+                                ? `- Version: v${hosting.deployment.version}
+- Files: ${hosting.deployment.fileCount}
+- Size: ${formatBytes(hosting.deployment.totalSizeBytes)}
+- Deployed: ${hosting.deployment.deployedAt}`
+                                : '_No active deployment_'}
+
+### Custom Domains
+${domainsList}`,
+                        },
+                    ],
+                };
+            }
+            case 'add_custom_domain': {
+                const appId = args.app_id;
+                const domain = args.domain;
+                const result = await api.hosting.addDomain(appId, domain);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Custom domain "${domain}" added.
+
+**DNS Configuration Required:**
+- Record Type: ${result.dns.type}
+- Name: ${result.dns.name}
+- Value: ${result.dns.value}
+
+${result.dns.instructions}
+
+Domain ID: ${result.domain.id}`,
+                        },
+                    ],
+                };
+            }
+            case 'remove_custom_domain': {
+                const appId = args.app_id;
+                const domainId = args.domain_id;
+                await api.hosting.removeDomain(appId, domainId);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Custom domain removed successfully.`,
+                        },
+                    ],
+                };
+            }
+            default:
+                return {
+                    content: [{ type: 'text', text: `Unknown hosting tool: ${name}` }],
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daylight-labs/sharedb-mcp",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "MCP server for ShareDB schema management and development",
   "type": "module",
   "main": "./dist/index.js",