@fruition/fcp-mcp-server 1.19.0 → 1.21.0

package/dist/index.js

@@ -1,4262 +0,0 @@
-#!/usr/bin/env node
-/**
- * FCP MCP Server
- *
- * Provides Claude Code with direct access to FCP Launch Coordination System:
- * - Query launches, checklists, and legacy access info
- * - Update checklist item status
- * - Get project context for migrations
- */
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-// Get version from package.json
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const packageJsonPath = join(__dirname, '..', 'package.json');
-let MCP_SERVER_VERSION = '1.0.0'; // fallback
-try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-    MCP_SERVER_VERSION = packageJson.version;
-}
-catch {
-    // Try one level up (for dist folder)
-    try {
-        const altPath = join(__dirname, '..', '..', 'package.json');
-        const packageJson = JSON.parse(readFileSync(altPath, 'utf-8'));
-        MCP_SERVER_VERSION = packageJson.version;
-    }
-    catch {
-        console.error('[MCP Server] Warning: Could not read package.json version');
-    }
-}
-import { execSync } from 'child_process';
-import { runSkillsCli } from './skills-sync-cli.js';
-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 || '';
-// 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';
-const UNROO_API_KEY = process.env.UNROO_API_KEY || '';
-// User identity for Unroo attribution
-// Without this, all actions are attributed to whoever created the FCP API key
-// Falls back to git config user.email for zero-config setup
-function detectUserEmail() {
-    if (process.env.FCP_USER_EMAIL)
-        return process.env.FCP_USER_EMAIL;
-    try {
-        const email = execSync('git config user.email', {
-            encoding: 'utf-8',
-            timeout: 3000,
-            stdio: ['pipe', 'pipe', 'ignore'],
-        }).trim();
-        if (email) {
-            console.error(`[MCP Server] Auto-detected user email: ${email}`);
-            return email;
-        }
-    }
-    catch {
-        // Not in a git repo or no email configured
-    }
-    console.error('[MCP Server] WARNING: FCP_USER_EMAIL not set and git email not detected. Unroo task updates will be attributed to the FCP API key owner, not you. Set FCP_USER_EMAIL in your MCP server env config.');
-    return '';
-}
-const FCP_USER_EMAIL = detectUserEmail();
-// If no Unroo key, use FCP as proxy (unified key setup)
-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()}`;
-const ROLE_HIERARCHY = [
-    'super_admin',
-    'admin',
-    'billing_admin',
-    'operator',
-    'viewer',
-    'none',
-];
-const TOOL_PERMISSIONS = {
-    // --- super_admin only: destructive, irreversible, or move raw prod data ---
-    fcp_create_site: 'super_admin',
-    fcp_delete_site: 'super_admin',
-    fcp_delete_launch: 'super_admin',
-    fcp_clone_to_staging: 'super_admin',
-    fcp_clone_confirm: 'super_admin',
-    fcp_shield_remove_domain: 'super_admin',
-    fcp_backup_delete_pairing: 'super_admin',
-    fcp_filesync_cancel_sync: 'super_admin',
-    // --- admin+: mutating ops with real-world side effects ---
-    fcp_create_launch: 'admin',
-    fcp_update_launch: 'admin',
-    fcp_update_site: 'admin',
-    fcp_delete_checklist_item: 'admin',
-    fcp_shield_add_domain: 'admin',
-    fcp_shield_update_domain: 'admin',
-    fcp_backup_enable: 'admin',
-    fcp_backup_trigger: 'admin',
-    fcp_backup_check_trigger: 'admin',
-    fcp_backup_update_pairing: 'admin',
-    fcp_backup_download: 'admin',
-    fcp_backup_download_prepared: 'admin',
-    fcp_kinsta_backup_download: 'admin',
-    fcp_filesync_start_sync: 'admin',
-    fcp_filesync_get_confirmation: 'admin',
-    fcp_trigger_nuclei_scan: 'admin',
-    fcp_scan_security_headers: 'admin',
-    // --- operator+: routine writes (checklists, progress notes, Unroo tasks) ---
-    fcp_add_checklist_item: 'operator',
-    fcp_update_checklist_item: 'operator',
-    fcp_validate_checklist_item: 'operator',
-    fcp_add_progress_note: 'operator',
-    unroo_create_task: 'operator',
-    unroo_update_task: 'operator',
-    unroo_add_comment: 'operator',
-    unroo_create_follow_up: 'operator',
-    unroo_log_future_work: 'operator',
-    unroo_convert_to_backlog: 'operator',
-    unroo_start_session: 'operator',
-    unroo_end_session: 'operator',
-    // --- viewer (read-only) — explicit for clarity; any unmapped tool also defaults here ---
-    fcp_list_launches: 'viewer',
-    fcp_get_launch: 'viewer',
-    fcp_get_legacy_access: 'viewer',
-    fcp_get_checklist: 'viewer',
-    fcp_get_claude_md: 'viewer',
-    fcp_get_success_factors: 'viewer',
-    fcp_get_unroo_section: 'viewer',
-    fcp_filesync_list_configs: 'viewer',
-    fcp_filesync_get_config: 'viewer',
-    fcp_filesync_get_job_status: 'viewer',
-    fcp_get_nuclei_results: 'viewer',
-    fcp_get_security_headers_results: 'viewer',
-    fcp_list_sites: 'viewer',
-    fcp_search_sites: 'viewer',
-    fcp_get_site: 'viewer',
-    fcp_get_local_setup_guide: 'viewer',
-    fcp_shield_list_domains: 'viewer',
-    fcp_shield_get_domain: 'viewer',
-    fcp_shield_get_metrics: 'viewer',
-    fcp_backup_list_sites: 'viewer',
-    fcp_backup_get_config: 'viewer',
-    fcp_backup_list_eligible: 'viewer',
-    fcp_backup_list_backups: 'viewer',
-    fcp_backup_get_status: 'viewer',
-    fcp_backup_sanitize_status: 'viewer',
-    fcp_backup_list_pairings: 'viewer',
-    fcp_kinsta_backup_list_sites: 'viewer',
-    fcp_kinsta_backup_list: 'viewer',
-    fcp_clone_status: 'viewer',
-    fcp_clone_list: 'viewer',
-    fcp_get_dev_environment_info: 'viewer',
-    unroo_list_projects: 'viewer',
-    unroo_list_tasks: 'viewer',
-    unroo_get_task: 'viewer',
-    unroo_list_comments: 'viewer',
-    unroo_get_my_tasks: 'viewer',
-    unroo_get_parking_lot: 'viewer',
-    unroo_get_backlog: 'viewer',
-};
-// Resolved role for the current API key. Cached only on successful lookup so
-// transient FCP outages don't pin us to 'none' for the rest of the session.
-let cachedUserRole;
-async function fetchUserRole() {
-    if (cachedUserRole !== undefined)
-        return cachedUserRole;
-    // dev_bypass is the local-dev token; treat as super_admin to avoid
-    // gating local development against role lookup.
-    if (FCP_API_TOKEN === 'dev_bypass') {
-        cachedUserRole = 'super_admin';
-        return cachedUserRole;
-    }
-    if (!FCP_API_TOKEN) {
-        return 'none';
-    }
-    try {
-        const res = await fetch(`${FCP_API_URL}/api/mcp/me`, {
-            headers: { 'X-API-Key': FCP_API_TOKEN },
-            signal: AbortSignal.timeout(10_000),
-        });
-        if (!res.ok) {
-            console.error(`[MCP Server] Role lookup failed: HTTP ${res.status}`);
-            return 'none';
-        }
-        const data = await res.json();
-        const role = data?.role ?? 'none';
-        cachedUserRole = role;
-        console.error(`[MCP Server] Resolved user role: ${role} (${data?.email ?? 'unknown'})`);
-        return role;
-    }
-    catch (err) {
-        console.error('[MCP Server] Role lookup error:', err);
-        return 'none';
-    }
-}
-function isRoleAtLeast(actual, required) {
-    if (actual === 'none')
-        return required === 'none';
-    const a = ROLE_HIERARCHY.indexOf(actual);
-    const r = ROLE_HIERARCHY.indexOf(required);
-    if (a === -1 || r === -1)
-        return false;
-    return a <= r;
-}
-async function enforceToolPermission(toolName) {
-    const required = TOOL_PERMISSIONS[toolName] ?? 'viewer';
-    const actual = await fetchUserRole();
-    if (!isRoleAtLeast(actual, required)) {
-        throw new Error(`Permission denied: tool '${toolName}' requires ${required} role; ` +
-            `your role is '${actual}'. Contact a super_admin (Brad, Mattox, or Andrea) ` +
-            `if you need access.`);
-    }
-}
-let currentProject = null;
-/**
- * Detect the current git remote URL
- */
-function detectGitRemote() {
-    try {
-        const remote = execSync('git config --get remote.origin.url', {
-            encoding: 'utf-8',
-            timeout: 5000,
-            stdio: ['pipe', 'pipe', 'ignore'],
-        }).trim();
-        return remote || null;
-    }
-    catch {
-        // Not a git repo or no remote configured
-        return null;
-    }
-}
-/**
- * Resolve project from git remote URL via FCP API
- */
-async function resolveProjectFromRepo(repoUrl) {
-    if (!FCP_API_URL) {
-        return null;
-    }
-    try {
-        const url = `${FCP_API_URL}/api/mcp/resolve-project?repo_url=${encodeURIComponent(repoUrl)}`;
-        const headers = {
-            'Content-Type': 'application/json',
-        };
-        if (FCP_API_TOKEN && FCP_API_TOKEN !== 'dev_bypass') {
-            headers['X-API-Key'] = FCP_API_TOKEN;
-        }
-        else if (FCP_API_TOKEN === 'dev_bypass') {
-            headers['X-Dev-Bypass'] = 'true';
-        }
-        const response = await fetch(url, { headers });
-        if (!response.ok) {
-            return null;
-        }
-        const data = await response.json();
-        if (data.found && data.project) {
-            return {
-                project_key: data.project.project_key,
-                website_id: data.project.website_id,
-                domain: data.project.domain,
-                account_name: data.project.account_name || 'Unknown',
-                github: data.project.github,
-            };
-        }
-        return null;
-    }
-    catch (error) {
-        console.error('[MCP Server] Error resolving project:', error);
-        return null;
-    }
-}
-/**
- * Initialize project detection on startup
- */
-async function initializeProjectDetection() {
-    const remoteUrl = detectGitRemote();
-    if (!remoteUrl) {
-        console.error('[MCP Server] No git remote detected - project will be tracked as general');
-        return;
-    }
-    console.error(`[MCP Server] Detected git remote: ${remoteUrl}`);
-    const project = await resolveProjectFromRepo(remoteUrl);
-    if (project) {
-        currentProject = project;
-        console.error(`[MCP Server] Resolved project: ${project.domain} (${project.project_key})`);
-    }
-    else {
-        console.error('[MCP Server] Could not resolve project from repo - check FCP website github config');
-    }
-}
-// API Client
-class FCPClient {
-    baseUrl;
-    token;
-    defaultTimeout = 15000; // 15 seconds
-    constructor(baseUrl, token) {
-        this.baseUrl = baseUrl;
-        this.token = token;
-    }
-    async fetch(path, options = {}, timeoutMs) {
-        const url = `${this.baseUrl}${path}`;
-        const headers = {
-            'Content-Type': 'application/json',
-            ...(options.headers || {}),
-        };
-        if (this.token) {
-            // Support dev bypass mode for local testing
-            if (this.token === 'dev_bypass') {
-                headers['X-Dev-Bypass'] = 'true';
-            }
-            else {
-                // Production mode: use X-API-Key header
-                headers['X-API-Key'] = this.token;
-            }
-        }
-        const response = await fetch(url, {
-            ...options,
-            headers,
-            signal: AbortSignal.timeout(timeoutMs || this.defaultTimeout),
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`FCP API error (${response.status}): ${error}`);
-        }
-        return response.json();
-    }
-    async listLaunches(filters) {
-        const params = new URLSearchParams();
-        if (filters?.status)
-            params.set('status', filters.status);
-        if (filters?.platform)
-            params.set('platform', filters.platform);
-        if (filters?.upcoming)
-            params.set('upcoming', filters.upcoming.toString());
-        if (filters?.limit)
-            params.set('limit', filters.limit.toString());
-        const query = params.toString();
-        return this.fetch(`/api/launches${query ? `?${query}` : ''}`);
-    }
-    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`);
-    }
-    async addNote(launchId, content) {
-        return this.fetch(`/api/launches/${launchId}/notes`, {
-            method: 'POST',
-            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`);
-    }
-    // Security Headers Methods
-    async scanSecurityHeaders(websiteId) {
-        return this.fetch(`/api/sites/${websiteId}/security-headers`, {
-            method: 'POST',
-            body: JSON.stringify({}),
-        }, 30000);
-    }
-    async getSecurityHeadersResults(websiteId, scanId) {
-        if (scanId) {
-            return this.fetch(`/api/sites/${websiteId}/security-headers/${scanId}`);
-        }
-        return this.fetch(`/api/sites/${websiteId}/security-headers/latest`);
-    }
-    // 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 || {}),
-        });
-    }
-    // Local Setup Guide
-    async getLocalSetupGuide(siteId) {
-        return this.fetch(`/api/sites/${siteId}/local-setup`);
-    }
-    // Shield Domain Management
-    async shieldListDomains(filters) {
-        const params = new URLSearchParams();
-        if (filters?.status)
-            params.append('status', filters.status);
-        if (filters?.account_id)
-            params.append('account_id', String(filters.account_id));
-        const qs = params.toString();
-        return this.fetch(`/api/shield/domains${qs ? `?${qs}` : ''}`);
-    }
-    async shieldAddDomain(input) {
-        return this.fetch('/api/shield/domains', {
-            method: 'POST',
-            body: JSON.stringify(input),
-        });
-    }
-    async shieldGetDomain(domainId) {
-        return this.fetch(`/api/shield/domains/${domainId}`);
-    }
-    async shieldUpdateDomain(domainId, updates) {
-        return this.fetch(`/api/shield/domains/${domainId}`, {
-            method: 'PUT',
-            body: JSON.stringify(updates),
-        });
-    }
-    async shieldRemoveDomain(domainId) {
-        return this.fetch(`/api/shield/domains/${domainId}`, {
-            method: 'DELETE',
-        });
-    }
-    async shieldGetMetrics() {
-        return this.fetch('/api/shield/metrics?include_health=true');
-    }
-    async shieldVerifyDomain(domainId) {
-        return this.fetch(`/api/shield/domains/${domainId}/verify`, {
-            method: 'POST',
-        });
-    }
-    // ============================================================================
-    // Backup Management Methods
-    // ============================================================================
-    async backupListSites() {
-        return this.fetch('/api/backup/sites');
-    }
-    async backupGetConfig() {
-        return this.fetch('/api/backup/config');
-    }
-    async backupListEligible() {
-        return this.fetch('/api/backup/eligible');
-    }
-    async backupEnable(siteId) {
-        return this.fetch('/api/backup/enable', {
-            method: 'POST',
-            body: JSON.stringify({ siteId }),
-        });
-    }
-    async backupTrigger(websiteId, triggerType) {
-        return this.fetch('/api/backup/trigger', {
-            method: 'POST',
-            body: JSON.stringify({ websiteId, triggerType }),
-        });
-    }
-    async backupCheckTrigger(websiteId) {
-        return this.fetch(`/api/backup/trigger?websiteId=${websiteId}`);
-    }
-    async backupListBackups(siteId) {
-        return this.fetch(`/api/backup/list?siteId=${encodeURIComponent(siteId)}`);
-    }
-    async backupGetStatus(options) {
-        const params = new URLSearchParams();
-        if (options.backupId)
-            params.set('backupId', options.backupId);
-        if (options.websiteId)
-            params.set('websiteId', options.websiteId.toString());
-        const query = params.toString();
-        return this.fetch(`/api/backup/status${query ? `?${query}` : ''}`);
-    }
-    async backupDownload(backupId) {
-        return this.fetch(`/api/backup/download?backupId=${encodeURIComponent(backupId)}`);
-    }
-    async backupDownloadPrepared(input) {
-        return this.fetch('/api/backup/download', {
-            method: 'POST',
-            body: JSON.stringify(input),
-        });
-    }
-    async backupSanitizeStatus(jobId) {
-        return this.fetch(`/api/backup/download/status?jobId=${encodeURIComponent(jobId)}`);
-    }
-    async backupListPairings(siteId) {
-        const params = new URLSearchParams();
-        if (siteId)
-            params.set('siteId', siteId.toString());
-        const query = params.toString();
-        return this.fetch(`/api/backup/pairing${query ? `?${query}` : ''}`);
-    }
-    async backupUpdatePairing(siteId, pairingConfig) {
-        return this.fetch('/api/backup/pairing', {
-            method: 'POST',
-            body: JSON.stringify({ siteId, pairingConfig }),
-        });
-    }
-    async backupDeletePairing(siteId) {
-        return this.fetch(`/api/backup/pairing?siteId=${siteId}`, {
-            method: 'DELETE',
-        });
-    }
-    // Kinsta backup methods (separate S3 bucket: kinsta-backups-fru)
-    async kinstaBackupListSites() {
-        return this.fetch('/api/backup/kinsta?action=sites');
-    }
-    async kinstaBackupListBackups(siteId) {
-        return this.fetch(`/api/backup/kinsta?siteId=${siteId}`);
-    }
-    async kinstaBackupDownload(s3Key) {
-        return this.fetch('/api/backup/kinsta', {
-            method: 'POST',
-            body: JSON.stringify({ s3Key }),
-        });
-    }
-    // Clone to Staging
-    async cloneToStagingConfirm(productionSiteId, stagingSiteId) {
-        return this.fetch('/api/clone-staging/confirm', {
-            method: 'POST',
-            body: JSON.stringify({ productionSiteId, stagingSiteId }),
-        });
-    }
-    async cloneToStaging(params) {
-        return this.fetch('/api/clone-staging', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    async getCloneStatus(cloneId) {
-        return this.fetch(`/api/clone-staging/${encodeURIComponent(cloneId)}`);
-    }
-    async listCloneOperations(params) {
-        const query = new URLSearchParams();
-        if (params?.productionSiteId)
-            query.set('productionSiteId', String(params.productionSiteId));
-        if (params?.stagingSiteId)
-            query.set('stagingSiteId', String(params.stagingSiteId));
-        if (params?.limit)
-            query.set('limit', String(params.limit));
-        return this.fetch(`/api/clone-staging?${query.toString()}`);
-    }
-    async getDevEnvironmentInfo(siteId) {
-        return this.fetch(`/api/sites/${siteId}/dev-info`);
-    }
-}
-// Unroo API Client
-// Supports two modes:
-// 1. Direct: Uses UNROO_API_KEY to call Unroo directly (legacy)
-// 2. Proxy: Routes through FCP at /api/mcp/unroo/* using FCP_API_TOKEN (recommended)
-class UnrooClient {
-    baseUrl;
-    apiKey;
-    useProxy;
-    fcpUrl;
-    fcpToken;
-    defaultTimeout = 15000; // 15 seconds
-    constructor(baseUrl, apiKey, useProxy = false, fcpUrl = '', fcpToken = '') {
-        this.baseUrl = baseUrl;
-        this.apiKey = apiKey;
-        this.useProxy = useProxy;
-        this.fcpUrl = fcpUrl;
-        this.fcpToken = fcpToken;
-        if (this.useProxy) {
-            console.error('[UnrooClient] Using FCP proxy mode (unified key)');
-        }
-        else {
-            console.error('[UnrooClient] Using direct Unroo API mode');
-        }
-    }
-    async fetch(path, options = {}, timeoutMs) {
-        let url;
-        const headers = {
-            'Content-Type': 'application/json',
-            ...(options.headers || {}),
-        };
-        if (this.useProxy) {
-            // Route through FCP proxy: /api/external/fcp/X -> /api/mcp/unroo/X
-            const proxyPath = path.replace('/api/external/fcp/', '/api/mcp/unroo/');
-            url = `${this.fcpUrl}${proxyPath}`;
-            // Use FCP API token
-            if (this.fcpToken && this.fcpToken !== 'dev_bypass') {
-                headers['X-API-Key'] = this.fcpToken;
-            }
-            else if (this.fcpToken === 'dev_bypass') {
-                headers['X-Dev-Bypass'] = 'true';
-            }
-            // Pass actual user identity so Unroo attributes actions correctly
-            // (otherwise all actions show as the FCP API key creator)
-            if (FCP_USER_EMAIL) {
-                headers['X-Acting-User-Email'] = FCP_USER_EMAIL;
-            }
-        }
-        else {
-            // Direct Unroo API call
-            url = `${this.baseUrl}${path}`;
-            headers['X-API-Key'] = this.apiKey;
-            // Pass user identity so Unroo attributes actions to the actual user
-            // (otherwise all actions show as the API key owner)
-            if (FCP_USER_EMAIL) {
-                headers['X-FCP-User-Email'] = FCP_USER_EMAIL;
-            }
-        }
-        const response = await fetch(url, {
-            ...options,
-            headers,
-            signal: AbortSignal.timeout(timeoutMs || this.defaultTimeout),
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            const source = this.useProxy ? 'FCP Proxy' : 'Unroo API';
-            throw new Error(`${source} error (${response.status}): ${error}`);
-        }
-        return response.json();
-    }
-    async listProjects() {
-        return this.fetch('/api/external/fcp/projects');
-    }
-    async listTasks(filters) {
-        const params = new URLSearchParams();
-        if (filters.project_key)
-            params.set('project_key', filters.project_key);
-        if (filters.status)
-            params.set('status', filters.status);
-        if (filters.assignee_email)
-            params.set('assignee_email', filters.assignee_email);
-        if (filters.external_source_type)
-            params.set('external_source_type', filters.external_source_type);
-        if (filters.limit)
-            params.set('limit', filters.limit.toString());
-        const query = params.toString();
-        return this.fetch(`/api/external/fcp/tasks${query ? `?${query}` : ''}`);
-    }
-    async createTask(task) {
-        return this.fetch('/api/external/fcp/tasks', {
-            method: 'POST',
-            body: JSON.stringify(task),
-        });
-    }
-    async getTask(taskId) {
-        return this.fetch(`/api/external/fcp/tasks/${encodeURIComponent(taskId)}`);
-    }
-    async updateTask(taskId, updates) {
-        return this.fetch(`/api/external/fcp/tasks/${encodeURIComponent(taskId)}`, {
-            method: 'PUT',
-            body: JSON.stringify(updates),
-        });
-    }
-    async startSession(input) {
-        return this.fetch('/api/external/fcp/sessions', {
-            method: 'POST',
-            body: JSON.stringify({ action: 'start', ...input }),
-        });
-    }
-    async endSession(input) {
-        return this.fetch('/api/external/fcp/sessions', {
-            method: 'POST',
-            body: JSON.stringify({ action: 'end', ...input }),
-        });
-    }
-    async sessionHeartbeat(input) {
-        return this.fetch('/api/external/fcp/sessions', {
-            method: 'POST',
-            body: JSON.stringify({ action: 'heartbeat', ...input }),
-        });
-    }
-    async logActivity(taskId, input) {
-        return this.fetch(`/api/external/fcp/tasks/${encodeURIComponent(taskId)}/activity`, {
-            method: 'POST',
-            body: JSON.stringify({
-                activity_type: input.activity_type,
-                source: input.source || 'claude_code',
-                field_changed: input.field_changed,
-                old_value: input.old_value,
-                new_value: input.new_value,
-                metadata: input.metadata,
-            }),
-        });
-    }
-    // ============================================================================
-    // Comment APIs
-    // ============================================================================
-    async addComment(taskId, input) {
-        return this.fetch(`/api/external/fcp/tasks/${encodeURIComponent(taskId)}/comments`, {
-            method: 'POST',
-            body: JSON.stringify(input),
-        });
-    }
-    async listComments(taskId) {
-        return this.fetch(`/api/external/fcp/tasks/${encodeURIComponent(taskId)}/comments`);
-    }
-    // ============================================================================
-    // Parking Lot / Backlog APIs
-    // ============================================================================
-    async logFutureWork(input) {
-        return this.fetch('/api/external/fcp/future-work', {
-            method: 'POST',
-            body: JSON.stringify(input),
-        });
-    }
-    async getFutureWork(filters) {
-        const params = new URLSearchParams();
-        if (filters.project_key)
-            params.set('project_key', filters.project_key);
-        if (filters.account_id)
-            params.set('account_id', filters.account_id);
-        if (filters.status)
-            params.set('status', filters.status);
-        if (filters.destination)
-            params.set('destination', filters.destination);
-        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/external/fcp/future-work${query ? `?${query}` : ''}`);
-    }
-    async updateFutureWork(id, updates) {
-        return this.fetch(`/api/external/fcp/future-work/${encodeURIComponent(id)}`, {
-            method: 'PUT',
-            body: JSON.stringify(updates),
-        });
-    }
-    async getBacklog(filters) {
-        const params = new URLSearchParams();
-        if (filters.project_key)
-            params.set('project_key', filters.project_key);
-        if (filters.priority)
-            params.set('priority', filters.priority);
-        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/external/fcp/backlog${query ? `?${query}` : ''}`);
-    }
-}
-// ============================================================================
-// Auto Session Tracking
-// ============================================================================
-class SessionTracker {
-    unrooClient;
-    toolCallCount = 0;
-    sessionActive = false;
-    lastHeartbeat = null;
-    activities = [];
-    heartbeatInterval = null;
-    currentTaskId = null;
-    consecutiveHeartbeatFailures = 0;
-    static MAX_HEARTBEAT_FAILURES = 3;
-    constructor(unrooClient) {
-        this.unrooClient = unrooClient;
-    }
-    /**
-     * Track a tool call - auto-starts session if needed
-     */
-    async trackToolCall(toolName, description) {
-        this.toolCallCount++;
-        this.activities.push({
-            timestamp: new Date().toISOString(),
-            tool: toolName,
-            description: description || toolName,
-        });
-        // Keep last 50 activities
-        if (this.activities.length > 50) {
-            this.activities = this.activities.slice(-50);
-        }
-        // Auto-start session on first tool call
-        // Session tracking works with either direct Unroo key OR FCP proxy mode
-        if (!this.sessionActive && UNROO_AVAILABLE) {
-            await this.startSession();
-        }
-        // Send heartbeat every 30 tool calls or every 5 minutes
-        const shouldHeartbeat = this.toolCallCount % 30 === 0 ||
-            (this.lastHeartbeat && Date.now() - this.lastHeartbeat.getTime() > 5 * 60 * 1000);
-        if (shouldHeartbeat && this.sessionActive) {
-            await this.sendHeartbeat();
-        }
-    }
-    /**
-     * Set the current task being worked on
-     */
-    setCurrentTask(taskId) {
-        this.currentTaskId = taskId;
-    }
-    /**
-     * Start a new session
-     */
-    async startSession() {
-        if (!UNROO_AVAILABLE) {
-            return;
-        }
-        try {
-            // Use auto-detected project if available
-            const sessionInput = {
-                task_id: this.currentTaskId || undefined,
-                source: 'claude-code-mcp',
-                machine_id: INSTANCE_ID, // Unique per MCP server process to prevent session collision
-            };
-            // Add auto-detected project info
-            if (currentProject) {
-                sessionInput.project_key = currentProject.project_key;
-                sessionInput.repo_name = `${currentProject.github.owner}/${currentProject.github.repo}`;
-            }
-            await this.unrooClient.startSession(sessionInput);
-            this.sessionActive = true;
-            this.lastHeartbeat = new Date();
-            // Set up periodic heartbeat (every 5 minutes)
-            this.heartbeatInterval = setInterval(() => {
-                this.sendHeartbeat().catch((err) => {
-                    this.consecutiveHeartbeatFailures++;
-                    if (this.consecutiveHeartbeatFailures >= SessionTracker.MAX_HEARTBEAT_FAILURES) {
-                        console.error(`[SessionTracker] Heartbeat failed ${this.consecutiveHeartbeatFailures}x - session tracking may not work`);
-                    }
-                });
-            }, 5 * 60 * 1000);
-            if (currentProject) {
-                console.error(`[SessionTracker] Session started for project: ${currentProject.domain}`);
-            }
-            else {
-                console.error('[SessionTracker] Session started (no project detected)');
-            }
-        }
-        catch (error) {
-            console.error('[SessionTracker] Failed to start session:', error);
-        }
-    }
-    /**
-     * Send a heartbeat to keep session alive
-     */
-    async sendHeartbeat() {
-        if (!this.sessionActive || !UNROO_AVAILABLE) {
-            return;
-        }
-        try {
-            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;
-            this.consecutiveHeartbeatFailures = 0; // Reset on success
-            console.error('[SessionTracker] Heartbeat sent');
-        }
-        catch (error) {
-            this.consecutiveHeartbeatFailures++;
-            console.error(`[SessionTracker] Failed to send heartbeat (attempt ${this.consecutiveHeartbeatFailures}):`, error);
-            throw error; // Re-throw for interval handler
-        }
-    }
-    /**
-     * End the current session and log activity summary to task
-     */
-    async endSession() {
-        if (!this.sessionActive || !UNROO_AVAILABLE) {
-            return;
-        }
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-            this.heartbeatInterval = null;
-        }
-        try {
-            // 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
-            if (this.currentTaskId && result.session) {
-                try {
-                    const session = result.session;
-                    const uniqueTools = [...new Set(this.activities.map(a => a.tool))];
-                    await this.unrooClient.logActivity(this.currentTaskId, {
-                        activity_type: 'claude_code_session',
-                        source: 'claude_code',
-                        metadata: {
-                            session_id: session.id,
-                            duration_seconds: session.duration_minutes ? session.duration_minutes * 60 : 0,
-                            total_tool_calls: session.total_tool_calls || this.toolCallCount,
-                            tools_used: uniqueTools.slice(0, 20), // Limit to 20 tools
-                            started_at: session.started_at,
-                            ended_at: session.ended_at || new Date().toISOString(),
-                        },
-                    });
-                    console.error(`[SessionTracker] Logged session activity to task ${this.currentTaskId}`);
-                }
-                catch (activityError) {
-                    console.error('[SessionTracker] Failed to log activity to task:', activityError);
-                    // Don't throw - session end was successful
-                }
-            }
-        }
-        catch (error) {
-            console.error('[SessionTracker] Failed to end session:', error);
-        }
-    }
-    /**
-     * Get session stats
-     */
-    getStats() {
-        return {
-            active: this.sessionActive,
-            toolCalls: this.toolCallCount,
-            lastHeartbeat: this.lastHeartbeat?.toISOString() || null,
-        };
-    }
-}
-// Session tracker instance created after clients below
-// Create server
-const server = new Server({
-    name: 'fcp-mcp-server',
-    version: MCP_SERVER_VERSION,
-}, {
-    capabilities: {
-        tools: {},
-        resources: {},
-    },
-});
-const client = new FCPClient(FCP_API_URL, FCP_API_TOKEN);
-const unrooClient = new UnrooClient(UNROO_API_URL, UNROO_API_KEY, USE_FCP_UNROO_PROXY, FCP_API_URL, FCP_API_TOKEN);
-const sessionTracker = new SessionTracker(unrooClient);
-// Tool definitions
-const TOOLS = [
-    {
-        name: 'fcp_list_launches',
-        description: 'List launches from FCP with optional filters. Returns upcoming launches, their status, and basic info.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                status: {
-                    type: 'string',
-                    description: 'Filter by status: planning, in_progress, soft_launched, launched, on_hold, cancelled',
-                },
-                platform: {
-                    type: 'string',
-                    description: 'Filter by platform: wordpress, drupal, nextjs, other',
-                },
-                upcoming: {
-                    type: 'number',
-                    description: 'Show launches within next N days',
-                },
-                limit: {
-                    type: 'number',
-                    description: 'Maximum number of launches to return',
-                },
-            },
-        },
-    },
-    {
-        name: 'fcp_get_launch',
-        description: 'Get detailed information about a specific launch including checklist items, legacy access info, and team assignments.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                launch_id: {
-                    type: 'number',
-                    description: 'The ID of the launch to retrieve',
-                },
-            },
-            required: ['launch_id'],
-        },
-    },
-    {
-        name: 'fcp_get_legacy_access',
-        description: 'Get legacy hosting access information for a migration launch. Includes hosting provider, database access, file access, git repo, and DNS details.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                launch_id: {
-                    type: 'number',
-                    description: 'The ID of the launch',
-                },
-            },
-            required: ['launch_id'],
-        },
-    },
-    {
-        name: 'fcp_get_checklist',
-        description: 'Get the launch checklist with item statuses and any Claude-specific instructions for completing tasks.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                launch_id: {
-                    type: 'number',
-                    description: 'The ID of the launch',
-                },
-                category: {
-                    type: 'string',
-                    description: 'Optional: filter by category (infrastructure, security, pre_launch_webops, pre_launch_devops, pre_launch_dev, launch_day_devops, launch_day_seo, post_launch_day1, post_launch_week1, post_launch_day30)',
-                },
-                status: {
-                    type: 'string',
-                    description: 'Optional: filter by status (pending, in_progress, completed, blocked, skipped)',
-                },
-            },
-            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: ['infrastructure', 'security', 'pre_launch_webops', 'pre_launch_devops', 'pre_launch_dev', 'launch_day_devops', 'launch_day_seo', 'post_launch_day1', 'post_launch_week1', 'post_launch_day30'],
-                    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 a checklist item. Can change status, title, description, category, assignment, and other fields.',
-        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',
-                },
-                status: {
-                    type: 'string',
-                    enum: ['pending', 'in_progress', 'completed', 'blocked', 'skipped'],
-                    description: 'New status for the item',
-                },
-                notes: {
-                    type: 'string',
-                    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: ['infrastructure', 'security', 'pre_launch_webops', 'pre_launch_devops', 'pre_launch_dev', 'launch_day_devops', 'launch_day_seo', 'post_launch_day1', 'post_launch_week1', 'post_launch_day30'],
-                    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'],
-        },
-    },
-    {
-        name: 'fcp_add_progress_note',
-        description: 'Add a progress note to a launch. Use this to document what work was done or any issues encountered.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                launch_id: {
-                    type: 'number',
-                    description: 'The ID of the launch',
-                },
-                content: {
-                    type: 'string',
-                    description: 'The note content',
-                },
-            },
-            required: ['launch_id', 'content'],
-        },
-    },
-    {
-        name: 'fcp_get_claude_md',
-        description: 'Generate CLAUDE.md content for a launch. Returns formatted markdown with project context, legacy access info, and checklist.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                launch_id: {
-                    type: 'number',
-                    description: 'The ID of the launch',
-                },
-            },
-            required: ['launch_id'],
-        },
-    },
-    // Launch CRUD Tools
-    {
-        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: {
-                name: {
-                    type: 'string',
-                    description: 'Launch name (required)',
-                },
-                platform: {
-                    type: 'string',
-                    enum: ['wordpress', 'drupal', 'nextjs', 'other'],
-                    description: 'Platform type (required)',
-                },
-                launch_type: {
-                    type: 'string',
-                    enum: ['new_site', 'migration', 'redesign', 'replatform', 'hosting_only', 'maintenance'],
-                    description: 'Type of launch (required)',
-                },
-                target_launch_date: {
-                    type: 'string',
-                    description: 'Target launch date in ISO format (required)',
-                },
-                website_id: {
-                    type: 'number',
-                    description: 'Associated website ID',
-                },
-                account_id: {
-                    type: 'number',
-                    description: 'Associated account/client ID',
-                },
-                description: {
-                    type: 'string',
-                    description: 'Launch description',
-                },
-                soft_launch_date: {
-                    type: 'string',
-                    description: 'Soft launch date in ISO format',
-                },
-                kickoff_date: {
-                    type: 'string',
-                    description: 'Kickoff date in ISO format',
-                },
-                priority: {
-                    type: 'string',
-                    enum: ['low', 'medium', 'high', 'critical'],
-                    description: 'Launch priority (default: medium)',
-                },
-                jira_project_key: {
-                    type: 'string',
-                    description: 'Jira project key',
-                },
-                unroo_project_id: {
-                    type: 'number',
-                    description: 'Unroo project ID to link',
-                },
-                webops_lead_id: {
-                    type: 'number',
-                    description: 'WebOps lead user ID',
-                },
-                devops_lead_id: {
-                    type: 'number',
-                    description: 'DevOps lead user 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: '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)',
-                },
-                slack_channel: {
-                    type: 'string',
-                    description: 'Slack channel for launch countdown notifications, e.g. #channel-name',
-                },
-            },
-            required: ['name', 'platform', 'launch_type', 'target_launch_date'],
-        },
-    },
-    {
-        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: {
-                launch_id: {
-                    type: 'number',
-                    description: 'The ID of the launch to update (required)',
-                },
-                website_id: {
-                    type: 'number',
-                    description: 'Associated website ID (null to unlink)',
-                },
-                account_id: {
-                    type: 'number',
-                    description: 'Associated account/client ID (null to unlink)',
-                },
-                name: {
-                    type: 'string',
-                    description: 'Updated launch name',
-                },
-                description: {
-                    type: 'string',
-                    description: 'Updated description',
-                },
-                status: {
-                    type: 'string',
-                    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: ['low', 'medium', 'high', 'critical'],
-                    description: 'Updated priority',
-                },
-                jira_project_key: {
-                    type: 'string',
-                    description: 'Jira project key (null to clear)',
-                },
-                unroo_project_id: {
-                    type: 'number',
-                    description: 'Unroo project ID (null to unlink)',
-                },
-                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: 'Client contact name (null to clear)',
-                },
-                client_contact_email: {
-                    type: 'string',
-                    description: 'Client contact email (null to clear)',
-                },
-                slack_channel: {
-                    type: 'string',
-                    description: 'Slack channel for launch countdown notifications, e.g. #channel-name (null to clear)',
-                },
-            },
-            required: ['launch_id'],
-        },
-    },
-    {
-        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 (including those not mapped to FCP). Returns project details with organization, company, 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',
-                },
-                github_branch: {
-                    type: 'string',
-                    description: 'Git branch name associated with this task',
-                },
-                github_repo: {
-                    type: 'string',
-                    description: 'GitHub repository (owner/repo format)',
-                },
-            },
-            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',
-                },
-                github_branch: {
-                    type: 'string',
-                    description: 'Git branch name associated with this task',
-                },
-                github_pr_url: {
-                    type: 'string',
-                    description: 'GitHub pull request URL',
-                },
-                github_pr_number: {
-                    type: 'number',
-                    description: 'GitHub pull request number',
-                },
-                github_repo: {
-                    type: 'string',
-                    description: 'GitHub repository (owner/repo format)',
-                },
-            },
-            required: ['task_id'],
-        },
-    },
-    {
-        name: 'unroo_add_comment',
-        description: 'Add a comment to an Unroo task. Use this for progress updates, notes, or tagging people with @mentions. Comments sync to Jira and notify watchers. Use is_internal=true for team-only notes.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                task_id: {
-                    type: 'string',
-                    description: 'Task ID or Jira key (e.g., task_abc123 or FLYFRU-189)',
-                },
-                comment_text: {
-                    type: 'string',
-                    description: 'The comment content. Use @email to mention people (e.g., @tony.diaz@fruition.net)',
-                },
-                is_internal: {
-                    type: 'boolean',
-                    description: 'If true, comment is team-only (not synced to Jira, not visible to customers). Default: false',
-                },
-                mentions: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Email addresses of people to mention/notify (e.g., ["tony.diaz@fruition.net"])',
-                },
-            },
-            required: ['task_id', 'comment_text'],
-        },
-    },
-    {
-        name: 'unroo_list_comments',
-        description: 'List comments on an Unroo task. Returns all comments in reverse chronological order.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                task_id: {
-                    type: 'string',
-                    description: 'Task ID or Jira key (e.g., task_abc123 or FLYFRU-189)',
-                },
-            },
-            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',
-            properties: {
-                status: {
-                    type: 'string',
-                    description: 'Filter by status (comma-separated for multiple)',
-                },
-                limit: {
-                    type: 'number',
-                    description: 'Maximum number of tasks to return',
-                },
-            },
-        },
-    },
-    {
-        name: 'unroo_start_session',
-        description: 'Start a work session for tracking time and activity. Call this when beginning work on a task.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                task_id: {
-                    type: 'string',
-                    description: 'The task you are working on',
-                },
-                task_jira_key: {
-                    type: 'string',
-                    description: 'JIRA issue key if applicable',
-                },
-                project_key: {
-                    type: 'string',
-                    description: 'Project being worked on',
-                },
-                repo_name: {
-                    type: 'string',
-                    description: 'Repository name if working on code',
-                },
-            },
-        },
-    },
-    {
-        name: 'unroo_end_session',
-        description: 'End the current work session and log time. Call this when finishing work.',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'unroo_create_follow_up',
-        description: 'Create a follow-up task linked to a parent task. Use for discovered issues, tech debt, or next steps.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                parent_task_id: {
-                    type: 'string',
-                    description: 'The parent task this follows up on (required)',
-                },
-                title: {
-                    type: 'string',
-                    description: 'Follow-up task title (required)',
-                },
-                description: {
-                    type: 'string',
-                    description: 'Description of the follow-up work',
-                },
-                priority: {
-                    type: 'string',
-                    enum: ['urgent', 'high', 'medium', 'low'],
-                    description: 'Priority (default: same as parent or medium)',
-                },
-            },
-            required: ['parent_task_id', 'title'],
-        },
-    },
-    // Parking Lot / Backlog Tools
-    {
-        name: 'unroo_log_future_work',
-        description: 'Log future work items to parking lot or backlog. Use when you discover work that should be done later - bugs, tech debt, features, documentation needs, etc.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                title: {
-                    type: 'string',
-                    description: 'Title of the future work item (required)',
-                },
-                project_key: {
-                    type: 'string',
-                    description: 'JIRA project key or FCP-SITE-{id} (required)',
-                },
-                description: {
-                    type: 'string',
-                    description: 'Detailed description of the work needed',
-                },
-                priority: {
-                    type: 'string',
-                    enum: ['Urgent', 'High', 'Medium', 'Low'],
-                    description: 'Priority level (default: Medium)',
-                },
-                task_type: {
-                    type: 'string',
-                    enum: ['bug', 'tech_debt', 'feature', 'documentation', 'security', 'performance'],
-                    description: 'Type of work item',
-                },
-                estimated_hours: {
-                    type: 'number',
-                    description: 'Estimated hours to complete',
-                },
-                launch_id: {
-                    type: 'number',
-                    description: 'FCP launch ID if related to a launch',
-                },
-                checklist_item_id: {
-                    type: 'number',
-                    description: 'FCP checklist item ID if discovered during checklist work',
-                },
-                notes: {
-                    type: 'string',
-                    description: 'Additional notes or context',
-                },
-                destination: {
-                    type: 'string',
-                    enum: ['parking_lot', 'backlog'],
-                    description: 'Where to put the item: parking_lot (needs review) or backlog (ready for sprint). Default: parking_lot',
-                },
-            },
-            required: ['title', 'project_key'],
-        },
-    },
-    {
-        name: 'unroo_get_parking_lot',
-        description: 'Get items from the parking lot - discovered work that needs review before being added to backlog.',
-        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: pending, approved, rejected, converted (default: pending)',
-                },
-                limit: {
-                    type: 'number',
-                    description: 'Maximum number of items to return (default: 100)',
-                },
-            },
-        },
-    },
-    {
-        name: 'unroo_get_backlog',
-        description: 'Get backlog items - tasks ready to be scheduled into sprints.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                project_key: {
-                    type: 'string',
-                    description: 'Filter by JIRA project key or FCP-SITE-{id}',
-                },
-                priority: {
-                    type: 'string',
-                    enum: ['Urgent', 'High', 'Medium', 'Low'],
-                    description: 'Filter by priority',
-                },
-                limit: {
-                    type: 'number',
-                    description: 'Maximum number of items to return (default: 100)',
-                },
-            },
-        },
-    },
-    {
-        name: 'unroo_convert_to_backlog',
-        description: 'Convert a parking lot item to backlog. Use after reviewing a discovered item and deciding it should be done.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                id: {
-                    type: 'string',
-                    description: 'The ID of the parking lot item to convert (required)',
-                },
-                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'],
-        },
-    },
-    // Security Headers Tools
-    {
-        name: 'fcp_scan_security_headers',
-        description: 'Scan a website for HTTP security headers (CSP, HSTS, X-Frame-Options, etc.). Returns grade (A-F), score (0-100), and per-header analysis with issues and recommendations.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                website_id: {
-                    type: 'number',
-                    description: 'The website ID to scan (required)',
-                },
-            },
-            required: ['website_id'],
-        },
-    },
-    {
-        name: 'fcp_get_security_headers_results',
-        description: 'Get security headers scan results for a website. Returns the latest scan grade, score, and per-header findings with issues and recommendations.',
-        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, defaults to latest)',
-                },
-            },
-            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_get_local_setup_guide',
-        description: 'Generate a local development setup guide for a website. Returns CMS-specific instructions for cloning, DDEV configuration, .env template, database import, and verification steps. Works for Bedrock WordPress, standard WordPress, and Drupal sites.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                website_id: {
-                    type: 'number',
-                    description: 'The website ID to generate setup guide for',
-                },
-            },
-            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',
-                },
-                backup_excluded: {
-                    type: 'boolean',
-                    description: 'Exclude site from backup eligibility (e.g. ephemeral sites, non-K8s hosting)',
-                },
-                backup_exclusion_reason: {
-                    type: 'string',
-                    description: 'Reason for backup exclusion (e.g. "Ephemeral captive portal site", "External hosting - not on K8s")',
-                },
-                multisite_root_id: {
-                    type: 'number',
-                    description: 'Root site ID for WordPress multisite networks. Set to link as a subsite, null to unlink.',
-                },
-                uptime_monitor_id: {
-                    type: 'number',
-                    description: 'UptimeRobot monitor ID for this site. Used by scheduler to pause/resume monitors on scale events.',
-                },
-                pvc_name: {
-                    type: 'string',
-                    description: 'PVC name in the K8s namespace (e.g., "public-files-nfs"). Update after RWO→RWX migration so the snapshot scheduler targets the new volume.',
-                },
-                pvc_storage_class: {
-                    type: 'string',
-                    description: 'PVC storage class (e.g., "openebs-kernel-nfs", "do-block-storage-xfs-retain"). Update after a storage migration.',
-                },
-                pvc_size: {
-                    type: 'string',
-                    description: 'PVC size with unit (e.g., "10Gi"). Update after expanding the volume.',
-                },
-                pvc_mount_path: {
-                    type: 'string',
-                    description: 'Where the PVC is mounted inside the container (e.g., "/var/www/html/wp-content/uploads").',
-                },
-                pvc_sidecar_detected: {
-                    type: 'boolean',
-                    description: 'Whether a backup sidecar was auto-detected on this PVC.',
-                },
-            },
-            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',
-                    description: 'Reason for retiring the site',
-                },
-                forward_url: {
-                    type: 'string',
-                    description: 'URL to forward the domain to after retirement',
-                },
-            },
-            required: ['website_id'],
-        },
-    },
-    // Fruition Shield - Shared WAF Gateway
-    {
-        name: 'fcp_shield_list_domains',
-        description: 'List all domains protected by Fruition Shield WAF. Filter by status (pending_dns, pending_cert, active, suspended) or account_id.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                status: {
-                    type: 'string',
-                    description: 'Filter by status: pending_dns, pending_cert, cert_validating, active, suspended, removed',
-                },
-                account_id: {
-                    type: 'number',
-                    description: 'Filter by account/client ID',
-                },
-            },
-        },
-    },
-    {
-        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.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                domain: {
-                    type: 'string',
-                    description: 'Domain to protect (e.g., www.butterflies.org)',
-                },
-                origin_host: {
-                    type: 'string',
-                    description: 'Origin server IP or hostname (e.g., 146.190.2.169 for K8s prod)',
-                },
-                origin_port: {
-                    type: 'number',
-                    description: 'Origin port (default: 443)',
-                },
-                origin_protocol: {
-                    type: 'string',
-                    description: 'Origin protocol: http or https (default: https)',
-                },
-                website_id: {
-                    type: 'number',
-                    description: 'Link to existing FCP website ID',
-                },
-                account_id: {
-                    type: 'number',
-                    description: 'Associated account/client ID',
-                },
-                cache_profile: {
-                    type: 'string',
-                    description: 'Cache profile: standard, aggressive, minimal, none (default: standard)',
-                },
-                notes: {
-                    type: 'string',
-                    description: 'Notes about this domain',
-                },
-            },
-            required: ['domain', 'origin_host'],
-        },
-    },
-    {
-        name: 'fcp_shield_get_domain',
-        description: 'Get Shield domain details including onboarding status, DNS records needed, and WAF configuration.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                domain_id: {
-                    type: 'number',
-                    description: 'The Shield domain ID',
-                },
-            },
-            required: ['domain_id'],
-        },
-    },
-    {
-        name: 'fcp_shield_update_domain',
-        description: 'Update Shield domain configuration (origin, cache profile, WAF rules, geo-blocking, rate limiting).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                domain_id: {
-                    type: 'number',
-                    description: 'The Shield domain ID',
-                },
-                origin_host: { type: 'string', description: 'Updated origin host' },
-                origin_port: { type: 'number', description: 'Updated origin port' },
-                cache_profile: { type: 'string', description: 'Cache profile: standard, aggressive, minimal, none' },
-                waf_profile: { type: 'string', description: 'WAF profile: standard, premium, custom' },
-                geo_block_countries: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Country codes to block (e.g., ["CN","RU","KP","IR","BY"])',
-                },
-                rate_limit_tier: { type: 'string', description: 'Rate limit: standard, strict, relaxed' },
-                bot_control_enabled: { type: 'boolean', description: 'Enable AWS Bot Control (+$10/mo)' },
-                cache_no_cache_paths: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Path patterns to never cache (e.g., ["/api/*", "/wp-admin/*", "/cart/*"])',
-                },
-                enabled: { type: 'boolean', description: 'Enable/disable domain' },
-                notes: { type: 'string', description: 'Updated notes' },
-            },
-            required: ['domain_id'],
-        },
-    },
-    {
-        name: 'fcp_shield_remove_domain',
-        description: 'Remove a domain from Fruition Shield protection. Removes from CloudFront, DynamoDB, and deletes ACM certificate.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                domain_id: {
-                    type: 'number',
-                    description: 'The Shield domain ID to remove',
-                },
-            },
-            required: ['domain_id'],
-        },
-    },
-    {
-        name: 'fcp_shield_get_metrics',
-        description: 'Get aggregate Fruition Shield WAF metrics: total domains, requests, blocks, block rate, and infrastructure health.',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    // ============================================================================
-    // Backup Management Tools
-    // ============================================================================
-    {
-        name: 'fcp_backup_list_sites',
-        description: 'List websites with backups enabled. Returns site details including domain, cluster, namespace, and backup schedule.',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'fcp_backup_get_config',
-        description: 'Get S3 backup configuration. Admin only. Returns bucket, region, endpoint info (credentials are excluded).',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'fcp_backup_list_eligible',
-        description: 'List sites eligible for backup but not yet enabled. Returns sites grouped by environment (production, staging, development).',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'fcp_backup_enable',
-        description: 'Enable backup for a site and trigger the first backup automatically.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                siteId: {
-                    type: 'number',
-                    description: 'The website ID to enable backups for',
-                },
-            },
-            required: ['siteId'],
-        },
-    },
-    {
-        name: 'fcp_backup_trigger',
-        description: 'Manually trigger a backup for a website. Admin only. Creates a queued backup job.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                websiteId: {
-                    type: 'number',
-                    description: 'The website ID to backup',
-                },
-                triggerType: {
-                    type: 'string',
-                    description: 'Trigger type (default: manual)',
-                },
-            },
-            required: ['websiteId'],
-        },
-    },
-    {
-        name: 'fcp_backup_check_trigger',
-        description: 'Check if a backup can be triggered for a website. Returns hosting status, K8s config, enabled status, and queue length.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                websiteId: {
-                    type: 'number',
-                    description: 'The website ID to check',
-                },
-            },
-            required: ['websiteId'],
-        },
-    },
-    {
-        name: 'fcp_backup_list_backups',
-        description: 'List backup history for a site. Returns backup jobs with status, size, duration, and location.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                siteId: {
-                    type: 'number',
-                    description: 'The website ID (will be formatted as site-{id} for the API)',
-                },
-            },
-            required: ['siteId'],
-        },
-    },
-    {
-        name: 'fcp_backup_get_status',
-        description: 'Get backup job status. Provide backupId for a specific job, or websiteId for backup history of a site.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                backupId: {
-                    type: 'string',
-                    description: 'Specific backup job ID to get status for',
-                },
-                websiteId: {
-                    type: 'number',
-                    description: 'Website ID to get backup history for',
-                },
-            },
-        },
-    },
-    {
-        name: 'fcp_backup_download',
-        description: 'Generate a presigned S3 download URL for a completed backup. URL expires in 1 hour.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                backupId: {
-                    type: 'string',
-                    description: 'The backup ID to download',
-                },
-            },
-            required: ['backupId'],
-        },
-    },
-    {
-        name: 'fcp_backup_download_prepared',
-        description: 'Prepare a backup download with optional sanitization. For production backups, sanitization is the default — this returns a jobId to poll via fcp_backup_sanitize_status. For non-production backups, returns a presigned download URL directly.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                siteId: {
-                    type: 'string',
-                    description: 'The site ID (e.g., site-123)',
-                },
-                backupId: {
-                    type: 'string',
-                    description: 'The backup ID to download',
-                },
-                downloadType: {
-                    type: 'string',
-                    description: 'Type of download (e.g., database, files)',
-                },
-                format: {
-                    type: 'string',
-                    description: 'Download format (optional)',
-                },
-                sanitize: {
-                    type: 'boolean',
-                    description: 'Whether to sanitize production data. Defaults to true for production environments. Set to false to skip sanitization (non-production only).',
-                },
-            },
-            required: ['siteId', 'backupId', 'downloadType'],
-        },
-    },
-    {
-        name: 'fcp_backup_sanitize_status',
-        description: 'Check the status of a database sanitization job. Poll this after fcp_backup_download_prepared returns a jobId. When status is "completed", the response includes a presigned downloadUrl for the sanitized backup.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                jobId: {
-                    type: 'string',
-                    description: 'The sanitization job ID returned by fcp_backup_download_prepared',
-                },
-            },
-            required: ['jobId'],
-        },
-    },
-    {
-        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.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                siteId: {
-                    type: 'number',
-                    description: 'Optional: specific site ID to get pairing for',
-                },
-            },
-        },
-    },
-    {
-        name: 'fcp_backup_update_pairing',
-        description: 'Create or update a site pairing configuration. Defines staging/development relationships for a site.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                siteId: {
-                    type: 'number',
-                    description: 'The site ID to update pairing for',
-                },
-                pairingConfig: {
-                    type: 'object',
-                    description: 'Pairing configuration with staging (string|null) and development (array) site references',
-                    properties: {
-                        staging: { type: 'string', description: 'Staging site domain or null' },
-                        development: {
-                            type: 'array',
-                            items: { type: 'string' },
-                            description: 'Development site domains',
-                        },
-                    },
-                },
-            },
-            required: ['siteId', 'pairingConfig'],
-        },
-    },
-    {
-        name: 'fcp_backup_delete_pairing',
-        description: 'Remove a site pairing configuration. Clears the pairing config for a site.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                siteId: {
-                    type: 'number',
-                    description: 'The site ID to remove pairing for',
-                },
-            },
-            required: ['siteId'],
-        },
-    },
-    // Kinsta backup tools (separate S3 bucket with weekly full-site zip backups)
-    {
-        name: 'fcp_kinsta_backup_list_sites',
-        description: 'List all Kinsta-hosted sites that have S3 backup mappings configured. Returns site IDs, domains, and S3 prefixes.',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'fcp_kinsta_backup_list',
-        description: 'List available Kinsta backups for a specific site. Returns backup files with sizes, dates, and S3 keys for downloading.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                siteId: {
-                    type: 'string',
-                    description: 'The site ID (e.g., site-215 for bnpassociates.com)',
-                },
-            },
-            required: ['siteId'],
-        },
-    },
-    {
-        name: 'fcp_kinsta_backup_download',
-        description: 'Generate a presigned S3 download URL for a Kinsta backup zip file. URL expires in 1 hour.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                s3Key: {
-                    type: 'string',
-                    description: 'The S3 key from fcp_kinsta_backup_list (e.g., bnpassociates/filename.zip)',
-                },
-            },
-            required: ['s3Key'],
-        },
-    },
-    // Clone to Staging (unified prod → staging with files + database + search/replace)
-    {
-        name: 'fcp_clone_to_staging',
-        description: 'Clone production to staging environment. Combines file sync (from DO snapshots) and database sync (from S3 backups pulled from RO replicas) into a single tracked operation. Requires a confirmation token from fcp_clone_confirm first, unless triggerType is "mcp".',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                productionSiteId: {
-                    type: 'number',
-                    description: 'Production site ID',
-                },
-                stagingSiteId: {
-                    type: 'number',
-                    description: 'Staging site ID to clone into',
-                },
-                includeFiles: {
-                    type: 'boolean',
-                    description: 'Whether to sync files from production snapshot (default: true)',
-                },
-                includeDatabase: {
-                    type: 'boolean',
-                    description: 'Whether to sync database from latest backup (default: true)',
-                },
-                runSearchReplace: {
-                    type: 'boolean',
-                    description: 'Whether to run domain search/replace after DB sync (default: true)',
-                },
-                backupId: {
-                    type: 'string',
-                    description: 'Specific backup ID to restore from (optional, defaults to latest)',
-                },
-            },
-            required: ['productionSiteId', 'stagingSiteId'],
-        },
-    },
-    {
-        name: 'fcp_clone_confirm',
-        description: 'Generate a safety confirmation token for a clone-to-staging operation. Returns token (5-min TTL) plus site info and latest backup age.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                productionSiteId: {
-                    type: 'number',
-                    description: 'Production site ID',
-                },
-                stagingSiteId: {
-                    type: 'number',
-                    description: 'Staging site ID',
-                },
-            },
-            required: ['productionSiteId', 'stagingSiteId'],
-        },
-    },
-    {
-        name: 'fcp_clone_status',
-        description: 'Get the status of a clone-to-staging operation. Returns progress, step statuses (files, database, search/replace), and errors.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                cloneId: {
-                    type: 'string',
-                    description: 'Clone operation ID (e.g., clone_abc12345_lxyz)',
-                },
-            },
-            required: ['cloneId'],
-        },
-    },
-    {
-        name: 'fcp_clone_list',
-        description: 'List recent clone-to-staging operations for a site. Shows history of all clone operations with status.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                productionSiteId: {
-                    type: 'number',
-                    description: 'Filter by production site ID',
-                },
-                stagingSiteId: {
-                    type: 'number',
-                    description: 'Filter by staging site ID',
-                },
-                limit: {
-                    type: 'number',
-                    description: 'Max results (default: 20)',
-                },
-            },
-        },
-    },
-    {
-        name: 'fcp_get_dev_environment_info',
-        description: 'Get developer environment info for a site. Shows what capabilities are available (clone to staging, download database, file sync, local setup), current state (latest backup age, clone status), staging sites, and quick action URLs. Use this to help developers understand what they can do with a site.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                siteId: {
-                    type: 'number',
-                    description: 'The production site ID to get dev environment info for',
-                },
-            },
-            required: ['siteId'],
-        },
-    },
-];
-// Register tool handlers
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return { tools: TOOLS };
-});
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    // Track tool call for session management
-    await sessionTracker.trackToolCall(name, `Called ${name}`);
-    try {
-        // Role-based access control: gate destructive / sensitive tools by RBAC role
-        // resolved from /api/auth/me. Throws on insufficient privilege; the catch
-        // block below converts the error into the standard MCP error response.
-        await enforceToolPermission(name);
-        switch (name) {
-            case 'fcp_list_launches': {
-                const result = await client.listLaunches(args);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'fcp_get_launch': {
-                const { launch_id } = args;
-                const result = await client.getLaunch(launch_id);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'fcp_get_legacy_access': {
-                const { launch_id } = args;
-                const result = await client.getLaunch(launch_id);
-                const legacyAccess = {
-                    launch_id,
-                    launch_name: result.launch.name,
-                    launch_type: result.launch.launch_type,
-                    legacy_domain: result.launch.legacy_domain,
-                    legacy_access_info: result.launch.legacy_access_info || {},
-                };
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(legacyAccess, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'fcp_get_checklist': {
-                const { launch_id, category, status } = args;
-                const result = await client.getLaunch(launch_id);
-                let checklist = result.checklist || [];
-                if (category) {
-                    checklist = checklist.filter((item) => item.category === category);
-                }
-                if (status) {
-                    checklist = checklist.filter((item) => item.status === status);
-                }
-                // Format for readability
-                const formatted = checklist.map((item) => ({
-                    id: item.id,
-                    title: item.title,
-                    status: item.status,
-                    category: item.category,
-                    is_blocker: item.is_blocker,
-                    description: item.description,
-                    claude_instructions: item.claude_instructions,
-                }));
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                launch_id,
-                                launch_name: result.launch.name,
-                                total_items: formatted.length,
-                                completed: formatted.filter((i) => i.status === 'completed').length,
-                                blockers: formatted.filter((i) => i.is_blocker && i.status !== 'completed').length,
-                                items: formatted,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'fcp_add_checklist_item': {
-                const { launch_id, title, category, ...rest } = args;
-                const result = await client.createChecklistItem(launch_id, {
-                    title,
-                    category,
-                    ...rest,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                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);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: 'Progress note added',
-                                note: result,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'fcp_get_claude_md': {
-                const { launch_id } = args;
-                const result = await client.getClaudeMd(launch_id);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: result.content,
-                        },
-                    ],
-                };
-            }
-            // 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),
-                        },
-                    ],
-                };
-            }
-            // Security Headers Handlers
-            case 'fcp_scan_security_headers': {
-                const { website_id } = args;
-                const result = await client.scanSecurityHeaders(website_id);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'fcp_get_security_headers_results': {
-                const { website_id, scan_id } = args;
-                const result = await client.getSecurityHeadersResults(website_id, scan_id);
-                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_get_local_setup_guide': {
-                const { website_id } = args;
-                const result = await client.getLocalSetupGuide(website_id);
-                // Return the guide as readable text, with structured data as JSON
-                const guide = result.guide || '';
-                const siteInfo = result.site || {};
-                const ddevInfo = result.ddev || {};
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: guide + '\n\n---\n\n**Structured Data:**\n```json\n' + JSON.stringify({ site: siteInfo, ddev: ddevInfo }, null, 2) + '\n```',
-                        },
-                    ],
-                };
-            }
-            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();
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'unroo_list_tasks': {
-                const filters = args;
-                const result = await unrooClient.listTasks(filters);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                total: result.summary?.total || result.tasks.length,
-                                by_status: result.summary?.by_status || {},
-                                tasks: result.tasks,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'unroo_create_task': {
-                const taskInput = args;
-                const result = await unrooClient.createTask({
-                    ...taskInput,
-                    external_source_type: 'claude_code',
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Task created: ${result.task.id}`,
-                                task: result.task,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            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);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Task ${task_id} updated`,
-                                task: result.task,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'unroo_add_comment': {
-                const { task_id, comment_text, is_internal, mentions } = args;
-                const commentResult = await unrooClient.addComment(task_id, {
-                    comment_text,
-                    is_internal,
-                    mentions,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Comment added to task ${task_id}${is_internal ? ' (internal)' : ''}`,
-                                comment: commentResult.comment,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'unroo_list_comments': {
-                const { task_id } = args;
-                const commentsResult = await unrooClient.listComments(task_id);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                total: commentsResult.total,
-                                comments: commentsResult.comments,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'unroo_get_my_tasks': {
-                const { status, limit } = args;
-                // Note: The API key determines the user, tasks are filtered server-side
-                const result = await unrooClient.listTasks({
-                    status,
-                    limit: limit || 50,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                total: result.tasks.length,
-                                tasks: result.tasks,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'unroo_start_session': {
-                const sessionInput = args;
-                // Update session tracker with task context
-                if (sessionInput.task_id) {
-                    sessionTracker.setCurrentTask(sessionInput.task_id);
-                }
-                const result = await unrooClient.startSession({
-                    ...sessionInput,
-                    source: 'claude-code-mcp',
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: 'Work session started',
-                                session: result.session,
-                                auto_tracking: sessionTracker.getStats(),
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'unroo_end_session': {
-                // End the auto-tracked session (clears heartbeat interval, logs activity)
-                await sessionTracker.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: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Session ended. Duration: ${result.session.duration_minutes} minutes`,
-                                session: result.session,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'unroo_create_follow_up': {
-                const { parent_task_id, title, description, priority } = args;
-                // Get parent task to inherit project_key
-                const parentResult = await unrooClient.getTask(parent_task_id);
-                if (!parentResult.task) {
-                    throw new Error(`Parent task not found: ${parent_task_id}`);
-                }
-                const parentTask = parentResult.task;
-                const result = await unrooClient.createTask({
-                    title: `[Follow-up] ${title}`,
-                    description: description || `Follow-up from task: ${parentTask.title}`,
-                    project_key: parentTask.project_key || 'FCP',
-                    priority: priority || parentTask.priority || 'medium',
-                    parent_issue_id: parent_task_id,
-                    external_source_type: 'claude_code_followup',
-                    labels: ['follow-up'],
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Follow-up task created: ${result.task.id}`,
-                                parent_task_id,
-                                task: result.task,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            // Parking Lot / Backlog Handlers
-            case 'unroo_log_future_work': {
-                const input = args;
-                const result = await unrooClient.logFutureWork({
-                    ...input,
-                    discovered_by: 'claude-code-mcp',
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: result.message,
-                                id: result.id,
-                                destination: result.destination,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'unroo_get_parking_lot': {
-                const { project_key, status, limit } = args;
-                const result = await unrooClient.getFutureWork({
-                    project_key,
-                    status: status || 'pending',
-                    destination: 'parking_lot',
-                    limit: limit || 100,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                total: result.items.length,
-                                stats: result.stats,
-                                items: result.items,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'unroo_get_backlog': {
-                const { project_key, priority, limit } = args;
-                const result = await unrooClient.getBacklog({
-                    project_key,
-                    priority,
-                    limit: limit || 100,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                total: result.total,
-                                items: result.items,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'unroo_convert_to_backlog': {
-                const { id, priority, notes } = args;
-                const result = await unrooClient.updateFutureWork(id, {
-                    convert_to_backlog: true,
-                    priority,
-                    notes,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Parking lot item ${id} converted to backlog`,
-                                item: result.item,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            // 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),
-                        },
-                    ],
-                };
-            }
-            // Fruition Shield Handlers
-            case 'fcp_shield_list_domains': {
-                const { status, account_id } = args;
-                const result = await client.shieldListDomains({ status, account_id });
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_shield_add_domain': {
-                const { domain, origin_host, origin_port, origin_protocol, 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,
-                });
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_shield_get_domain': {
-                const { domain_id } = args;
-                const result = await client.shieldGetDomain(domain_id);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_shield_update_domain': {
-                const { domain_id, ...updates } = args;
-                const result = await client.shieldUpdateDomain(domain_id, updates);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_shield_remove_domain': {
-                const { domain_id } = args;
-                const result = await client.shieldRemoveDomain(domain_id);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_shield_get_metrics': {
-                const result = await client.shieldGetMetrics();
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            // ============================================================================
-            // Backup Management Handlers
-            // ============================================================================
-            case 'fcp_backup_list_sites': {
-                const result = await client.backupListSites();
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_backup_get_config': {
-                const result = await client.backupGetConfig();
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_backup_list_eligible': {
-                const result = await client.backupListEligible();
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_backup_enable': {
-                const { siteId } = args;
-                const result = await client.backupEnable(siteId);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_backup_trigger': {
-                const { websiteId, triggerType } = args;
-                const result = await client.backupTrigger(websiteId, triggerType);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_backup_check_trigger': {
-                const { websiteId } = args;
-                const result = await client.backupCheckTrigger(websiteId);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_backup_list_backups': {
-                const { siteId } = args;
-                const result = await client.backupListBackups(`site-${siteId}`);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_backup_get_status': {
-                const { backupId, websiteId } = args;
-                const result = await client.backupGetStatus({ backupId, websiteId });
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_backup_download': {
-                const { backupId } = args;
-                const result = await client.backupDownload(backupId);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_backup_download_prepared': {
-                const { siteId, backupId, downloadType, format, sanitize } = args;
-                const result = await client.backupDownloadPrepared({ siteId, backupId, downloadType, format, sanitize });
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_backup_sanitize_status': {
-                const { jobId } = args;
-                const result = await client.backupSanitizeStatus(jobId);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_backup_list_pairings': {
-                const { siteId } = args;
-                const result = await client.backupListPairings(siteId);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_backup_update_pairing': {
-                const { siteId, pairingConfig } = args;
-                const result = await client.backupUpdatePairing(siteId, pairingConfig);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_backup_delete_pairing': {
-                const { siteId } = args;
-                const result = await client.backupDeletePairing(siteId);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            // Kinsta backup tools
-            case 'fcp_kinsta_backup_list_sites': {
-                const result = await client.kinstaBackupListSites();
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_kinsta_backup_list': {
-                const { siteId } = args;
-                const result = await client.kinstaBackupListBackups(siteId);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_kinsta_backup_download': {
-                const { s3Key } = args;
-                const result = await client.kinstaBackupDownload(s3Key);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            // Clone to Staging tools
-            case 'fcp_clone_to_staging': {
-                const { productionSiteId, stagingSiteId, includeFiles, includeDatabase, runSearchReplace, backupId } = args;
-                // For MCP callers, auto-generate confirmation token (bypasses type-to-confirm UI)
-                const confirmResult = await client.cloneToStagingConfirm(productionSiteId, stagingSiteId);
-                const token = confirmResult.token;
-                const result = await client.cloneToStaging({
-                    productionSiteId,
-                    stagingSiteId,
-                    includeFiles: includeFiles !== false,
-                    includeDatabase: includeDatabase !== false,
-                    runSearchReplace: runSearchReplace !== false,
-                    confirmationToken: token,
-                    backupId,
-                });
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_clone_confirm': {
-                const { productionSiteId, stagingSiteId } = args;
-                const result = await client.cloneToStagingConfirm(productionSiteId, stagingSiteId);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_clone_status': {
-                const { cloneId } = args;
-                const result = await client.getCloneStatus(cloneId);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_clone_list': {
-                const { productionSiteId, stagingSiteId, limit } = args;
-                const result = await client.listCloneOperations({ productionSiteId, stagingSiteId, limit });
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case 'fcp_get_dev_environment_info': {
-                const { siteId } = args;
-                const result = await client.getDevEnvironmentInfo(siteId);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            default:
-                throw new Error(`Unknown tool: ${name}`);
-        }
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({ error: message }, null, 2),
-                },
-            ],
-            isError: true,
-        };
-    }
-});
-// Resource handlers
-server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    return {
-        resources: [
-            {
-                uri: 'fcp://launches',
-                name: 'FCP Launches',
-                description: 'List of all launches in FCP',
-                mimeType: 'application/json',
-            },
-        ],
-    };
-});
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const { uri } = request.params;
-    if (uri === 'fcp://launches') {
-        const result = await client.listLaunches({ limit: 50 });
-        return {
-            contents: [
-                {
-                    uri,
-                    mimeType: 'application/json',
-                    text: JSON.stringify(result, null, 2),
-                },
-            ],
-        };
-    }
-    // Handle fcp://launches/{id}
-    const launchMatch = uri.match(/^fcp:\/\/launches\/(\d+)$/);
-    if (launchMatch) {
-        const launchId = parseInt(launchMatch[1], 10);
-        const result = await client.getLaunch(launchId);
-        return {
-            contents: [
-                {
-                    uri,
-                    mimeType: 'application/json',
-                    text: JSON.stringify(result, null, 2),
-                },
-            ],
-        };
-    }
-    throw new Error(`Unknown resource: ${uri}`);
-});
-// Version comparison helper
-function compareVersions(v1, v2) {
-    const parts1 = v1.split('.').map(Number);
-    const parts2 = v2.split('.').map(Number);
-    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
-        const p1 = parts1[i] || 0;
-        const p2 = parts2[i] || 0;
-        if (p1 > p2)
-            return 1;
-        if (p1 < p2)
-            return -1;
-    }
-    return 0;
-}
-// Check for updates on startup
-async function checkForUpdates() {
-    if (!FCP_API_URL)
-        return;
-    try {
-        const response = await fetch(`${FCP_API_URL}/api/mcp/version`, {
-            headers: FCP_API_TOKEN ? { 'X-API-Key': FCP_API_TOKEN } : {},
-        });
-        if (!response.ok) {
-            // Silently ignore - version endpoint may not exist on older FCP versions
-            return;
-        }
-        const data = await response.json();
-        const latestVersion = data.version;
-        const minVersion = data.minVersion;
-        if (compareVersions(MCP_SERVER_VERSION, minVersion) < 0) {
-            console.error(`\n⚠️  [MCP Server] INCOMPATIBLE VERSION`);
-            console.error(`   Your version: ${MCP_SERVER_VERSION}`);
-            console.error(`   Minimum required: ${minVersion}`);
-            console.error(`   Please update: ${data.updateUrl}\n`);
-        }
-        else if (compareVersions(MCP_SERVER_VERSION, latestVersion) < 0) {
-            console.error(`\n📦 [MCP Server] Update available: ${MCP_SERVER_VERSION} → ${latestVersion}`);
-            console.error(`   Update: ${data.updateUrl}\n`);
-        }
-        else {
-            console.error(`[MCP Server] Version ${MCP_SERVER_VERSION} (up to date)`);
-        }
-    }
-    catch {
-        // Silently ignore network errors - don't block startup
-    }
-}
-// Start server
-async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error(`FCP MCP Server v${MCP_SERVER_VERSION} running on stdio`);
-    console.error(`  FCP API: ${FCP_API_URL}`);
-    if (USE_FCP_UNROO_PROXY) {
-        console.error('  Unroo: via FCP proxy (unified key mode)');
-    }
-    else {
-        console.error(`  Unroo: direct (${UNROO_API_URL})`);
-    }
-    // Auto-detect project from git remote (non-blocking)
-    initializeProjectDetection();
-    // Check for updates (non-blocking)
-    checkForUpdates();
-    // Sync ~/.claude/skills with the shared Unroo KG (non-blocking, opt-in).
-    // First run on a fresh workstation is dry-run only; user opts in via
-    // `fcp-mcp-server sync-skills --enable`.
-    // Passing the FCP key lets skills-sync route through FCP's Unroo proxy when
-    // no personal UNROO_API_KEY is set — so the single `claude mcp add` key
-    // covers skill sync too.
-    runBackgroundSync({
-        unrooApiKey: process.env.UNROO_API_KEY ?? "",
-        userEmail: FCP_USER_EMAIL,
-        unrooApiUrl: process.env.UNROO_API_URL,
-        fcpApiUrl: FCP_API_URL,
-        fcpApiToken: FCP_API_TOKEN,
-    });
-    // Handle graceful shutdown — idempotent, safe to call from any signal/event
-    let shuttingDown = false;
-    const shutdown = async (reason) => {
-        if (shuttingDown)
-            return;
-        shuttingDown = true;
-        console.error(`Shutting down MCP server (${reason})...`);
-        try {
-            await sessionTracker.endSession();
-        }
-        catch (err) {
-            console.error('Error ending session during shutdown:', err);
-        }
-        process.exit(0);
-    };
-    process.on('SIGINT', () => void shutdown('SIGINT'));
-    process.on('SIGTERM', () => void shutdown('SIGTERM'));
-    process.on('SIGHUP', () => void shutdown('SIGHUP'));
-    // Stdin closure means the parent (Claude Code) closed the pipe — exit.
-    // Without this, the server lingers as a zombie when the parent restarts
-    // or crashes, and accumulates over a long workstation session.
-    process.stdin.on('end', () => void shutdown('stdin end'));
-    process.stdin.on('close', () => void shutdown('stdin close'));
-    process.stdin.on('error', (err) => {
-        console.error('stdin error:', err);
-        void shutdown('stdin error');
-    });
-    // Orphan watchdog: if our parent process dies and we get reparented to
-    // init (PID 1), no signal fires and stdin may stay technically open. Poll
-    // for ppid change and shut down if we're orphaned.
-    const initialPpid = process.ppid;
-    setInterval(() => {
-        const currentPpid = process.ppid;
-        if (currentPpid === 1 && initialPpid !== 1) {
-            void shutdown(`orphaned (ppid ${initialPpid} -> 1)`);
-        }
-    }, 30_000).unref();
-}
-// Subcommand: `fcp-mcp-server sync-skills [...]` runs the skills sync CLI
-// instead of starting the MCP server. This lets the same binary serve both
-// the long-running stdio MCP role and the one-shot sync-skills tool.
-if (process.argv[2] === 'sync-skills') {
-    runSkillsCli(process.argv.slice(3))
-        .then((code) => process.exit(code))
-        .catch((err) => {
-        console.error('[skills-sync] fatal:', err);
-        process.exit(1);
-    });
-}
-else {
-    main().catch((error) => {
-        console.error('Fatal error:', error);
-        process.exit(1);
-    });
-}