@fruition/fcp-mcp-server 1.25.0 → 1.27.0

package/dist/index.js

@@ -39,6 +39,8 @@ import { runBackgroundSync } from './skills-sync.js';
 // Configuration
 const FCP_API_URL = process.env.FCP_API_URL || 'https://fcp.fru.io';
 const FCP_API_TOKEN = process.env.FCP_API_TOKEN || '';
+// Small async sleep used by bounded polling loops (e.g. fcp_backup_get_database).
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 // Unroo API can be called directly (legacy) or proxied through FCP (recommended)
 // When UNROO_API_KEY is not set, Unroo calls go through FCP's proxy at /api/mcp/unroo/*
 const UNROO_API_URL = process.env.UNROO_API_URL || 'https://app.unroo.io';
@@ -112,6 +114,7 @@ const TOOL_PERMISSIONS = {
     fcp_backup_update_pairing: 'admin',
     fcp_backup_download: 'admin',
     fcp_backup_download_prepared: 'admin',
+    fcp_backup_get_database: 'admin',
     fcp_kinsta_backup_download: 'admin',
     fcp_filesync_start_sync: 'admin',
     fcp_filesync_get_confirmation: 'admin',
@@ -2811,7 +2814,7 @@ const TOOLS = [
     },
     {
         name: 'fcp_shield_add_domain',
-        description: 'Add a domain to Fruition Shield WAF protection. Returns DNS records (traffic CNAME + cert validation CNAME) that must be added at the registrar.',
+        description: 'Add a domain to Fruition Shield WAF protection. Custom mode (default) fronts an origin server via the shared distribution. S3 mode (origin_type="s3") provisions a DEDICATED CloudFront distribution + OAC over a private S3 bucket (Steldris static hosting) and returns its distribution id + CloudFront domain. Returns DNS records to add at the registrar.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -2819,9 +2822,14 @@ const TOOLS = [
                     type: 'string',
                     description: 'Domain to protect (e.g., www.butterflies.org)',
                 },
+                origin_type: {
+                    type: 'string',
+                    enum: ['custom', 's3'],
+                    description: 'Origin mode: custom (shared distribution + origin server, default) or s3 (dedicated distribution + OAC over a private S3 bucket).',
+                },
                 origin_host: {
                     type: 'string',
-                    description: 'Origin server IP or hostname (e.g., 146.190.2.169 for K8s prod)',
+                    description: 'Origin server IP or hostname (e.g., 146.190.2.169 for K8s prod). Required for origin_type=custom; ignored for s3.',
                 },
                 origin_port: {
                     type: 'number',
@@ -2831,6 +2839,18 @@ const TOOLS = [
                     type: 'string',
                     description: 'Origin protocol: http or https (default: https)',
                 },
+                s3_bucket: {
+                    type: 'string',
+                    description: 'S3 artifacts bucket (origin_type=s3, e.g. steldris-sites-prod). Required for s3 mode.',
+                },
+                s3_region: {
+                    type: 'string',
+                    description: 'S3 bucket region (origin_type=s3, e.g. us-east-1). Required for s3 mode.',
+                },
+                s3_origin_path: {
+                    type: 'string',
+                    description: 'CloudFront OriginPath — the per-tenant key prefix (origin_type=s3, e.g. /acme).',
+                },
                 website_id: {
                     type: 'number',
                     description: 'Link to existing FCP website ID',
@@ -2841,14 +2861,14 @@ const TOOLS = [
                 },
                 cache_profile: {
                     type: 'string',
-                    description: 'Cache profile: standard, aggressive, minimal, none (default: standard)',
+                    description: 'Cache profile: standard, aggressive, minimal, none (default: standard; s3 defaults to aggressive)',
                 },
                 notes: {
                     type: 'string',
                     description: 'Notes about this domain',
                 },
             },
-            required: ['domain', 'origin_host'],
+            required: ['domain'],
         },
     },
     {
@@ -3201,6 +3221,36 @@ const TOOLS = [
             required: ['jobId'],
         },
     },
+    {
+        name: 'fcp_backup_get_database',
+        description: 'Return a database backup for a site in ONE call. Reuses the most recent completed backup if it is younger than maxAgeHours, otherwise triggers a fresh one and waits. Production data is sanitized by default. Returns a presigned download URL (1h expiry) when ready. If the backup or sanitization is still running when waitSeconds is exhausted, returns status:"pending" with a handle (backupId or sanitizeJobId) so you can poll fcp_backup_get_status / fcp_backup_sanitize_status and re-call. Admin only.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                websiteId: {
+                    type: 'number',
+                    description: 'The website ID to back up',
+                },
+                maxAgeHours: {
+                    type: 'number',
+                    description: 'Reuse the latest completed backup if it is younger than this many hours (default: 24). Ignored when fresh=true.',
+                },
+                fresh: {
+                    type: 'boolean',
+                    description: 'Force a brand-new backup, ignoring any existing one (default: false).',
+                },
+                sanitize: {
+                    type: 'boolean',
+                    description: 'Whether to sanitize production data. Leave unset to use the server default (production is sanitized, non-production is returned raw). Set false to force a raw dump (admin, use with care).',
+                },
+                waitSeconds: {
+                    type: 'number',
+                    description: 'Total bounded wait budget in seconds across the trigger and sanitize polls (default: 180). On exhaustion the tool returns status:"pending" with a resume handle rather than hanging.',
+                },
+            },
+            required: ['websiteId'],
+        },
+    },
     {
         name: 'fcp_backup_list_pairings',
         description: 'List site pairings for backup management. Optionally filter by site ID. Shows production/staging/dev relationships grouped by account.',
@@ -4734,9 +4784,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case 'fcp_shield_add_domain': {
-                const { domain, origin_host, origin_port, origin_protocol, website_id, account_id, cache_profile, notes } = args;
+                const { domain, origin_type, origin_host, origin_port, origin_protocol, s3_bucket, s3_region, s3_origin_path, website_id, account_id, cache_profile, notes } = args;
                 const result = await client.shieldAddDomain({
-                    domain, origin_host, origin_port, origin_protocol, website_id, account_id, cache_profile, notes,
+                    domain, origin_type, origin_host, origin_port, origin_protocol, s3_bucket, s3_region, s3_origin_path, website_id, account_id, cache_profile, notes,
                 });
                 return {
                     content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
@@ -4912,6 +4962,138 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                 };
             }
+            case 'fcp_backup_get_database': {
+                const { websiteId, maxAgeHours = 24, fresh = false, sanitize, waitSeconds = 180, } = args;
+                const siteId = `site-${websiteId}`;
+                const deadline = Date.now() + Math.max(0, waitSeconds) * 1000;
+                const pollIntervalMs = 10_000;
+                const isDbType = (t) => !!t && ['mysql', 'database', 'postgresql', 'mysqldump'].includes(String(t).toLowerCase());
+                const respond = (payload) => ({
+                    content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+                });
+                let backupId;
+                let ageMinutes;
+                // 1. Reuse the most recent completed DB backup unless a fresh one is requested.
+                if (!fresh) {
+                    const list = await client.backupListBackups(siteId);
+                    const backups = Array.isArray(list) ? list : (list?.backups ?? []);
+                    const completed = backups
+                        .filter((b) => b?.status === 'completed' && isDbType(b?.backup_type) && b?.backup_location)
+                        .sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+                    const latest = completed[0];
+                    if (latest?.created_at) {
+                        ageMinutes = (Date.now() - new Date(latest.created_at).getTime()) / 60_000;
+                        if (ageMinutes <= maxAgeHours * 60) {
+                            backupId = latest.backup_id;
+                        }
+                    }
+                }
+                // 2. Trigger a fresh backup if none reusable, then poll until completed.
+                if (!backupId) {
+                    const trig = await client.backupTrigger(websiteId, 'mcp');
+                    if (!trig?.backupId) {
+                        return respond({
+                            status: 'error',
+                            stage: 'trigger',
+                            message: trig?.error || trig?.message || 'Failed to trigger backup',
+                            detail: trig,
+                        });
+                    }
+                    backupId = trig.backupId;
+                    ageMinutes = 0;
+                    let backupStatus = trig.status || 'queued';
+                    while (backupStatus !== 'completed') {
+                        if (Date.now() >= deadline) {
+                            return respond({
+                                status: 'pending',
+                                stage: 'backup',
+                                backupId,
+                                message: `Backup still '${backupStatus}' after ${waitSeconds}s. Poll fcp_backup_get_status({ backupId: "${backupId}" }), then re-call fcp_backup_get_database to reuse it once completed.`,
+                            });
+                        }
+                        await sleep(pollIntervalMs);
+                        const st = await client.backupGetStatus({ backupId });
+                        const job = st?.job ?? st;
+                        backupStatus = job?.status || backupStatus;
+                        if (backupStatus === 'failed') {
+                            return respond({
+                                status: 'error',
+                                stage: 'backup',
+                                backupId,
+                                message: job?.error_message || 'Backup job failed',
+                            });
+                        }
+                    }
+                }
+                // 3. Prepare the download (sanitizes production data by default).
+                const prep = await client.backupDownloadPrepared({
+                    siteId,
+                    backupId: backupId,
+                    downloadType: 'database',
+                    sanitize,
+                });
+                // Non-production (or explicit sanitize:false): direct presigned URL.
+                if (prep?.downloadUrl && prep?.sanitized !== true) {
+                    return respond({
+                        status: 'ready',
+                        backupId,
+                        sanitized: false,
+                        downloadUrl: prep.downloadUrl,
+                        fileName: prep.fileName,
+                        sizeBytes: prep.sizeBytes,
+                        backupType: prep.backupType,
+                        ageMinutes: ageMinutes != null ? Math.round(ageMinutes) : undefined,
+                        expiresIn: 3600,
+                    });
+                }
+                // Production: poll the sanitization job until it produces a download URL.
+                if (prep?.jobId) {
+                    const sanitizeJobId = prep.jobId;
+                    for (;;) {
+                        if (Date.now() >= deadline) {
+                            return respond({
+                                status: 'pending',
+                                stage: 'sanitize',
+                                backupId,
+                                sanitizeJobId,
+                                message: `Sanitization still running after ${waitSeconds}s. Poll fcp_backup_sanitize_status({ jobId: "${sanitizeJobId}" }) for the download URL.`,
+                            });
+                        }
+                        await sleep(pollIntervalMs);
+                        const s = await client.backupSanitizeStatus(sanitizeJobId);
+                        if (s?.status === 'completed' && s?.downloadUrl) {
+                            return respond({
+                                status: 'ready',
+                                backupId,
+                                sanitizeJobId,
+                                sanitized: true,
+                                downloadUrl: s.downloadUrl,
+                                fileName: s.fileName,
+                                sizeBytes: s.sanitizedSizeBytes,
+                                ageMinutes: ageMinutes != null ? Math.round(ageMinutes) : undefined,
+                                expiresIn: 3600,
+                            });
+                        }
+                        if (s?.status === 'failed') {
+                            return respond({
+                                status: 'error',
+                                stage: 'sanitize',
+                                backupId,
+                                sanitizeJobId,
+                                message: s?.error || 'Sanitization failed',
+                            });
+                        }
+                    }
+                }
+                // Unexpected prepare response — surface it for debugging.
+                return respond({
+                    status: 'error',
+                    stage: 'prepare',
+                    backupId,
+                    message: 'Unexpected response from backup download preparation',
+                    detail: prep,
+                });
+            }
             case 'fcp_backup_list_pairings': {
                 const { siteId } = args;
                 const result = await client.backupListPairings(siteId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fruition/fcp-mcp-server",
-  "version": "1.25.0",
+  "version": "1.27.0",
   "description": "MCP Server for FCP Launch Coordination System - enables Claude Code to interact with FCP launches and track development time",
   "main": "dist/index.js",
   "type": "module",