@fruition/fcp-mcp-server 1.5.0 → 1.6.0

package/dist/index.js

@@ -45,6 +45,12 @@ const UNROO_API_KEY = process.env.UNROO_API_KEY || '';
 const USE_FCP_UNROO_PROXY = !UNROO_API_KEY;
 // Helper to check if Unroo functionality is available (either mode)
 const UNROO_AVAILABLE = UNROO_API_KEY || (USE_FCP_UNROO_PROXY && FCP_API_TOKEN);
+// Unique instance ID for this MCP server process
+// Combines hostname + PID + startup timestamp to ensure uniqueness across:
+// - Multiple machines (hostname)
+// - Multiple processes on same machine (PID)
+// - Process restarts (timestamp)
+const INSTANCE_ID = `${process.env.HOSTNAME || 'local'}-${process.pid}-${Date.now()}`;
 let currentProject = null;
 /**
  * Detect the current git remote URL
@@ -173,12 +179,48 @@ class FCPClient {
     async getLaunch(id) {
         return this.fetch(`/api/launches/${id}`);
     }
+    async createChecklistItem(launchId, input) {
+        return this.fetch(`/api/launches/${launchId}/checklist`, {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
     async updateChecklistItem(launchId, itemId, updates) {
         return this.fetch(`/api/launches/${launchId}/checklist/${itemId}`, {
             method: 'PUT',
             body: JSON.stringify(updates),
         });
     }
+    async deleteChecklistItem(launchId, itemId) {
+        return this.fetch(`/api/launches/${launchId}/checklist/${itemId}`, {
+            method: 'DELETE',
+        });
+    }
+    async createLaunch(input) {
+        return this.fetch('/api/launches', {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    async updateLaunch(id, updates) {
+        return this.fetch(`/api/launches/${id}`, {
+            method: 'PUT',
+            body: JSON.stringify(updates),
+        });
+    }
+    async deleteLaunch(id) {
+        return this.fetch(`/api/launches/${id}`, {
+            method: 'DELETE',
+        });
+    }
+    async getSuccessFactors(launchId, itemId) {
+        return this.fetch(`/api/launches/${launchId}/checklist/${itemId}/success-factors`);
+    }
+    async validateChecklistItem(launchId, itemId) {
+        return this.fetch(`/api/launches/${launchId}/checklist/${itemId}/validate`, {
+            method: 'POST',
+        });
+    }
     async getClaudeMd(launchId) {
         return this.fetch(`/api/launches/${launchId}/claude-md`);
     }
@@ -188,6 +230,105 @@ class FCPClient {
             body: JSON.stringify({ content }),
         });
     }
+    // FileSync methods
+    async listFileSyncConfigs(filters) {
+        const params = new URLSearchParams();
+        if (filters?.enabled !== undefined)
+            params.set('enabled', String(filters.enabled));
+        if (filters?.sync_direction)
+            params.set('sync_direction', filters.sync_direction);
+        const query = params.toString();
+        return this.fetch(`/api/filesync/configs${query ? `?${query}` : ''}`);
+    }
+    async getFileSyncJobs(filters) {
+        const params = new URLSearchParams();
+        if (filters?.config_id)
+            params.set('config_id', String(filters.config_id));
+        if (filters?.status)
+            params.set('status', filters.status);
+        if (filters?.limit)
+            params.set('limit', String(filters.limit));
+        const query = params.toString();
+        return this.fetch(`/api/filesync/jobs${query ? `?${query}` : ''}`);
+    }
+    async startFileSync(input) {
+        return this.fetch('/api/filesync/start', {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    async cancelFileSync(jobId) {
+        return this.fetch(`/api/filesync/cancel/${encodeURIComponent(jobId)}`, {
+            method: 'POST',
+        });
+    }
+    async getFileSyncConfirmation(configId) {
+        return this.fetch('/api/filesync/confirm', {
+            method: 'POST',
+            body: JSON.stringify({ config_id: configId }),
+        });
+    }
+    async triggerNucleiScan(websiteId, options) {
+        return this.fetch(`/api/sites/${websiteId}/nuclei-scan`, {
+            method: 'POST',
+            body: JSON.stringify(options || {}),
+        }, 30000);
+    }
+    async getNucleiResults(websiteId, options) {
+        // If scan_id provided, get detailed results for that specific scan
+        if (options?.scan_id) {
+            return this.fetch(`/api/sites/${websiteId}/nuclei-scans/${options.scan_id}`);
+        }
+        // Otherwise, get scan history list
+        return this.fetch(`/api/sites/${websiteId}/nuclei-scans`);
+    }
+    // Site/Website CRUD Methods
+    async listSites(filters) {
+        const params = new URLSearchParams();
+        if (filters?.account_id)
+            params.set('account_id', filters.account_id.toString());
+        if (filters?.cms)
+            params.set('cms', filters.cms);
+        if (filters?.environment)
+            params.set('environment', filters.environment);
+        if (filters?.fru_hosted !== undefined)
+            params.set('fru_hosted', String(filters.fru_hosted));
+        if (filters?.retired)
+            params.set('retired', filters.retired);
+        if (filters?.limit)
+            params.set('limit', filters.limit.toString());
+        if (filters?.offset)
+            params.set('offset', filters.offset.toString());
+        const query = params.toString();
+        return this.fetch(`/api/sites${query ? `?${query}` : ''}`);
+    }
+    async searchSites(query, limit) {
+        const params = new URLSearchParams({ q: query });
+        if (limit)
+            params.set('limit', limit.toString());
+        return this.fetch(`/api/sites/search?${params.toString()}`);
+    }
+    async getSite(siteId) {
+        return this.fetch(`/api/sites/${siteId}`);
+    }
+    async createSite(production, staging) {
+        return this.fetch('/api/projects/websites/create-with-staging', {
+            method: 'POST',
+            body: JSON.stringify({ production, staging: staging || [] }),
+        });
+    }
+    async updateSite(siteId, updates) {
+        return this.fetch(`/api/sites/${siteId}`, {
+            method: 'PUT',
+            body: JSON.stringify(updates),
+        });
+    }
+    async deleteSite(siteId, options) {
+        return this.fetch(`/api/sites/${siteId}`, {
+            method: 'DELETE',
+            body: JSON.stringify(options || {}),
+        });
+    }
 }
 // Unroo API Client
 // Supports two modes:
@@ -287,10 +428,10 @@ class UnrooClient {
             body: JSON.stringify({ action: 'start', ...input }),
         });
     }
-    async endSession() {
+    async endSession(input) {
         return this.fetch('/api/external/fcp/sessions', {
             method: 'POST',
-            body: JSON.stringify({ action: 'end' }),
+            body: JSON.stringify({ action: 'end', ...input }),
         });
     }
     async sessionHeartbeat(input) {
@@ -418,7 +559,7 @@ class SessionTracker {
             const sessionInput = {
                 task_id: this.currentTaskId || undefined,
                 source: 'claude-code-mcp',
-                machine_id: process.env.HOSTNAME || 'unknown',
+                machine_id: INSTANCE_ID, // Unique per MCP server process to prevent session collision
             };
             // Add auto-detected project info
             if (currentProject) {
@@ -459,6 +600,8 @@ class SessionTracker {
             await this.unrooClient.sessionHeartbeat({
                 tool_calls_delta: this.toolCallCount,
                 activity: this.activities.slice(-10), // Send last 10 activities
+                machine_id: INSTANCE_ID, // Required for session key lookup
+                repo_name: currentProject ? `${currentProject.github.owner}/${currentProject.github.repo}` : undefined,
             });
             this.lastHeartbeat = new Date();
             this.toolCallCount = 0;
@@ -483,8 +626,11 @@ class SessionTracker {
             this.heartbeatInterval = null;
         }
         try {
-            // End the session first
-            const result = await this.unrooClient.endSession();
+            // End the session first - include machine_id and repo_name for session key lookup
+            const result = await this.unrooClient.endSession({
+                machine_id: INSTANCE_ID,
+                repo_name: currentProject ? `${currentProject.github.owner}/${currentProject.github.repo}` : undefined,
+            });
             this.sessionActive = false;
             console.error('[SessionTracker] Session ended');
             // Log activity summary to the task if we have a current task
@@ -618,9 +764,72 @@ const TOOLS = [
             required: ['launch_id'],
         },
     },
+    {
+        name: 'fcp_add_checklist_item',
+        description: 'Add a new checklist item to a launch. Requires title and category at minimum.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                launch_id: {
+                    type: 'number',
+                    description: 'The ID of the launch',
+                },
+                title: {
+                    type: 'string',
+                    description: 'Title of the checklist item',
+                },
+                category: {
+                    type: 'string',
+                    enum: ['pre_launch', 'content', 'technical', 'seo', 'testing', 'dns', 'monitoring', 'post_launch'],
+                    description: 'Category for the checklist item',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Detailed description of the item',
+                },
+                role: {
+                    type: 'string',
+                    description: 'Team role responsible: webops, devops, dev, seo, client',
+                },
+                environment: {
+                    type: 'string',
+                    description: 'Environment: production, staging, both',
+                },
+                assigned_to_id: {
+                    type: 'number',
+                    description: 'User ID to assign the item to',
+                },
+                due_date: {
+                    type: 'string',
+                    description: 'Due date in ISO format',
+                },
+                sort_order: {
+                    type: 'number',
+                    description: 'Sort order within the category',
+                },
+                depends_on_item_id: {
+                    type: 'number',
+                    description: 'ID of another checklist item this depends on',
+                },
+                is_required: {
+                    type: 'boolean',
+                    description: 'Whether this item is required for launch (default: true)',
+                },
+                is_blocking: {
+                    type: 'boolean',
+                    description: 'Whether this item blocks the launch (default: false)',
+                },
+                external_link: {
+                    type: 'string',
+                    description: 'External URL related to this item',
+                },
+            },
+            required: ['launch_id', 'title', 'category'],
+        },
+    },
     {
         name: 'fcp_update_checklist_item',
-        description: 'Update the status of a checklist item. Use this to mark items as completed, in_progress, or blocked as you work through tasks.',
+        description: 'Update a checklist item. Can change status, title, description, category, assignment, and other fields.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -639,10 +848,85 @@ const TOOLS = [
                 },
                 notes: {
                     type: 'string',
-                    description: 'Optional notes about the status change',
+                    description: 'Notes about the status change (alias for completion_notes)',
+                },
+                title: {
+                    type: 'string',
+                    description: 'Updated title',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Updated description (null to clear)',
+                },
+                category: {
+                    type: 'string',
+                    enum: ['pre_launch', 'content', 'technical', 'seo', 'testing', 'dns', 'monitoring', 'post_launch'],
+                    description: 'Updated category',
+                },
+                role: {
+                    type: 'string',
+                    description: 'Updated team role: webops, devops, dev, seo, client',
+                },
+                environment: {
+                    type: 'string',
+                    description: 'Updated environment: production, staging, both',
+                },
+                assigned_to_id: {
+                    type: 'number',
+                    description: 'User ID to assign to (null to unassign)',
+                },
+                due_date: {
+                    type: 'string',
+                    description: 'Updated due date in ISO format (null to clear)',
+                },
+                sort_order: {
+                    type: 'number',
+                    description: 'Updated sort order',
+                },
+                depends_on_item_id: {
+                    type: 'number',
+                    description: 'Updated dependency item ID (null to clear)',
+                },
+                is_required: {
+                    type: 'boolean',
+                    description: 'Whether this item is required for launch',
+                },
+                is_blocking: {
+                    type: 'boolean',
+                    description: 'Whether this item blocks the launch',
+                },
+                external_link: {
+                    type: 'string',
+                    description: 'External URL (null to clear)',
+                },
+                evidence_url: {
+                    type: 'string',
+                    description: 'URL to evidence of completion (null to clear)',
+                },
+                jira_ticket_key: {
+                    type: 'string',
+                    description: 'Associated Jira ticket key (null to clear)',
+                },
+            },
+            required: ['launch_id', 'item_id'],
+        },
+    },
+    {
+        name: 'fcp_delete_checklist_item',
+        description: 'Delete a checklist item from a launch. This action cannot be undone.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                launch_id: {
+                    type: 'number',
+                    description: 'The ID of the launch',
+                },
+                item_id: {
+                    type: 'number',
+                    description: 'The ID of the checklist item to delete',
                 },
             },
-            required: ['launch_id', 'item_id', 'status'],
+            required: ['launch_id', 'item_id'],
         },
     },
     {
@@ -677,109 +961,109 @@ const TOOLS = [
             required: ['launch_id'],
         },
     },
-    // Unroo Task Management Tools
-    {
-        name: 'unroo_list_projects',
-        description: 'List all Unroo projects mapped to FCP clients. Returns project mappings with organization and JIRA key info.',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
+    // Launch CRUD Tools
     {
-        name: 'unroo_list_tasks',
-        description: 'List tasks from Unroo with optional filters. Use to find tasks for a project, by status, or by assignee.',
+        name: 'fcp_create_launch',
+        description: 'Create a new launch in FCP. Requires name, platform, launch_type, and target_launch_date. Optionally creates a default checklist.',
         inputSchema: {
             type: 'object',
             properties: {
-                project_key: {
+                name: {
                     type: 'string',
-                    description: 'Filter by JIRA project key or FCP-SITE-{id}',
+                    description: 'Launch name (required)',
                 },
-                status: {
+                platform: {
                     type: 'string',
-                    description: 'Filter by status: To Do, In Progress, Done, Blocked (comma-separated for multiple)',
+                    enum: ['wordpress', 'drupal', 'nextjs', 'other'],
+                    description: 'Platform type (required)',
                 },
-                assignee_email: {
+                launch_type: {
                     type: 'string',
-                    description: 'Filter by assignee email',
+                    enum: ['new_site', 'migration', 'redesign', 'replatform', 'hosting_only', 'maintenance'],
+                    description: 'Type of launch (required)',
                 },
-                external_source_type: {
+                target_launch_date: {
                     type: 'string',
-                    description: 'Filter by source: fcp, fcp_checklist, fcp_launch',
+                    description: 'Target launch date in ISO format (required)',
                 },
-                limit: {
+                website_id: {
                     type: 'number',
-                    description: 'Maximum number of tasks to return (default 100)',
+                    description: 'Associated website ID',
                 },
-            },
-        },
-    },
-    {
-        name: 'unroo_create_task',
-        description: 'Create a new task in Unroo. Requires title and project_key. Use for follow-up tasks, discovered issues, or new work items.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                title: {
-                    type: 'string',
-                    description: 'Task title (required)',
+                account_id: {
+                    type: 'number',
+                    description: 'Associated account/client ID',
                 },
                 description: {
                     type: 'string',
-                    description: 'Detailed description of the task',
+                    description: 'Launch description',
                 },
-                project_key: {
+                soft_launch_date: {
                     type: 'string',
-                    description: 'JIRA project key or FCP-SITE-{id} (required)',
+                    description: 'Soft launch date in ISO format',
                 },
-                priority: {
+                kickoff_date: {
                     type: 'string',
-                    enum: ['urgent', 'high', 'medium', 'low'],
-                    description: 'Task priority (default: medium)',
+                    description: 'Kickoff date in ISO format',
                 },
-                status: {
+                priority: {
                     type: 'string',
-                    description: 'Initial status (default: To Do)',
+                    enum: ['low', 'medium', 'high', 'critical'],
+                    description: 'Launch priority (default: medium)',
                 },
-                assignee_email: {
+                jira_project_key: {
                     type: 'string',
-                    description: 'Email of person to assign the task to',
+                    description: 'Jira project key',
                 },
-                due_date: {
-                    type: 'string',
-                    description: 'Due date in ISO format',
+                unroo_project_id: {
+                    type: 'number',
+                    description: 'Unroo project ID to link',
                 },
-                hours_estimated: {
+                webops_lead_id: {
                     type: 'number',
-                    description: 'Estimated hours to complete',
+                    description: 'WebOps lead user ID',
                 },
-                labels: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Labels/tags for the task',
+                devops_lead_id: {
+                    type: 'number',
+                    description: 'DevOps lead user ID',
                 },
-                parent_issue_id: {
+                dev_lead_id: {
+                    type: 'number',
+                    description: 'Dev lead user ID',
+                },
+                seo_lead_id: {
+                    type: 'number',
+                    description: 'SEO lead user ID',
+                },
+                client_contact: {
                     type: 'string',
-                    description: 'Parent task ID if this is a subtask',
+                    description: 'Client contact name',
+                },
+                client_contact_email: {
+                    type: 'string',
+                    description: 'Client contact email',
+                },
+                use_default_checklist: {
+                    type: 'boolean',
+                    description: 'Whether to create default checklist items (default: true)',
                 },
             },
-            required: ['title', 'project_key'],
+            required: ['name', 'platform', 'launch_type', 'target_launch_date'],
         },
     },
     {
-        name: 'unroo_update_task',
-        description: 'Update an existing task in Unroo. Use to change status, log hours, update priority, or reassign.',
+        name: 'fcp_update_launch',
+        description: 'Update an existing launch. Only provided fields are updated. Can change status, dates, assignments, and other properties.',
         inputSchema: {
             type: 'object',
             properties: {
-                task_id: {
-                    type: 'string',
-                    description: 'The ID of the task to update (required)',
+                launch_id: {
+                    type: 'number',
+                    description: 'The ID of the launch to update (required)',
                 },
-                title: {
+                name: {
                     type: 'string',
-                    description: 'Updated title',
+                    description: 'Updated launch name',
                 },
                 description: {
                     type: 'string',
@@ -787,31 +1071,293 @@ const TOOLS = [
                 },
                 status: {
                     type: 'string',
-                    description: 'New status: To Do, In Progress, Done, Blocked',
+                    enum: ['planning', 'in_progress', 'soft_launched', 'launched', 'on_hold', 'cancelled'],
+                    description: 'Updated status',
+                },
+                platform: {
+                    type: 'string',
+                    enum: ['wordpress', 'drupal', 'nextjs', 'other'],
+                    description: 'Updated platform',
+                },
+                launch_type: {
+                    type: 'string',
+                    enum: ['new_site', 'migration', 'redesign', 'replatform', 'hosting_only', 'maintenance'],
+                    description: 'Updated launch type',
+                },
+                target_launch_date: {
+                    type: 'string',
+                    description: 'Updated target launch date',
+                },
+                soft_launch_date: {
+                    type: 'string',
+                    description: 'Updated soft launch date (null to clear)',
+                },
+                actual_launch_date: {
+                    type: 'string',
+                    description: 'Actual launch date when launched',
+                },
+                kickoff_date: {
+                    type: 'string',
+                    description: 'Updated kickoff date (null to clear)',
                 },
                 priority: {
                     type: 'string',
-                    enum: ['urgent', 'high', 'medium', 'low'],
+                    enum: ['low', 'medium', 'high', 'critical'],
                     description: 'Updated priority',
                 },
-                assignee_email: {
+                jira_project_key: {
                     type: 'string',
-                    description: 'New assignee email (null to unassign)',
+                    description: 'Jira project key (null to clear)',
                 },
-                hours_logged: {
+                unroo_project_id: {
                     type: 'number',
-                    description: 'Total hours logged on the task',
+                    description: 'Unroo project ID (null to unlink)',
                 },
-                resolution: {
+                webops_lead_id: {
+                    type: 'number',
+                    description: 'WebOps lead user ID (null to clear)',
+                },
+                devops_lead_id: {
+                    type: 'number',
+                    description: 'DevOps lead user ID (null to clear)',
+                },
+                dev_lead_id: {
+                    type: 'number',
+                    description: 'Dev lead user ID (null to clear)',
+                },
+                seo_lead_id: {
+                    type: 'number',
+                    description: 'SEO lead user ID (null to clear)',
+                },
+                client_contact: {
                     type: 'string',
-                    description: 'Resolution when marking as Done',
+                    description: 'Client contact name (null to clear)',
+                },
+                client_contact_email: {
+                    type: 'string',
+                    description: 'Client contact email (null to clear)',
                 },
             },
-            required: ['task_id'],
+            required: ['launch_id'],
         },
     },
     {
-        name: 'unroo_get_my_tasks',
+        name: 'fcp_delete_launch',
+        description: 'Delete a launch and all associated checklist items. This action cannot be undone.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                launch_id: {
+                    type: 'number',
+                    description: 'The ID of the launch to delete',
+                },
+            },
+            required: ['launch_id'],
+        },
+    },
+    // Validation / Success Factor Tools
+    {
+        name: 'fcp_get_success_factors',
+        description: 'Get the success factors (validation criteria) for a checklist item. Shows what automated checks are configured.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                launch_id: {
+                    type: 'number',
+                    description: 'The ID of the launch',
+                },
+                item_id: {
+                    type: 'number',
+                    description: 'The ID of the checklist item',
+                },
+            },
+            required: ['launch_id', 'item_id'],
+        },
+    },
+    {
+        name: 'fcp_validate_checklist_item',
+        description: 'Run automated validation checks on a checklist item. Executes all configured success factors (HTTP checks, DNS checks, SSL checks, etc.) and returns results.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                launch_id: {
+                    type: 'number',
+                    description: 'The ID of the launch',
+                },
+                item_id: {
+                    type: 'number',
+                    description: 'The ID of the checklist item to validate',
+                },
+            },
+            required: ['launch_id', 'item_id'],
+        },
+    },
+    {
+        name: 'fcp_get_unroo_section',
+        description: 'Generate the Unroo task management section for a CLAUDE.md file. Auto-detects project key from git remote. Use this to add Unroo integration instructions to any project.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repo_url: {
+                    type: 'string',
+                    description: 'Git remote URL (e.g., git@github.com:owner/repo.git). If not provided, uses current directory.',
+                },
+                project_key: {
+                    type: 'string',
+                    description: 'Manual project key override. Use if auto-detection fails.',
+                },
+            },
+        },
+    },
+    // Unroo Task Management Tools
+    {
+        name: 'unroo_list_projects',
+        description: 'List all Unroo projects mapped to FCP clients. Returns project mappings with organization and JIRA key info.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'unroo_list_tasks',
+        description: 'List tasks from Unroo with optional filters. Use to find tasks for a project, by status, or by assignee.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_key: {
+                    type: 'string',
+                    description: 'Filter by JIRA project key or FCP-SITE-{id}',
+                },
+                status: {
+                    type: 'string',
+                    description: 'Filter by status: To Do, In Progress, Done, Blocked (comma-separated for multiple)',
+                },
+                assignee_email: {
+                    type: 'string',
+                    description: 'Filter by assignee email',
+                },
+                external_source_type: {
+                    type: 'string',
+                    description: 'Filter by source: fcp, fcp_checklist, fcp_launch',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of tasks to return (default 100)',
+                },
+            },
+        },
+    },
+    {
+        name: 'unroo_create_task',
+        description: 'Create a new task in Unroo. Requires title and project_key. Use for follow-up tasks, discovered issues, or new work items.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: {
+                    type: 'string',
+                    description: 'Task title (required)',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Detailed description of the task',
+                },
+                project_key: {
+                    type: 'string',
+                    description: 'JIRA project key or FCP-SITE-{id} (required)',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['urgent', 'high', 'medium', 'low'],
+                    description: 'Task priority (default: medium)',
+                },
+                status: {
+                    type: 'string',
+                    description: 'Initial status (default: To Do)',
+                },
+                assignee_email: {
+                    type: 'string',
+                    description: 'Email of person to assign the task to',
+                },
+                due_date: {
+                    type: 'string',
+                    description: 'Due date in ISO format',
+                },
+                hours_estimated: {
+                    type: 'number',
+                    description: 'Estimated hours to complete',
+                },
+                labels: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Labels/tags for the task',
+                },
+                parent_issue_id: {
+                    type: 'string',
+                    description: 'Parent task ID if this is a subtask',
+                },
+            },
+            required: ['title', 'project_key'],
+        },
+    },
+    {
+        name: 'unroo_get_task',
+        description: 'Get detailed information about a specific task by ID. Returns full task details including description, status, priority, labels, hours, and activity.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                task_id: {
+                    type: 'string',
+                    description: 'The ID of the task to retrieve (required)',
+                },
+            },
+            required: ['task_id'],
+        },
+    },
+    {
+        name: 'unroo_update_task',
+        description: 'Update an existing task in Unroo. Use to change status, log hours, update priority, or reassign.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                task_id: {
+                    type: 'string',
+                    description: 'The ID of the task to update (required)',
+                },
+                title: {
+                    type: 'string',
+                    description: 'Updated title',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Updated description',
+                },
+                status: {
+                    type: 'string',
+                    description: 'New status: To Do, In Progress, Done, Blocked',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['urgent', 'high', 'medium', 'low'],
+                    description: 'Updated priority',
+                },
+                assignee_email: {
+                    type: 'string',
+                    description: 'New assignee email (null to unassign)',
+                },
+                hours_logged: {
+                    type: 'number',
+                    description: 'Total hours logged on the task',
+                },
+                resolution: {
+                    type: 'string',
+                    description: 'Resolution when marking as Done',
+                },
+            },
+            required: ['task_id'],
+        },
+    },
+    {
+        name: 'unroo_get_my_tasks',
         description: 'Get tasks assigned to the current user (based on API key). Useful for finding your work items.',
         inputSchema: {
             type: 'object',
@@ -994,17 +1540,399 @@ const TOOLS = [
                     type: 'string',
                     description: 'The ID of the parking lot item to convert (required)',
                 },
-                priority: {
+                priority: {
+                    type: 'string',
+                    enum: ['Urgent', 'High', 'Medium', 'Low'],
+                    description: 'Priority for the backlog item (optional, keeps original if not specified)',
+                },
+                notes: {
+                    type: 'string',
+                    description: 'Notes about the conversion decision',
+                },
+            },
+            required: ['id'],
+        },
+    },
+    // FileSync Tools
+    {
+        name: 'fcp_filesync_list_configs',
+        description: 'List all file sync configurations with current status. Shows prod/staging PVC pairs, scheduling, sync direction, and last sync info.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                enabled: {
+                    type: 'boolean',
+                    description: 'Filter by enabled status',
+                },
+                search: {
+                    type: 'string',
+                    description: 'Search across site names, clusters, namespaces',
+                },
+                sync_direction: {
+                    type: 'string',
+                    enum: ['prod_to_staging', 'staging_to_prod'],
+                    description: 'Filter by sync direction',
+                },
+            },
+        },
+    },
+    {
+        name: 'fcp_filesync_get_config',
+        description: 'Get detailed file sync config with recent job history. Returns full config, last 5 jobs, and scheduling info.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                config_id: {
+                    type: 'number',
+                    description: 'The config ID to retrieve',
+                },
+            },
+            required: ['config_id'],
+        },
+    },
+    {
+        name: 'fcp_filesync_start_sync',
+        description: 'Trigger a file sync immediately. For prod-to-staging syncs, executes directly. For staging-to-prod syncs, requires a confirmation_token from fcp_filesync_get_confirmation.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                config_id: {
+                    type: 'number',
+                    description: 'The config ID to sync',
+                },
+                confirmation_token: {
+                    type: 'string',
+                    description: 'Required for staging-to-prod syncs. Get from fcp_filesync_get_confirmation.',
+                },
+            },
+            required: ['config_id'],
+        },
+    },
+    {
+        name: 'fcp_filesync_get_job_status',
+        description: 'Get the status of a file sync job. Returns progress, current step, rsync stats, and timing info. Call in a loop to monitor a running sync.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                config_id: {
+                    type: 'number',
+                    description: 'The config ID to check jobs for',
+                },
+                status: {
+                    type: 'string',
+                    description: 'Filter by job status (e.g. pending, syncing, completed, failed)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Number of jobs to return (default 5)',
+                },
+            },
+            required: ['config_id'],
+        },
+    },
+    {
+        name: 'fcp_filesync_cancel_sync',
+        description: 'Cancel a running file sync. Kills the K8s Job and marks the job as cancelled.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                job_id: {
+                    type: 'string',
+                    description: 'The job ID (UUID) to cancel',
+                },
+            },
+            required: ['job_id'],
+        },
+    },
+    {
+        name: 'fcp_filesync_get_confirmation',
+        description: 'Generate a confirmation token for staging-to-prod syncs. Token is valid for 5 minutes. Use before fcp_filesync_start_sync for staging_to_prod direction.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                config_id: {
+                    type: 'number',
+                    description: 'The config ID requiring confirmation',
+                },
+            },
+            required: ['config_id'],
+        },
+    },
+    // Nuclei Security Scanning
+    {
+        name: 'fcp_trigger_nuclei_scan',
+        description: 'Trigger a Nuclei security scan for a website. Creates a Kubernetes Job that runs the scan and stores results in the FCP database.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                website_id: {
+                    type: 'number',
+                    description: 'The website ID to scan (required)',
+                },
+                url: {
+                    type: 'string',
+                    description: 'Override target URL (optional, auto-resolved from website record if not provided)',
+                },
+                severity: {
+                    type: 'string',
+                    description: 'Comma-separated severity levels to scan for (default: critical,high,medium)',
+                },
+                templates: {
+                    type: 'string',
+                    description: 'Comma-separated Nuclei template categories (default: cves,exposures,misconfiguration). Options: cves, vulnerabilities, exposures, misconfiguration, technologies',
+                },
+            },
+            required: ['website_id'],
+        },
+    },
+    {
+        name: 'fcp_get_nuclei_results',
+        description: 'Get Nuclei security scan results for a website. Returns scan history with findings summary and individual vulnerability details.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                website_id: {
+                    type: 'number',
+                    description: 'The website ID to get results for (required)',
+                },
+                scan_id: {
+                    type: 'string',
+                    description: 'Specific scan ID to get detailed results for (optional)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of scans to return (default: 5)',
+                },
+                status: {
+                    type: 'string',
+                    description: 'Filter findings by status: active, fixed, reopened, false_positive',
+                },
+            },
+            required: ['website_id'],
+        },
+    },
+    // Site/Website CRUD Tools
+    {
+        name: 'fcp_list_sites',
+        description: 'List websites managed by FCP with optional filters. Returns paginated results with account info.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                account_id: {
+                    type: 'number',
+                    description: 'Filter by account/client ID',
+                },
+                cms: {
+                    type: 'string',
+                    description: 'Filter by CMS type: WordPress, Drupal, Strapi, Other',
+                },
+                environment: {
+                    type: 'string',
+                    description: 'Filter by environment: production, staging, development',
+                },
+                retired: {
+                    type: 'string',
+                    description: 'Filter retired sites: "true" (only retired), "all" (include retired), omit for active only',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum results to return (default: 50, max: 200)',
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Offset for pagination (default: 0)',
+                },
+            },
+        },
+    },
+    {
+        name: 'fcp_search_sites',
+        description: 'Search websites by domain name, account name, or URL. Returns matching sites ranked by relevance.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Search query (min 2 characters) - matches against domain, account name, and URL',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum results to return (default: 10)',
+                },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'fcp_get_site',
+        description: 'Get detailed information about a specific website including account info, infrastructure details, and lead developer.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                website_id: {
+                    type: 'number',
+                    description: 'The website ID to retrieve',
+                },
+            },
+            required: ['website_id'],
+        },
+    },
+    {
+        name: 'fcp_create_site',
+        description: 'Create a new website with optional staging environments. Production site is created first, then staging sites are linked to it.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                account_id: {
+                    type: 'number',
+                    description: 'Account/client ID the site belongs to (required)',
+                },
+                domain: {
+                    type: 'string',
+                    description: 'Primary domain name, e.g. "example.com" (required)',
+                },
+                cms: {
+                    type: 'string',
+                    description: 'CMS type: WordPress, Drupal, Strapi, Other (required)',
+                },
+                url_full: {
+                    type: 'string',
+                    description: 'Full URL including protocol (default: https://<domain>)',
+                },
+                git_provider: {
+                    type: 'string',
+                    description: 'Git provider: GitHub, GitLab, Bitbucket (default: GitHub)',
+                },
+                git_link: {
+                    type: 'string',
+                    description: 'URL to the git repository',
+                },
+                hosting_provider: {
+                    type: 'string',
+                    description: 'Hosting provider name',
+                },
+                fru_hosted: {
+                    type: 'boolean',
+                    description: 'Whether the site is hosted on FruCloud (default: false)',
+                },
+                k8s_cluster: {
+                    type: 'string',
+                    description: 'Kubernetes cluster name if FruCloud hosted',
+                },
+                k8s_namespace: {
+                    type: 'string',
+                    description: 'Kubernetes namespace if FruCloud hosted',
+                },
+                staging: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            domain: { type: 'string', description: 'Staging domain' },
+                            k8s_namespace: { type: 'string', description: 'Staging K8s namespace' },
+                        },
+                        required: ['domain', 'k8s_namespace'],
+                    },
+                    description: 'Optional staging environments to create',
+                },
+            },
+            required: ['account_id', 'domain', 'cms'],
+        },
+    },
+    {
+        name: 'fcp_update_site',
+        description: 'Update properties of an existing website. Only provided fields are updated.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                website_id: {
+                    type: 'number',
+                    description: 'The website ID to update (required)',
+                },
+                domain: {
+                    type: 'string',
+                    description: 'Updated domain name',
+                },
+                url_full: {
+                    type: 'string',
+                    description: 'Updated full URL',
+                },
+                cms: {
+                    type: 'string',
+                    description: 'Updated CMS type',
+                },
+                git_provider: {
+                    type: 'string',
+                    description: 'Updated git provider',
+                },
+                git_link: {
+                    type: 'string',
+                    description: 'Updated git repository URL',
+                },
+                staging_url: {
+                    type: 'string',
+                    description: 'Updated staging URL',
+                },
+                hosting_provider: {
+                    type: 'string',
+                    description: 'Updated hosting provider',
+                },
+                fru_hosted: {
+                    type: 'boolean',
+                    description: 'Updated FruCloud hosting flag',
+                },
+                k8s_cluster: {
+                    type: 'string',
+                    description: 'Updated K8s cluster',
+                },
+                k8s_namespace: {
+                    type: 'string',
+                    description: 'Updated K8s namespace',
+                },
+                environment: {
+                    type: 'string',
+                    description: 'Updated environment: production, staging, development',
+                },
+                lead_developer: {
+                    type: 'number',
+                    description: 'Updated lead developer user ID',
+                },
+                frucare_site: {
+                    type: 'boolean',
+                    description: 'Updated FruCare maintenance flag',
+                },
+                backup_enabled: {
+                    type: 'boolean',
+                    description: 'Updated backup enabled flag',
+                },
+                backup_schedule: {
+                    type: 'string',
+                    description: 'Updated backup cron schedule',
+                },
+            },
+            required: ['website_id'],
+        },
+    },
+    {
+        name: 'fcp_delete_site',
+        description: 'Soft-delete (retire) a website. Sets retired flag and preserves all data. Admin only.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                website_id: {
+                    type: 'number',
+                    description: 'The website ID to retire (required)',
+                },
+                reason: {
                     type: 'string',
-                    enum: ['Urgent', 'High', 'Medium', 'Low'],
-                    description: 'Priority for the backlog item (optional, keeps original if not specified)',
+                    description: 'Reason for retiring the site',
                 },
-                notes: {
+                forward_url: {
                     type: 'string',
-                    description: 'Notes about the conversion decision',
+                    description: 'URL to forward the domain to after retirement',
                 },
             },
-            required: ['id'],
+            required: ['website_id'],
         },
     },
 ];
@@ -1096,11 +2024,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
-            case 'fcp_update_checklist_item': {
-                const { launch_id, item_id, status, notes } = args;
-                const result = await client.updateChecklistItem(launch_id, item_id, {
-                    status,
-                    notes,
+            case 'fcp_add_checklist_item': {
+                const { launch_id, title, category, ...rest } = args;
+                const result = await client.createChecklistItem(launch_id, {
+                    title,
+                    category,
+                    ...rest,
                 });
                 return {
                     content: [
@@ -1108,13 +2037,49 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             type: 'text',
                             text: JSON.stringify({
                                 success: true,
-                                message: `Checklist item ${item_id} updated to status: ${status}`,
+                                message: `Checklist item created: "${title}"`,
+                                item: result,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_update_checklist_item': {
+                const { launch_id, item_id, notes, ...updates } = args;
+                // Map 'notes' to 'completion_notes' for the API
+                const payload = { ...updates };
+                if (notes !== undefined) {
+                    payload.completion_notes = notes;
+                }
+                const result = await client.updateChecklistItem(launch_id, item_id, payload);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Checklist item ${item_id} updated`,
                                 item: result,
                             }, null, 2),
                         },
                     ],
                 };
             }
+            case 'fcp_delete_checklist_item': {
+                const { launch_id, item_id } = args;
+                await client.deleteChecklistItem(launch_id, item_id);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Checklist item ${item_id} deleted from launch ${launch_id}`,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
             case 'fcp_add_progress_note': {
                 const { launch_id, content } = args;
                 const result = await client.addNote(launch_id, content);
@@ -1143,6 +2108,244 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            // Nuclei Security Scanning Handlers
+            case 'fcp_trigger_nuclei_scan': {
+                const { website_id, url, severity, templates } = args;
+                const result = await client.triggerNucleiScan(website_id, { url, severity, templates });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_get_nuclei_results': {
+                const { website_id, scan_id, limit, status } = args;
+                const result = await client.getNucleiResults(website_id, { scan_id, limit, status });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            // Site/Website CRUD Handlers
+            case 'fcp_list_sites': {
+                const filters = args;
+                const result = await client.listSites(filters);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_search_sites': {
+                const { query, limit } = args;
+                const result = await client.searchSites(query, limit);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_get_site': {
+                const { website_id } = args;
+                const result = await client.getSite(website_id);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_create_site': {
+                const { account_id, domain, cms, url_full, git_provider, git_link, hosting_provider, fru_hosted, k8s_cluster, k8s_namespace, staging, } = args;
+                const result = await client.createSite({ account_id, domain, cms, url_full, git_provider, git_link, hosting_provider, fru_hosted, k8s_cluster, k8s_namespace }, staging);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_update_site': {
+                const { website_id, ...updates } = args;
+                const result = await client.updateSite(website_id, updates);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_delete_site': {
+                const { website_id, reason, forward_url } = args;
+                const result = await client.deleteSite(website_id, { reason, forward_url });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            // Launch CRUD Handlers
+            case 'fcp_create_launch': {
+                const { name, platform, launch_type, target_launch_date, ...rest } = args;
+                const result = await client.createLaunch({
+                    name,
+                    platform,
+                    launch_type,
+                    target_launch_date,
+                    ...rest,
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Launch created: "${name}" (ID: ${result.launch.id})`,
+                                launch: result.launch,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_update_launch': {
+                const { launch_id, ...updates } = args;
+                const result = await client.updateLaunch(launch_id, updates);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Launch ${launch_id} updated`,
+                                launch: result.launch || result,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_delete_launch': {
+                const { launch_id } = args;
+                await client.deleteLaunch(launch_id);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Launch ${launch_id} deleted`,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            // Validation / Success Factor Handlers
+            case 'fcp_get_success_factors': {
+                const { launch_id, item_id } = args;
+                const result = await client.getSuccessFactors(launch_id, item_id);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                checklist_item_id: item_id,
+                                total: result.factors?.length || 0,
+                                factors: result.factors || [],
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_validate_checklist_item': {
+                const { launch_id, item_id } = args;
+                const result = await client.validateChecklistItem(launch_id, item_id);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_get_unroo_section': {
+                const { repo_url, project_key } = args;
+                // Use provided repo_url or detect from current directory
+                const repoUrlToUse = repo_url || detectGitRemote();
+                if (!repoUrlToUse && !project_key) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    error: 'Could not detect git remote and no project_key provided. Either run this from a git repository or provide a project_key.',
+                                }, null, 2),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                // Build query params
+                const sectionParams = new URLSearchParams();
+                if (repoUrlToUse)
+                    sectionParams.set('repo_url', repoUrlToUse);
+                if (project_key)
+                    sectionParams.set('project_key', project_key);
+                // Call FCP API to get the section
+                const sectionUrl = `${FCP_API_URL}/api/mcp/claude-md-section?${sectionParams}`;
+                const sectionHeaders = {
+                    'Content-Type': 'application/json',
+                };
+                if (FCP_API_TOKEN && FCP_API_TOKEN !== 'dev_bypass') {
+                    sectionHeaders['X-API-Key'] = FCP_API_TOKEN;
+                }
+                else if (FCP_API_TOKEN === 'dev_bypass') {
+                    sectionHeaders['X-Dev-Bypass'] = 'true';
+                }
+                const response = await fetch(sectionUrl, { headers: sectionHeaders });
+                const data = await response.json();
+                if (!response.ok) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: data.error || 'Failed to get section' }, null, 2),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                // Return the markdown content with metadata
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Project Key: ${data.project_key}\nSource: ${data.source}\n${data.warning ? `Warning: ${data.warning}\n` : ''}\n---\n\n${data.content}`,
+                        },
+                    ],
+                };
+            }
             // Unroo Task Management Handlers
             case 'unroo_list_projects': {
                 const result = await unrooClient.listProjects();
@@ -1190,6 +2393,21 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            case 'unroo_get_task': {
+                const { task_id } = args;
+                const result = await unrooClient.getTask(task_id);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                task: result.task,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
             case 'unroo_update_task': {
                 const { task_id, ...updates } = args;
                 const result = await unrooClient.updateTask(task_id, updates);
@@ -1250,9 +2468,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case 'unroo_end_session': {
-                // End both explicit and auto-tracked sessions
+                // End the auto-tracked session (clears heartbeat interval, logs activity)
                 await sessionTracker.endSession();
-                const result = await unrooClient.endSession();
+                // End session via API to get the final session state
+                // Note: If sessionTracker already ended it, Unroo returns the existing completed session
+                // (protected against duplicate work log creation server-side)
+                const result = await unrooClient.endSession({
+                    machine_id: INSTANCE_ID,
+                    repo_name: currentProject ? `${currentProject.github.owner}/${currentProject.github.repo}` : undefined,
+                });
                 return {
                     content: [
                         {
@@ -1380,6 +2604,178 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            // FileSync Handlers
+            case 'fcp_filesync_list_configs': {
+                const filters = args;
+                const result = await client.listFileSyncConfigs(filters);
+                // If search is provided, filter client-side (API doesn't have text search)
+                let configs = result.data || [];
+                if (filters.search) {
+                    const term = filters.search.toLowerCase();
+                    configs = configs.filter((c) => (c.prod_namespace || '').toLowerCase().includes(term) ||
+                        (c.staging_namespace || '').toLowerCase().includes(term) ||
+                        (c.prod_cluster || '').toLowerCase().includes(term) ||
+                        (c.staging_cluster || '').toLowerCase().includes(term) ||
+                        (c.prod_pvc_name || '').toLowerCase().includes(term) ||
+                        (c.staging_pvc_name || '').toLowerCase().includes(term));
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                total: configs.length,
+                                configs: configs.map((c) => ({
+                                    id: c.id,
+                                    prod_namespace: c.prod_namespace,
+                                    staging_namespace: c.staging_namespace,
+                                    prod_cluster: c.prod_cluster,
+                                    staging_cluster: c.staging_cluster,
+                                    sync_direction: c.sync_direction,
+                                    sync_method: c.sync_method,
+                                    enabled: c.enabled,
+                                    schedule_enabled: c.schedule_enabled,
+                                    schedule_cron: c.schedule_cron,
+                                    last_sync_at: c.last_sync_at,
+                                    last_sync_status: c.last_sync_status,
+                                })),
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_filesync_get_config': {
+                const { config_id } = args;
+                // Get config from list (filtered by looking through all)
+                const configsResult = await client.listFileSyncConfigs();
+                const config = (configsResult.data || []).find((c) => c.id === config_id);
+                if (!config) {
+                    throw new Error(`Config not found: ${config_id}`);
+                }
+                // Get recent jobs for this config
+                const jobsResult = await client.getFileSyncJobs({ config_id, limit: 5 });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                config,
+                                recent_jobs: (jobsResult.data || []).map((j) => ({
+                                    id: j.id,
+                                    job_id: j.job_id,
+                                    status: j.status,
+                                    trigger_type: j.trigger_type,
+                                    progress_percent: j.progress_percent,
+                                    current_step: j.current_step,
+                                    started_at: j.started_at,
+                                    completed_at: j.completed_at,
+                                    duration_seconds: j.duration_seconds,
+                                    files_transferred: j.files_transferred,
+                                    bytes_transferred: j.bytes_transferred,
+                                    error_message: j.error_message,
+                                })),
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_filesync_start_sync': {
+                const { config_id, confirmation_token } = args;
+                console.error(`[MCP] Starting file sync for config ${config_id}`);
+                const result = await client.startFileSync({
+                    config_id,
+                    trigger_type: 'api',
+                    triggered_by: 'claude-code-mcp',
+                    confirmation_token,
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: result.success,
+                                message: result.message,
+                                job: result.data ? {
+                                    id: result.data.id,
+                                    job_id: result.data.job_id,
+                                    status: result.data.status,
+                                    current_step: result.data.current_step,
+                                } : null,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_filesync_get_job_status': {
+                const { config_id, status, limit } = args;
+                const result = await client.getFileSyncJobs({
+                    config_id,
+                    status,
+                    limit: limit || 5,
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                total: (result.data || []).length,
+                                jobs: (result.data || []).map((j) => ({
+                                    id: j.id,
+                                    job_id: j.job_id,
+                                    status: j.status,
+                                    trigger_type: j.trigger_type,
+                                    progress_percent: j.progress_percent,
+                                    current_step: j.current_step,
+                                    started_at: j.started_at,
+                                    completed_at: j.completed_at,
+                                    duration_seconds: j.duration_seconds,
+                                    files_transferred: j.files_transferred,
+                                    files_deleted: j.files_deleted,
+                                    bytes_transferred: j.bytes_transferred,
+                                    error_message: j.error_message,
+                                    rsync_stats: j.rsync_stats,
+                                })),
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_filesync_cancel_sync': {
+                const { job_id } = args;
+                console.error(`[MCP] Cancelling file sync job ${job_id}`);
+                const result = await client.cancelFileSync(job_id);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: result.success,
+                                message: result.message,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_filesync_get_confirmation': {
+                const { config_id } = args;
+                console.error(`[MCP] Getting confirmation token for config ${config_id}`);
+                const result = await client.getFileSyncConfirmation(config_id);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: result.success,
+                                confirmation_token: result.data.token,
+                                config_id: result.data.config_id,
+                                expires_at: result.data.expires_at,
+                                ttl_seconds: result.data.ttl_seconds,
+                                warnings: result.data.warnings,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }