@local-labs-jpollock/local-cli 0.0.1

package/addon-dist/lib/main/index.js

@@ -0,0 +1,3322 @@
+"use strict";
+/**
+ * CLI Bridge Addon - Main Process Entry Point
+ *
+ * This addon extends Local's capabilities:
+ * - GraphQL mutations for deleteSite, wpCli (for local-cli)
+ * - MCP Server for AI tool integration (Claude Code, ChatGPT, etc.)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const LocalMain = __importStar(require("@getflywheel/local/main"));
+const electron_1 = require("electron");
+const graphql_tag_1 = __importDefault(require("graphql-tag"));
+const McpServer_1 = require("./mcp/McpServer");
+const constants_1 = require("../common/constants");
+const ADDON_NAME = 'MCP Server';
+let mcpServer = null;
+/**
+ * GraphQL type definitions for CLI Bridge
+ */
+const typeDefs = (0, graphql_tag_1.default) `
+  input DeleteSiteInput {
+    "The site ID to delete"
+    id: ID!
+    "Whether to move site files to trash (true) or just remove from Local (false)"
+    trashFiles: Boolean = true
+    "Whether to update the hosts file"
+    updateHosts: Boolean = true
+  }
+
+  type DeleteSiteResult {
+    "Whether the deletion was successful"
+    success: Boolean!
+    "Error message if deletion failed"
+    error: String
+    "The ID of the deleted site"
+    siteId: ID
+  }
+
+  input WpCliInput {
+    "The site ID to run WP-CLI against"
+    siteId: ID!
+    "WP-CLI command and arguments (e.g., ['plugin', 'list', '--format=json'])"
+    args: [String!]!
+    "Skip loading plugins (default: true)"
+    skipPlugins: Boolean = true
+    "Skip loading themes (default: true)"
+    skipThemes: Boolean = true
+  }
+
+  type WpCliResult {
+    "Whether the command executed successfully"
+    success: Boolean!
+    "Command output (stdout)"
+    output: String
+    "Error message if command failed"
+    error: String
+  }
+
+  input CreateSiteInput {
+    "Site name (required)"
+    name: String!
+    "PHP version (e.g., '8.2.10'). Uses Local default if not specified."
+    phpVersion: String
+    "Web server type"
+    webServer: String
+    "Database type"
+    database: String
+    "WordPress admin username (default: admin)"
+    wpAdminUsername: String
+    "WordPress admin password (default: password)"
+    wpAdminPassword: String
+    "WordPress admin email (default: admin@local.test)"
+    wpAdminEmail: String
+    "Blueprint name to create site from. Use list_blueprints to see available blueprints."
+    blueprint: String
+  }
+
+  type CreateSiteResult {
+    "Whether site creation was initiated successfully"
+    success: Boolean!
+    "Error message if creation failed"
+    error: String
+    "The created site ID"
+    siteId: ID
+    "The site name"
+    siteName: String
+    "The site domain"
+    siteDomain: String
+  }
+
+  input OpenSiteInput {
+    "The site ID to open"
+    siteId: ID!
+    "Path to open (default: /, use /wp-admin for admin)"
+    path: String = "/"
+  }
+
+  type OpenSiteResult {
+    "Whether the site was opened successfully"
+    success: Boolean!
+    "Error message if failed"
+    error: String
+    "The URL that was opened"
+    url: String
+  }
+
+  input CloneSiteInput {
+    "The site ID to clone"
+    siteId: ID!
+    "Name for the cloned site"
+    newName: String!
+  }
+
+  type CloneSiteResult {
+    "Whether cloning was successful"
+    success: Boolean!
+    "Error message if failed"
+    error: String
+    "The new site ID"
+    newSiteId: ID
+    "The new site name"
+    newSiteName: String
+    "The new site domain"
+    newSiteDomain: String
+  }
+
+  input ExportSiteInput {
+    "The site ID to export"
+    siteId: ID!
+    "Output directory path (default: ~/Downloads)"
+    outputPath: String
+  }
+
+  type ExportSiteResult {
+    "Whether export was successful"
+    success: Boolean!
+    "Error message if failed"
+    error: String
+    "Path to the exported zip file"
+    exportPath: String
+  }
+
+  type Blueprint {
+    "Blueprint name"
+    name: String!
+    "Last modified date"
+    lastModified: String
+    "PHP version"
+    phpVersion: String
+    "Web server type"
+    webServer: String
+    "Database type"
+    database: String
+  }
+
+  type BlueprintsResult {
+    "Whether query was successful"
+    success: Boolean!
+    "Error message if failed"
+    error: String
+    "List of blueprints"
+    blueprints: [Blueprint!]
+  }
+
+  input SaveBlueprintInput {
+    "The site ID to save as blueprint"
+    siteId: ID!
+    "Name for the blueprint"
+    name: String!
+  }
+
+  type SaveBlueprintResult {
+    "Whether save was successful"
+    success: Boolean!
+    "Error message if failed"
+    error: String
+    "The blueprint name"
+    blueprintName: String
+  }
+
+  # Phase 8: WordPress Development Tools
+  input ExportDatabaseInput {
+    "The site ID"
+    siteId: ID!
+    "Output file path (optional, defaults to ~/Downloads/<site-name>.sql)"
+    outputPath: String
+  }
+
+  type ExportDatabaseResult {
+    "Whether export was successful"
+    success: Boolean!
+    "Error message if failed"
+    error: String
+    "Path to the exported SQL file"
+    outputPath: String
+  }
+
+  input ImportDatabaseInput {
+    "The site ID"
+    siteId: ID!
+    "Path to the SQL file to import"
+    sqlPath: String!
+  }
+
+  type ImportDatabaseResult {
+    "Whether import was successful"
+    success: Boolean!
+    "Error message if failed"
+    error: String
+  }
+
+  input OpenAdminerInput {
+    "The site ID"
+    siteId: ID!
+  }
+
+  type OpenAdminerResult {
+    "Whether opening was successful"
+    success: Boolean!
+    "Error message if failed"
+    error: String
+  }
+
+  input TrustSslInput {
+    "The site ID"
+    siteId: ID!
+  }
+
+  type TrustSslResult {
+    "Whether trust was successful"
+    success: Boolean!
+    "Error message if failed"
+    error: String
+  }
+
+  input McpRenameSiteInput {
+    "The site ID"
+    siteId: ID!
+    "New name for the site"
+    newName: String!
+  }
+
+  type McpRenameSiteResult {
+    "Whether rename was successful"
+    success: Boolean!
+    "Error message if failed"
+    error: String
+    "The new name"
+    newName: String
+  }
+
+  input ChangePhpVersionInput {
+    "The site ID"
+    siteId: ID!
+    "Target PHP version"
+    phpVersion: String!
+  }
+
+  type ChangePhpVersionResult {
+    "Whether change was successful"
+    success: Boolean!
+    "Error message if failed"
+    error: String
+    "The new PHP version"
+    phpVersion: String
+  }
+
+  input ImportSiteInput {
+    "Path to the zip file to import"
+    zipPath: String!
+    "Name for the imported site (optional)"
+    siteName: String
+  }
+
+  type ImportSiteResult {
+    "Whether import was successful"
+    success: Boolean!
+    "Error message if failed"
+    error: String
+    "The imported site ID"
+    siteId: ID
+    "The imported site name"
+    siteName: String
+  }
+
+  # Phase 9: Site Configuration & Dev Tools
+  input ToggleXdebugInput {
+    "The site ID"
+    siteId: ID!
+    "Whether to enable or disable Xdebug"
+    enabled: Boolean!
+  }
+
+  type ToggleXdebugResult {
+    "Whether toggle was successful"
+    success: Boolean!
+    "Error message if failed"
+    error: String
+    "Current Xdebug state"
+    enabled: Boolean
+  }
+
+  input GetSiteLogsInput {
+    "The site ID"
+    siteId: ID!
+    "Type of logs to retrieve (php, nginx, mysql, all)"
+    logType: String = "php"
+    "Number of lines to return"
+    lines: Int = 100
+  }
+
+  type LogEntry {
+    "Log type"
+    type: String!
+    "Log content"
+    content: String!
+    "Log file path"
+    path: String!
+  }
+
+  type GetSiteLogsResult {
+    "Whether retrieval was successful"
+    success: Boolean!
+    "Error message if failed"
+    error: String
+    "Log entries"
+    logs: [LogEntry!]
+  }
+
+  type ServiceInfo {
+    "Service role (php, database, webserver)"
+    role: String!
+    "Service name"
+    name: String!
+    "Service version"
+    version: String!
+  }
+
+  type ListServicesResult {
+    "Whether listing was successful"
+    success: Boolean!
+    "Error message if failed"
+    error: String
+    "Available services"
+    services: [ServiceInfo!]
+  }
+
+  extend type Mutation {
+    "Create a new WordPress site with full WordPress installation"
+    createSite(input: CreateSiteInput!): CreateSiteResult!
+
+    "Delete a site from Local"
+    deleteSite(input: DeleteSiteInput!): DeleteSiteResult!
+
+    "Delete multiple sites from Local"
+    deleteSites(ids: [ID!]!, trashFiles: Boolean = true): DeleteSiteResult!
+
+    "Run a WP-CLI command against a site"
+    wpCli(input: WpCliInput!): WpCliResult!
+
+    "Open a site in the default browser"
+    openSite(input: OpenSiteInput!): OpenSiteResult!
+
+    "Clone an existing site"
+    cloneSite(input: CloneSiteInput!): CloneSiteResult!
+
+    "Export a site to a zip file"
+    exportSite(input: ExportSiteInput!): ExportSiteResult!
+
+    "Save a site as a blueprint"
+    saveBlueprint(input: SaveBlueprintInput!): SaveBlueprintResult!
+
+    # Phase 8: WordPress Development Tools
+    "Export site database to SQL file"
+    exportDatabase(input: ExportDatabaseInput!): ExportDatabaseResult!
+
+    "Import SQL file into site database"
+    importDatabase(input: ImportDatabaseInput!): ImportDatabaseResult!
+
+    "Open Adminer database management UI"
+    openAdminer(input: OpenAdminerInput!): OpenAdminerResult!
+
+    "Trust site SSL certificate"
+    trustSsl(input: TrustSslInput!): TrustSslResult!
+
+    "Rename a site (MCP version)"
+    mcpRenameSite(input: McpRenameSiteInput!): McpRenameSiteResult!
+
+    "Change site PHP version"
+    changePhpVersion(input: ChangePhpVersionInput!): ChangePhpVersionResult!
+
+    "Import site from zip file"
+    importSite(input: ImportSiteInput!): ImportSiteResult!
+
+    # Phase 9: Site Configuration & Dev Tools
+    "Toggle Xdebug for a site"
+    toggleXdebug(input: ToggleXdebugInput!): ToggleXdebugResult!
+
+    "Get site log files"
+    getSiteLogs(input: GetSiteLogsInput!): GetSiteLogsResult!
+  }
+
+  extend type Query {
+    "Run a WP-CLI command against a site (read-only operations)"
+    wpCliQuery(input: WpCliInput!): WpCliResult!
+
+    "List all available blueprints"
+    blueprints: BlueprintsResult!
+
+    "List available service versions"
+    listServices(type: String): ListServicesResult!
+
+    # Phase 11: WP Engine Connect
+    "Check WP Engine authentication status"
+    wpeStatus: WpeAuthStatus!
+
+    "List all sites from WP Engine account"
+    listWpeSites(accountId: String): ListWpeSitesResult!
+
+    # Phase 11b: Site Linking
+    "Get WP Engine connection details for a local site"
+    getWpeLink(siteId: ID!): GetWpeLinkResult!
+  }
+
+  # Phase 11: WP Engine Connect Types
+  type WpeAuthStatus {
+    "Whether authenticated with WP Engine"
+    authenticated: Boolean!
+    "User email if authenticated"
+    email: String
+    "Account ID if authenticated"
+    accountId: String
+    "Account name if authenticated"
+    accountName: String
+    "Token expiry time"
+    tokenExpiry: String
+    "Error message if status check failed"
+    error: String
+  }
+
+  type WpeAuthResult {
+    "Whether authentication was successful"
+    success: Boolean!
+    "User email if successful"
+    email: String
+    "Message about the authentication result"
+    message: String
+    "Error message if failed"
+    error: String
+  }
+
+  type WpeLogoutResult {
+    "Whether logout was successful"
+    success: Boolean!
+    "Message about the logout result"
+    message: String
+    "Error message if failed"
+    error: String
+  }
+
+  type WpeSite {
+    "Install ID"
+    id: String!
+    "Install name"
+    name: String!
+    "Environment (production, staging, development)"
+    environment: String!
+    "PHP version"
+    phpVersion: String
+    "Primary domain"
+    primaryDomain: String
+    "Account ID"
+    accountId: String
+    "Account name"
+    accountName: String
+    "SFTP host"
+    sftpHost: String
+    "SFTP user"
+    sftpUser: String
+  }
+
+  type ListWpeSitesResult {
+    "Whether query was successful"
+    success: Boolean!
+    "Error message if failed"
+    error: String
+    "List of WP Engine sites"
+    sites: [WpeSite!]
+    "Total count of sites"
+    count: Int
+  }
+
+  # Phase 11b: Site Linking Types
+  type WpeConnection {
+    "Remote install ID (UUID from WP Engine)"
+    remoteInstallId: String!
+    "Install name (human-readable, used in portal URLs)"
+    installName: String
+    "Environment (production, staging, development)"
+    environment: String
+    "Account ID"
+    accountId: String
+    "WP Engine portal URL"
+    portalUrl: String
+    "Primary domain/CNAME"
+    primaryDomain: String
+  }
+
+  "Sync capabilities available for WPE-connected sites"
+  type WpeSyncCapabilities {
+    "Whether user can push to WP Engine"
+    canPush: Boolean!
+    "Whether user can pull from WP Engine"
+    canPull: Boolean!
+    "Available sync modes"
+    syncModes: [String!]!
+    "Whether Magic Sync (select files) is available"
+    magicSyncAvailable: Boolean!
+    "Whether database sync is available"
+    databaseSyncAvailable: Boolean!
+  }
+
+  type GetWpeLinkResult {
+    "Whether site is linked to WP Engine"
+    linked: Boolean!
+    "Site name"
+    siteName: String
+    "WP Engine connections"
+    connections: [WpeConnection!]
+    "Number of connections"
+    connectionCount: Int
+    "Sync capabilities (only present if linked)"
+    capabilities: WpeSyncCapabilities
+    "Message (for unlinked sites)"
+    message: String
+    "Error message if failed"
+    error: String
+  }
+
+  # Phase 11c: Sync Operations Types
+  type SyncHistoryEvent {
+    "Remote install name"
+    remoteInstallName: String
+    "Unix timestamp"
+    timestamp: Float!
+    "Environment (production, staging, development)"
+    environment: String!
+    "Sync direction"
+    direction: String!
+    "Sync status"
+    status: String
+  }
+
+  type GetSyncHistoryResult {
+    "Whether the query was successful"
+    success: Boolean!
+    "Site name"
+    siteName: String
+    "Sync history events"
+    events: [SyncHistoryEvent!]
+    "Number of events"
+    count: Int
+    "Error message if failed"
+    error: String
+  }
+
+  type SyncResult {
+    "Whether the sync was initiated successfully"
+    success: Boolean!
+    "Status message"
+    message: String
+    "Error message if failed"
+    error: String
+  }
+
+  # File change detection
+  type FileChange {
+    "File path relative to site root"
+    path: String!
+    "Change type: create, upload, download, delete, modify"
+    instruction: String!
+    "File size in bytes"
+    size: Int
+    "File type: - (file) or d (directory)"
+    type: String
+  }
+
+  type GetSiteChangesResult {
+    "Whether the query was successful"
+    success: Boolean!
+    "Site name"
+    siteName: String
+    "Direction of comparison"
+    direction: String
+    "Files that would be added/uploaded"
+    added: [FileChange!]
+    "Files that would be modified"
+    modified: [FileChange!]
+    "Files that would be deleted"
+    deleted: [FileChange!]
+    "Total number of changes"
+    totalChanges: Int
+    "Summary message"
+    message: String
+    "Error message if failed"
+    error: String
+  }
+
+  # Phase 10: Cloud Backup Types
+  type BackupProviderStatus {
+    "Whether authenticated with provider"
+    authenticated: Boolean!
+    "Account ID"
+    accountId: String
+    "Account email"
+    email: String
+  }
+
+  type BackupStatusResult {
+    "Whether backups are available"
+    available: Boolean!
+    "Whether the feature is enabled"
+    featureEnabled: Boolean!
+    "Dropbox authentication status"
+    dropbox: BackupProviderStatus
+    "Google Drive authentication status"
+    googleDrive: BackupProviderStatus
+    "Message if backups unavailable"
+    message: String
+    "Error message if failed"
+    error: String
+  }
+
+  type BackupMetadata {
+    "Snapshot ID"
+    snapshotId: String!
+    "Backup timestamp (ISO format)"
+    timestamp: String
+    "Backup note/description"
+    note: String
+    "Site domain"
+    siteDomain: String
+    "Services info (JSON)"
+    services: String
+  }
+
+  type ListBackupsResult {
+    "Whether query was successful"
+    success: Boolean!
+    "Site name"
+    siteName: String
+    "Backup provider"
+    provider: String
+    "List of backups"
+    backups: [BackupMetadata!]
+    "Number of backups"
+    count: Int
+    "Error message if failed"
+    error: String
+  }
+
+  type CreateBackupResult {
+    "Whether backup was created successfully"
+    success: Boolean!
+    "Snapshot ID"
+    snapshotId: String
+    "Backup timestamp"
+    timestamp: String
+    "Status message"
+    message: String
+    "Error message if failed"
+    error: String
+  }
+
+  type RestoreBackupResult {
+    "Whether restore was successful"
+    success: Boolean!
+    "Status message"
+    message: String
+    "Error message if failed"
+    error: String
+  }
+
+  type DeleteBackupResult {
+    "Whether deletion was successful"
+    success: Boolean!
+    "Deleted snapshot ID"
+    deletedSnapshotId: String
+    "Status message"
+    message: String
+    "Error message if failed"
+    error: String
+  }
+
+  type DownloadBackupResult {
+    "Whether download was successful"
+    success: Boolean!
+    "Path to downloaded file"
+    filePath: String
+    "Status message"
+    message: String
+    "Error message if failed"
+    error: String
+  }
+
+  type EditBackupNoteResult {
+    "Whether edit was successful"
+    success: Boolean!
+    "Updated snapshot ID"
+    snapshotId: String
+    "Updated note"
+    note: String
+    "Error message if failed"
+    error: String
+  }
+
+  extend type Query {
+    # Phase 10: Cloud Backups
+    "Check if cloud backups are available and authenticated"
+    backupStatus: BackupStatusResult!
+
+    "List all backups for a site"
+    listBackups(siteId: ID!, provider: String!): ListBackupsResult!
+
+    # Phase 11c: Sync Operations
+    "Get sync history for a local site"
+    getSyncHistory(siteId: ID!, limit: Int): GetSyncHistoryResult!
+
+    "Get file changes between local site and WP Engine (dry-run comparison)"
+    getSiteChanges(siteId: ID!, direction: String = "push"): GetSiteChangesResult!
+  }
+
+  extend type Mutation {
+    # Phase 10: Cloud Backups
+    "Create a backup of a site to cloud storage"
+    createBackup(siteId: ID!, provider: String!, note: String): CreateBackupResult!
+
+    "Restore a site from a cloud backup"
+    restoreBackup(
+      siteId: ID!
+      provider: String!
+      snapshotId: String!
+      confirm: Boolean = false
+    ): RestoreBackupResult!
+
+    "Delete a backup from cloud storage"
+    deleteBackup(
+      siteId: ID!
+      provider: String!
+      snapshotId: String!
+      confirm: Boolean = false
+    ): DeleteBackupResult!
+
+    "Download a backup as a ZIP file"
+    downloadBackup(siteId: ID!, provider: String!, snapshotId: String!): DownloadBackupResult!
+
+    "Update the note/description for a backup"
+    editBackupNote(
+      siteId: ID!
+      provider: String!
+      snapshotId: String!
+      note: String!
+    ): EditBackupNoteResult!
+
+    # Phase 11: WP Engine Connect
+    "Authenticate with WP Engine (opens browser for OAuth)"
+    wpeAuthenticate: WpeAuthResult!
+
+    "Logout from WP Engine"
+    wpeLogout: WpeLogoutResult!
+
+    # Phase 11c: Sync Operations
+    "Push local site to WP Engine"
+    pushToWpe(
+      localSiteId: ID!
+      remoteInstallId: ID!
+      includeSql: Boolean = false
+      confirm: Boolean = false
+    ): SyncResult!
+
+    "Pull from WP Engine to local site"
+    pullFromWpe(localSiteId: ID!, remoteInstallId: ID!, includeSql: Boolean = false): SyncResult!
+  }
+`;
+/**
+ * Create GraphQL resolvers that use Local's internal services
+ */
+function createResolvers(services) {
+    const { deleteSite: deleteSiteService, siteData, localLogger, wpCli, siteProcessManager, addSite: addSiteService, cloneSite: cloneSiteService, exportSite: exportSiteService, blueprints: blueprintsService, browserManager, adminer, x509Cert, siteProvisioner, importSite: importSiteService, lightningServices, siteDatabase, importSQLFile: importSQLFileService, 
+    // Phase 11: WP Engine Connect
+    wpeOAuth: wpeOAuthService, capi: capiService, 
+    // Phase 11c: Sync services
+    wpePush: wpePushService, wpePull: wpePullService, connectHistory: connectHistoryService, wpeConnectBase: wpeConnectBaseService,
+    // Note: Phase 10 Cloud Backup services are accessed via IPC to the Cloud Backups addon
+    // (backupService, dropbox, googleDrive, featureFlags, userData)
+     } = services;
+    // Helper to invoke IPC calls to the Cloud Backups addon
+    // This uses the same pattern as the BackupAIBridge
+    // Timeout constants for backup operations (in milliseconds)
+    const BACKUP_IPC_TIMEOUT = 600000; // 10 minutes for backup operations
+    const DEFAULT_IPC_TIMEOUT = 30000; // 30 seconds for quick operations
+    const invokeBackupIPC = async (channel, timeoutMs = BACKUP_IPC_TIMEOUT, ...args) => {
+        return new Promise((resolve, reject) => {
+            const timestamp = Date.now();
+            const random = Math.random().toString(36).substr(2, 9);
+            const successReplyChannel = `${channel}-success-${timestamp}-${random}`;
+            const errorReplyChannel = `${channel}-error-${timestamp}-${random}`;
+            const timeoutSeconds = Math.round(timeoutMs / 1000);
+            const timeout = setTimeout(() => {
+                electron_1.ipcMain.removeAllListeners(successReplyChannel);
+                electron_1.ipcMain.removeAllListeners(errorReplyChannel);
+                reject(new Error(`IPC call to ${channel} timed out after ${timeoutSeconds} seconds`));
+            }, timeoutMs);
+            electron_1.ipcMain.once(successReplyChannel, (_event, result) => {
+                clearTimeout(timeout);
+                electron_1.ipcMain.removeAllListeners(errorReplyChannel);
+                localLogger.info(`[${ADDON_NAME}] IPC success from ${channel}`);
+                resolve({ result });
+            });
+            electron_1.ipcMain.once(errorReplyChannel, (_event, error) => {
+                clearTimeout(timeout);
+                electron_1.ipcMain.removeAllListeners(successReplyChannel);
+                localLogger.error(`[${ADDON_NAME}] IPC error from ${channel}: ${error?.message}`);
+                resolve({ error });
+            });
+            const mockEvent = {
+                reply: (replyChannel, data) => {
+                    electron_1.ipcMain.emit(replyChannel, null, data);
+                },
+                sender: {
+                    send: (replyChannel, data) => {
+                        electron_1.ipcMain.emit(replyChannel, null, data);
+                    },
+                },
+            };
+            const replyChannels = { successReplyChannel, errorReplyChannel };
+            localLogger.info(`[${ADDON_NAME}] Invoking backup IPC: ${channel}`);
+            electron_1.ipcMain.emit(channel, mockEvent, replyChannels, ...args);
+        });
+    };
+    // Helper to get backup providers from the Cloud Backups addon
+    const getBackupProviders = async () => {
+        try {
+            const result = await invokeBackupIPC('backups:enabled-providers', DEFAULT_IPC_TIMEOUT);
+            localLogger.info(`[${ADDON_NAME}] Raw IPC result: ${JSON.stringify(result)}`);
+            if (result.error) {
+                localLogger.error(`[${ADDON_NAME}] Failed to get backup providers: ${result.error.message}`);
+                return [];
+            }
+            // The response is double-nested: result.result.result contains the array
+            // Structure: { result: { result: [providers...] } }
+            let providers = result.result;
+            // Unwrap nested result if present
+            if (providers && typeof providers === 'object' && !Array.isArray(providers)) {
+                if (Array.isArray(providers.result)) {
+                    providers = providers.result;
+                }
+                else if (providers.result && typeof providers.result === 'object') {
+                    // Even deeper nesting
+                    providers = providers.result;
+                }
+            }
+            localLogger.info(`[${ADDON_NAME}] Extracted providers: ${JSON.stringify(providers)}`);
+            if (Array.isArray(providers)) {
+                localLogger.info(`[${ADDON_NAME}] Got ${providers.length} backup providers`);
+                return providers;
+            }
+            localLogger.warn(`[${ADDON_NAME}] Unexpected providers format after unwrapping: ${typeof providers}`);
+            return [];
+        }
+        catch (error) {
+            localLogger.error(`[${ADDON_NAME}] Error getting backup providers: ${error.message}`);
+            return [];
+        }
+    };
+    // Shared WP-CLI execution logic
+    const executeWpCli = async (_parent, args) => {
+        const { siteId, args: wpArgs, skipPlugins = true, skipThemes = true } = args.input;
+        try {
+            localLogger.info(`[${ADDON_NAME}] Running WP-CLI: wp ${wpArgs.join(' ')}`);
+            const site = siteData.getSite(siteId);
+            if (!site) {
+                return {
+                    success: false,
+                    output: null,
+                    error: `Site not found: ${siteId}`,
+                };
+            }
+            const status = await siteProcessManager.getSiteStatus(site);
+            if (status !== 'running') {
+                return {
+                    success: false,
+                    output: null,
+                    error: `Site "${site.name}" is not running. Start it first with: local-cli start ${site.name}`,
+                };
+            }
+            const output = await wpCli.run(site, wpArgs, {
+                skipPlugins,
+                skipThemes,
+                ignoreErrors: false,
+            });
+            localLogger.info(`[${ADDON_NAME}] WP-CLI completed successfully`);
+            return {
+                success: true,
+                output: output?.trim() || '',
+                error: null,
+            };
+        }
+        catch (error) {
+            localLogger.error(`[${ADDON_NAME}] WP-CLI failed:`, error);
+            return {
+                success: false,
+                output: null,
+                error: error.message || 'Unknown error',
+            };
+        }
+    };
+    return {
+        Query: {
+            wpCliQuery: executeWpCli,
+            blueprints: async () => {
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Fetching blueprints`);
+                    const blueprintsList = await blueprintsService.getBlueprints();
+                    return {
+                        success: true,
+                        error: null,
+                        blueprints: blueprintsList.map((bp) => ({
+                            name: bp.name,
+                            lastModified: bp.lastModified,
+                            // Handle nested objects - extract just the name/type string
+                            phpVersion: typeof bp.phpVersion === 'object'
+                                ? bp.phpVersion?.name || bp.phpVersion?.version
+                                : bp.phpVersion,
+                            webServer: typeof bp.webServer === 'object'
+                                ? bp.webServer?.name || bp.webServer?.type
+                                : bp.webServer,
+                            database: typeof bp.database === 'object'
+                                ? bp.database?.name || bp.database?.type
+                                : bp.database,
+                        })),
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to fetch blueprints:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        blueprints: [],
+                    };
+                }
+            },
+            listServices: async (_parent, args) => {
+                const { type = 'all' } = args;
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Listing services (type: ${type})`);
+                    if (!lightningServices) {
+                        return {
+                            success: false,
+                            error: 'Lightning services not available',
+                            services: [],
+                        };
+                    }
+                    const roleMap = {
+                        php: 'php',
+                        database: 'mysql',
+                        webserver: 'nginx',
+                    };
+                    const roleFilter = type !== 'all' ? roleMap[type] : undefined;
+                    const registeredServices = lightningServices.getRegisteredServices(roleFilter);
+                    const serviceList = [];
+                    for (const [role, versions] of Object.entries(registeredServices)) {
+                        for (const [version, info] of Object.entries(versions)) {
+                            serviceList.push({
+                                role,
+                                name: info?.name || role,
+                                version,
+                            });
+                        }
+                    }
+                    return {
+                        success: true,
+                        error: null,
+                        services: serviceList,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to list services:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        services: [],
+                    };
+                }
+            },
+            // Phase 11: WP Engine Connect
+            wpeStatus: async () => {
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Checking WP Engine authentication status`);
+                    if (!wpeOAuthService) {
+                        return {
+                            authenticated: false,
+                            email: null,
+                            accountId: null,
+                            accountName: null,
+                            tokenExpiry: null,
+                            error: 'WP Engine OAuth service not available',
+                        };
+                    }
+                    // Check if we have valid credentials by trying to get access token
+                    const accessToken = await wpeOAuthService.getAccessToken();
+                    if (!accessToken) {
+                        return {
+                            authenticated: false,
+                            email: null,
+                            accountId: null,
+                            accountName: null,
+                            tokenExpiry: null,
+                            error: null,
+                        };
+                    }
+                    // Try to get user info from CAPI if available
+                    let email = null;
+                    if (capiService) {
+                        try {
+                            const currentUser = await capiService.getCurrentUser();
+                            email = currentUser?.email || null;
+                        }
+                        catch {
+                            // User info not available, but still authenticated
+                        }
+                    }
+                    return {
+                        authenticated: true,
+                        email,
+                        accountId: null,
+                        accountName: null,
+                        tokenExpiry: null,
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to check WPE status:`, error);
+                    return {
+                        authenticated: false,
+                        email: null,
+                        accountId: null,
+                        accountName: null,
+                        tokenExpiry: null,
+                        error: error.message || 'Unknown error',
+                    };
+                }
+            },
+            listWpeSites: async (_parent, args) => {
+                const { accountId } = args;
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Listing WP Engine sites${accountId ? ` for account ${accountId}` : ''}`);
+                    if (!wpeOAuthService) {
+                        return {
+                            success: false,
+                            error: 'WP Engine OAuth service not available',
+                            sites: [],
+                            count: 0,
+                        };
+                    }
+                    // Check if authenticated by trying to get access token
+                    const accessToken = await wpeOAuthService.getAccessToken();
+                    if (!accessToken) {
+                        return {
+                            success: false,
+                            error: 'Not authenticated with WP Engine. Use wpe_authenticate first.',
+                            sites: [],
+                            count: 0,
+                        };
+                    }
+                    if (!capiService) {
+                        return {
+                            success: false,
+                            error: 'WP Engine CAPI service not available',
+                            sites: [],
+                            count: 0,
+                        };
+                    }
+                    // Get installs from CAPI using getInstallList
+                    const installs = await capiService.getInstallList();
+                    if (!installs) {
+                        return {
+                            success: true,
+                            error: null,
+                            sites: [],
+                            count: 0,
+                        };
+                    }
+                    const sites = installs.map((install) => ({
+                        id: install.id,
+                        name: install.name,
+                        environment: install.environment || 'production',
+                        phpVersion: install.phpVersion || null,
+                        primaryDomain: install.primaryDomain || install.cname || null,
+                        accountId: install.accountId || accountId || null,
+                        accountName: install.accountName || null,
+                        sftpHost: `${install.name}.ssh.wpengine.net`,
+                        sftpUser: install.name,
+                    }));
+                    return {
+                        success: true,
+                        error: null,
+                        sites,
+                        count: sites.length,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to list WPE sites:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        sites: [],
+                        count: 0,
+                    };
+                }
+            },
+            // Phase 11b: Site Linking
+            getWpeLink: async (_parent, args) => {
+                const { siteId } = args;
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Getting WP Engine link for site ${siteId}`);
+                    // Get site from siteData
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            linked: false,
+                            siteName: null,
+                            connections: [],
+                            connectionCount: 0,
+                            message: null,
+                            error: `Site not found: ${siteId}`,
+                        };
+                    }
+                    // Get hostConnections from site
+                    const hostConnections = site.hostConnections || [];
+                    const wpeConnections = hostConnections.filter((c) => c.hostId === 'wpe');
+                    if (wpeConnections.length === 0) {
+                        return {
+                            linked: false,
+                            siteName: site.name,
+                            connections: [],
+                            connectionCount: 0,
+                            message: 'Site is not linked to any WP Engine environment. Use Connect in Local to pull a site from WPE.',
+                            error: null,
+                        };
+                    }
+                    // Transform connections for output, enriching with CAPI data if available
+                    const connections = await Promise.all(wpeConnections.map(async (c) => {
+                        let installName = c.remoteSiteId; // Default to UUID
+                        let portalUrl = null;
+                        let primaryDomain = null;
+                        // Try to get install details from CAPI to get the actual name
+                        // remoteSiteId matches install.site.id (WPE Site ID), not install.id
+                        if (capiService && typeof capiService.getInstallList === 'function') {
+                            try {
+                                localLogger.info(`[${ADDON_NAME}] Looking for install with site.id=${c.remoteSiteId}, env=${c.remoteSiteEnv}`);
+                                const installs = await capiService.getInstallList();
+                                localLogger.info(`[${ADDON_NAME}] Got ${installs?.length || 0} installs from CAPI`);
+                                if (installs && installs.length > 0) {
+                                    // Log first install structure for debugging
+                                    localLogger.info(`[${ADDON_NAME}] Sample install structure: ${JSON.stringify(installs[0], null, 2)}`);
+                                    // Match by site.id (remoteSiteId is the WPE Site ID, not Install ID)
+                                    // Also filter by environment if available
+                                    const matchingInstall = installs.find((i) => i.site?.id === c.remoteSiteId &&
+                                        (!c.remoteSiteEnv || i.environment === c.remoteSiteEnv));
+                                    if (matchingInstall) {
+                                        localLogger.info(`[${ADDON_NAME}] Found match: ${matchingInstall.name}`);
+                                        installName = matchingInstall.name;
+                                        portalUrl = `https://my.wpengine.com/installs/${matchingInstall.name}`;
+                                        primaryDomain =
+                                            matchingInstall.primary_domain || matchingInstall.cname || null;
+                                    }
+                                    else {
+                                        localLogger.warn(`[${ADDON_NAME}] No matching install found for site.id=${c.remoteSiteId}`);
+                                    }
+                                }
+                            }
+                            catch (e) {
+                                localLogger.warn(`[${ADDON_NAME}] Could not look up install from CAPI: ${e.message}`);
+                            }
+                        }
+                        else {
+                            localLogger.warn(`[${ADDON_NAME}] capiService or getInstallList not available`);
+                        }
+                        return {
+                            remoteInstallId: c.remoteSiteId,
+                            installName,
+                            environment: c.remoteSiteEnv || null,
+                            accountId: c.accountId || null,
+                            portalUrl,
+                            primaryDomain,
+                        };
+                    }));
+                    // Capabilities are always the same for WPE-connected sites
+                    const capabilities = {
+                        canPush: true,
+                        canPull: true,
+                        syncModes: ['all_files', 'select_files', 'database_only'],
+                        magicSyncAvailable: true,
+                        databaseSyncAvailable: true,
+                    };
+                    return {
+                        linked: true,
+                        siteName: site.name,
+                        connections,
+                        connectionCount: connections.length,
+                        capabilities,
+                        message: null,
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to get WPE link:`, error);
+                    return {
+                        linked: false,
+                        siteName: null,
+                        connections: [],
+                        connectionCount: 0,
+                        message: null,
+                        error: error.message || 'Unknown error',
+                    };
+                }
+            },
+            // Phase 10: Cloud Backups
+            backupStatus: async () => {
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Checking backup status`);
+                    // Get providers from Cloud Backups addon via IPC
+                    const providers = await getBackupProviders();
+                    localLogger.info(`[${ADDON_NAME}] Got ${providers.length} backup providers`);
+                    if (providers.length === 0) {
+                        return {
+                            available: false,
+                            featureEnabled: false,
+                            dropbox: null,
+                            googleDrive: null,
+                            message: 'No cloud storage providers configured. Connect Google Drive or Dropbox in Local Hub (hub.localwp.com/addons/cloud-backups).',
+                            error: null,
+                        };
+                    }
+                    // Map provider info to our response format
+                    const dropboxProvider = providers.find((p) => p.id === 'dropbox' || p.name?.toLowerCase().includes('dropbox'));
+                    const googleProvider = providers.find((p) => p.id === 'google' || p.name?.toLowerCase().includes('google'));
+                    const dropboxStatus = dropboxProvider
+                        ? {
+                            authenticated: true,
+                            accountId: dropboxProvider.id,
+                            email: dropboxProvider.email || null,
+                        }
+                        : {
+                            authenticated: false,
+                            accountId: null,
+                            email: null,
+                        };
+                    const googleDriveStatus = googleProvider
+                        ? {
+                            authenticated: true,
+                            accountId: googleProvider.id,
+                            email: googleProvider.email || null,
+                        }
+                        : {
+                            authenticated: false,
+                            accountId: null,
+                            email: null,
+                        };
+                    const hasProvider = providers.length > 0;
+                    return {
+                        available: hasProvider,
+                        featureEnabled: true,
+                        dropbox: dropboxStatus,
+                        googleDrive: googleDriveStatus,
+                        message: hasProvider
+                            ? null
+                            : 'No cloud storage provider authenticated. Connect Dropbox or Google Drive in Local settings.',
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to check backup status:`, error);
+                    return {
+                        available: false,
+                        featureEnabled: false,
+                        dropbox: null,
+                        googleDrive: null,
+                        message: null,
+                        error: error.message || 'Unknown error',
+                    };
+                }
+            },
+            listBackups: async (_parent, args) => {
+                const { siteId, provider } = args;
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Listing backups for site ${siteId} from ${provider}`);
+                    // Get site
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            siteName: null,
+                            provider,
+                            backups: [],
+                            count: 0,
+                            error: `Site not found: ${siteId}`,
+                        };
+                    }
+                    // Get providers from Cloud Backups addon
+                    const providers = await getBackupProviders();
+                    if (providers.length === 0) {
+                        return {
+                            success: false,
+                            siteName: site.name,
+                            provider,
+                            backups: [],
+                            count: 0,
+                            error: 'No cloud storage providers configured. Connect Google Drive or Dropbox in Local Hub.',
+                        };
+                    }
+                    // Find the matching provider (map 'googleDrive' to 'google' for the addon)
+                    const providerMap = { googleDrive: 'google', dropbox: 'dropbox' };
+                    const providerId = providerMap[provider] || provider;
+                    const matchedProvider = providers.find((p) => p.id === providerId);
+                    if (!matchedProvider) {
+                        return {
+                            success: false,
+                            siteName: site.name,
+                            provider,
+                            backups: [],
+                            count: 0,
+                            error: `Provider '${provider}' not configured. Available: ${providers.map((p) => p.name).join(', ')}`,
+                        };
+                    }
+                    // For listing snapshots, use the Hub provider ID directly (e.g., 'google')
+                    // NOT the rclone backend name ('drive') - the Hub queries expect the OAuth provider name
+                    // Also pass pageOffset parameter (0 for first page)
+                    const result = await invokeBackupIPC('backups:provider-snapshots', DEFAULT_IPC_TIMEOUT, siteId, matchedProvider.id, 0);
+                    localLogger.info(`[${ADDON_NAME}] Provider snapshots raw result: ${JSON.stringify(result)}`);
+                    if (result.error) {
+                        return {
+                            success: false,
+                            siteName: site.name,
+                            provider,
+                            backups: [],
+                            count: 0,
+                            error: result.error.message || 'Failed to list backups',
+                        };
+                    }
+                    // Unwrap nested result structure (similar to providers)
+                    let backupsData = result.result;
+                    if (backupsData && typeof backupsData === 'object' && !Array.isArray(backupsData)) {
+                        // Check for nested result or snapshots array
+                        if (Array.isArray(backupsData.result)) {
+                            backupsData = backupsData.result;
+                        }
+                        else if (Array.isArray(backupsData.snapshots)) {
+                            backupsData = backupsData.snapshots;
+                        }
+                        else if (backupsData.result && Array.isArray(backupsData.result.snapshots)) {
+                            backupsData = backupsData.result.snapshots;
+                        }
+                    }
+                    const backups = Array.isArray(backupsData) ? backupsData : [];
+                    localLogger.info(`[${ADDON_NAME}] Extracted ${backups.length} backups`);
+                    return {
+                        success: true,
+                        siteName: site.name,
+                        provider,
+                        backups: backups.map((b) => ({
+                            // Use hash for snapshotId as that's what restic uses for restore/delete operations
+                            // The Hub ID (b.id) is just a database identifier
+                            snapshotId: b.hash || b.snapshotId || b.short_id,
+                            timestamp: b.updatedAt || b.createdAt || b.timestamp || b.time || b.created,
+                            note: b.configObject?.description || b.note || b.description || b.tags?.description || '',
+                            siteDomain: b.configObject?.name
+                                ? `${b.configObject.name}.local`
+                                : b.siteDomain || site.domain,
+                            services: JSON.stringify(b.configObject?.services || b.services || {}),
+                        })),
+                        count: backups.length,
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to list backups:`, error);
+                    return {
+                        success: false,
+                        siteName: null,
+                        provider,
+                        backups: [],
+                        count: 0,
+                        error: error.message || 'Unknown error',
+                    };
+                }
+            },
+            // Phase 11c: Sync History
+            getSyncHistory: async (_parent, args) => {
+                const { siteId, limit = 30 } = args;
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Getting sync history for site ${siteId}`);
+                    // Get site to verify it exists
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            siteName: null,
+                            events: [],
+                            count: 0,
+                            error: `Site not found: ${siteId}`,
+                        };
+                    }
+                    // Check if connectHistory service is available
+                    if (!connectHistoryService || typeof connectHistoryService.getEvents !== 'function') {
+                        return {
+                            success: false,
+                            siteName: site.name,
+                            events: [],
+                            count: 0,
+                            error: 'Sync history service not available',
+                        };
+                    }
+                    const events = connectHistoryService.getEvents(siteId);
+                    const limitedEvents = events.slice(0, limit);
+                    return {
+                        success: true,
+                        siteName: site.name,
+                        events: limitedEvents.map((e) => ({
+                            remoteInstallName: e.remoteInstallName || null,
+                            timestamp: e.timestamp,
+                            environment: e.environment,
+                            direction: e.direction,
+                            status: e.status || null,
+                        })),
+                        count: limitedEvents.length,
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to get sync history:`, error);
+                    return {
+                        success: false,
+                        siteName: null,
+                        events: [],
+                        count: 0,
+                        error: error.message || 'Unknown error',
+                    };
+                }
+            },
+            // Get file changes between local and WPE (dry-run comparison)
+            getSiteChanges: async (_parent, args) => {
+                const { siteId, direction = 'push' } = args;
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Getting site changes for ${siteId}, direction=${direction}`);
+                    // Validate direction
+                    if (direction !== 'push' && direction !== 'pull') {
+                        return {
+                            success: false,
+                            siteName: null,
+                            direction,
+                            added: [],
+                            modified: [],
+                            deleted: [],
+                            totalChanges: 0,
+                            message: null,
+                            error: 'Invalid direction. Must be "push" or "pull".',
+                        };
+                    }
+                    // Get site
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            siteName: null,
+                            direction,
+                            added: [],
+                            modified: [],
+                            deleted: [],
+                            totalChanges: 0,
+                            message: null,
+                            error: `Site not found: ${siteId}`,
+                        };
+                    }
+                    // Check WPE connection
+                    const wpeConnection = site.hostConnections?.find((c) => c.hostId === 'wpe');
+                    if (!wpeConnection) {
+                        return {
+                            success: false,
+                            siteName: site.name,
+                            direction,
+                            added: [],
+                            modified: [],
+                            deleted: [],
+                            totalChanges: 0,
+                            message: null,
+                            error: 'Site is not linked to WP Engine. Use Connect in Local to link the site first.',
+                        };
+                    }
+                    // Check service availability
+                    if (!wpeConnectBaseService ||
+                        typeof wpeConnectBaseService.listModifications !== 'function') {
+                        return {
+                            success: false,
+                            siteName: site.name,
+                            direction,
+                            added: [],
+                            modified: [],
+                            deleted: [],
+                            totalChanges: 0,
+                            message: null,
+                            error: 'WPE Connect service not available',
+                        };
+                    }
+                    // Get install details from CAPI
+                    let installName = wpeConnection.remoteSiteId;
+                    let primaryDomain = '';
+                    let installId = '';
+                    if (capiService && typeof capiService.getInstallList === 'function') {
+                        const installs = await capiService.getInstallList();
+                        const matchingInstall = installs?.find((i) => i.site?.id === wpeConnection.remoteSiteId &&
+                            (!wpeConnection.remoteSiteEnv || i.environment === wpeConnection.remoteSiteEnv));
+                        if (matchingInstall) {
+                            installName = matchingInstall.name;
+                            primaryDomain =
+                                matchingInstall.primary_domain ||
+                                    matchingInstall.cname ||
+                                    `${matchingInstall.name}.wpengine.com`;
+                            installId = matchingInstall.id;
+                        }
+                    }
+                    if (!primaryDomain) {
+                        return {
+                            success: false,
+                            siteName: site.name,
+                            direction,
+                            added: [],
+                            modified: [],
+                            deleted: [],
+                            totalChanges: 0,
+                            message: null,
+                            error: 'Could not determine WP Engine install details. Please ensure you are authenticated.',
+                        };
+                    }
+                    // Call listModifications (dry-run rsync comparison)
+                    localLogger.info(`[${ADDON_NAME}] Calling listModifications for ${installName}`);
+                    const modifications = await wpeConnectBaseService.listModifications({
+                        connectArgs: {
+                            wpengineInstallName: installName,
+                            wpengineInstallId: installId,
+                            wpengineSiteId: wpeConnection.remoteSiteId,
+                            wpenginePrimaryDomain: primaryDomain,
+                            localSiteId: site.id,
+                        },
+                        direction: direction,
+                        includeIgnored: false,
+                    });
+                    // Categorize changes
+                    const added = modifications
+                        .filter((f) => f.instruction === 'create' ||
+                        f.instruction === 'upload' ||
+                        f.instruction === 'download')
+                        .map((f) => ({
+                        path: f.path,
+                        instruction: f.instruction,
+                        size: f.size,
+                        type: f.type,
+                    }));
+                    const modified = modifications
+                        .filter((f) => f.instruction === 'modify')
+                        .map((f) => ({
+                        path: f.path,
+                        instruction: f.instruction,
+                        size: f.size,
+                        type: f.type,
+                    }));
+                    const deleted = modifications
+                        .filter((f) => f.instruction === 'delete')
+                        .map((f) => ({
+                        path: f.path,
+                        instruction: f.instruction,
+                        size: f.size,
+                        type: f.type,
+                    }));
+                    const totalChanges = added.length + modified.length + deleted.length;
+                    const directionLabel = direction === 'push' ? 'local → WPE' : 'WPE → local';
+                    return {
+                        success: true,
+                        siteName: site.name,
+                        direction,
+                        added,
+                        modified,
+                        deleted,
+                        totalChanges,
+                        message: totalChanges > 0
+                            ? `${totalChanges} file(s) changed (${directionLabel}): ${added.length} added, ${modified.length} modified, ${deleted.length} deleted`
+                            : `No changes detected (${directionLabel})`,
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to get site changes:`, error);
+                    return {
+                        success: false,
+                        siteName: null,
+                        direction,
+                        added: [],
+                        modified: [],
+                        deleted: [],
+                        totalChanges: 0,
+                        message: null,
+                        error: error.message || 'Unknown error',
+                    };
+                }
+            },
+        },
+        Mutation: {
+            wpCli: executeWpCli,
+            createSite: async (_parent, args) => {
+                // DEBUG: Log raw args received
+                localLogger.info(`[${ADDON_NAME}] createSite called with args: ${JSON.stringify(args)}`);
+                const { name, phpVersion, webServer = 'nginx', database = 'mysql', wpAdminUsername = 'admin', wpAdminPassword = 'password', wpAdminEmail = 'admin@local.test', blueprint, } = args.input;
+                // DEBUG: Log destructured values
+                localLogger.info(`[${ADDON_NAME}] Destructured - name: ${name}, blueprint: ${blueprint}, typeof blueprint: ${typeof blueprint}`);
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Creating site: ${name}${blueprint ? ` from blueprint: ${blueprint}` : ''}`);
+                    // Generate slug and domain from name
+                    const siteSlug = name
+                        .toLowerCase()
+                        .replace(/[^a-z0-9]+/g, '-')
+                        .replace(/^-|-$/g, '');
+                    const siteDomain = `${siteSlug}.local`;
+                    const os = require('os');
+                    const path = require('path');
+                    const fs = require('fs');
+                    const sitePath = path.join(os.homedir(), 'Local Sites', siteSlug);
+                    // If blueprint is provided, use importSiteService instead of addSiteService
+                    if (blueprint) {
+                        localLogger.info(`[${ADDON_NAME}] Blueprint parameter received: ${blueprint}`);
+                        // Get the userDataPath from electron app
+                        const { app } = require('electron');
+                        const userDataPath = app.getPath('userData');
+                        const blueprintZipPath = path.join(userDataPath, 'blueprints', `${blueprint}.zip`);
+                        localLogger.info(`[${ADDON_NAME}] Looking for blueprint at: ${blueprintZipPath}`);
+                        // Verify blueprint exists
+                        if (!fs.existsSync(blueprintZipPath)) {
+                            localLogger.error(`[${ADDON_NAME}] Blueprint not found at: ${blueprintZipPath}`);
+                            return {
+                                success: false,
+                                error: `Blueprint not found: ${blueprint}. Use list_blueprints to see available blueprints.`,
+                                siteId: null,
+                                siteName: name,
+                                siteDomain: null,
+                            };
+                        }
+                        localLogger.info(`[${ADDON_NAME}] Found blueprint at: ${blueprintZipPath}`);
+                        // Read the local-site.json from the blueprint zip to get manifest
+                        let localSiteJSON;
+                        try {
+                            const StreamZip = require('node-stream-zip');
+                            localLogger.info(`[${ADDON_NAME}] node-stream-zip loaded successfully`);
+                            const zip = new StreamZip.async({ file: blueprintZipPath });
+                            const entries = await zip.entries();
+                            localLogger.info(`[${ADDON_NAME}] Zip entries loaded, count: ${Object.keys(entries).length}`);
+                            const filename = entries['local-site.json']
+                                ? 'local-site.json'
+                                : 'pressmatic-site.json';
+                            localLogger.info(`[${ADDON_NAME}] Reading manifest file: ${filename}`);
+                            const data = await zip.entryData(filename);
+                            localSiteJSON = JSON.parse(data.toString('utf8'));
+                            await zip.close();
+                            localLogger.info(`[${ADDON_NAME}] Successfully read manifest:`, JSON.stringify(localSiteJSON).substring(0, 200));
+                        }
+                        catch (zipError) {
+                            localLogger.error(`[${ADDON_NAME}] Failed to read blueprint zip: ${zipError.message}`, zipError);
+                            return {
+                                success: false,
+                                error: `Failed to read blueprint manifest: ${zipError.message}`,
+                                siteId: null,
+                                siteName: name,
+                                siteDomain: null,
+                            };
+                        }
+                        // Build import settings
+                        const importSettings = {
+                            siteName: name,
+                            siteDomain: siteDomain,
+                            sitePath: sitePath,
+                            zip: blueprintZipPath,
+                            importData: {
+                                type: 'local-blueprint',
+                                oldSite: localSiteJSON,
+                            },
+                            environment: localSiteJSON.environment || 'flywheel',
+                            blueprint: blueprint,
+                        };
+                        // Copy service versions from blueprint if available
+                        if (localSiteJSON.services) {
+                            // Extract PHP version
+                            const phpService = Object.values(localSiteJSON.services).find((s) => s.role === 'php');
+                            if (phpService) {
+                                importSettings.phpVersion = phpService.version;
+                            }
+                            // Extract database
+                            const dbService = Object.values(localSiteJSON.services).find((s) => s.role === 'database' || s.role === 'db');
+                            if (dbService) {
+                                importSettings.database = `${dbService.name}-${dbService.version}`;
+                            }
+                            // Extract web server
+                            const webService = Object.values(localSiteJSON.services).find((s) => s.role === 'http' || s.role === 'web');
+                            if (webService) {
+                                importSettings.webServer = `${webService.name}-${webService.version}`;
+                            }
+                        }
+                        else if (localSiteJSON.phpVersion) {
+                            importSettings.phpVersion = localSiteJSON.phpVersion;
+                        }
+                        localLogger.info(`[${ADDON_NAME}] Import settings prepared:`, JSON.stringify(importSettings).substring(0, 500));
+                        if (!importSiteService) {
+                            localLogger.error(`[${ADDON_NAME}] importSiteService is not available!`);
+                            return {
+                                success: false,
+                                error: 'Import service not available',
+                                siteId: null,
+                                siteName: name,
+                                siteDomain: null,
+                            };
+                        }
+                        localLogger.info(`[${ADDON_NAME}] Calling importSiteService.run()...`);
+                        // Use the importSiteService to create from blueprint
+                        const importResult = await importSiteService.run(importSettings);
+                        localLogger.info(`[${ADDON_NAME}] Import result:`, JSON.stringify(importResult || 'null').substring(0, 500));
+                        if (importResult && importResult.id) {
+                            localLogger.info(`[${ADDON_NAME}] Successfully created site from blueprint: ${name} (${importResult.id})`);
+                            return {
+                                success: true,
+                                error: null,
+                                siteId: importResult.id,
+                                siteName: name,
+                                siteDomain: siteDomain,
+                            };
+                        }
+                        else {
+                            localLogger.warn(`[${ADDON_NAME}] Import returned but no site ID found`);
+                            return {
+                                success: true,
+                                error: null,
+                                siteId: null,
+                                siteName: name,
+                                siteDomain: siteDomain,
+                            };
+                        }
+                    }
+                    // No blueprint - create a fresh site
+                    const newSiteInfo = {
+                        siteName: name,
+                        siteDomain: siteDomain,
+                        sitePath: sitePath,
+                        webServer: webServer,
+                        database: database,
+                    };
+                    if (phpVersion) {
+                        newSiteInfo.phpVersion = phpVersion;
+                    }
+                    const wpCredentials = {
+                        adminUsername: wpAdminUsername,
+                        adminPassword: wpAdminPassword,
+                        adminEmail: wpAdminEmail,
+                    };
+                    const site = await addSiteService.addSite({
+                        newSiteInfo,
+                        wpCredentials,
+                        goToSite: false,
+                    });
+                    localLogger.info(`[${ADDON_NAME}] Successfully created site: ${name} (${site.id})`);
+                    return {
+                        success: true,
+                        error: null,
+                        siteId: site.id,
+                        siteName: name,
+                        siteDomain: siteDomain,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to create site:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        siteId: null,
+                        siteName: name,
+                        siteDomain: null,
+                    };
+                }
+            },
+            deleteSite: async (_parent, args) => {
+                const { id, trashFiles = true, updateHosts = true } = args.input;
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Deleting site: ${id}`);
+                    const site = siteData.getSite(id);
+                    if (!site) {
+                        return {
+                            success: false,
+                            error: `Site not found: ${id}`,
+                            siteId: id,
+                        };
+                    }
+                    await deleteSiteService.deleteSite({
+                        site,
+                        trashFiles,
+                        updateHosts,
+                    });
+                    localLogger.info(`[${ADDON_NAME}] Successfully deleted site: ${site.name}`);
+                    return {
+                        success: true,
+                        error: null,
+                        siteId: id,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to delete site:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        siteId: id,
+                    };
+                }
+            },
+            deleteSites: async (_parent, args) => {
+                const { ids, trashFiles = true } = args;
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Deleting ${ids.length} sites`);
+                    await deleteSiteService.deleteSites({
+                        siteIds: ids,
+                        trashFiles,
+                        updateHosts: true,
+                    });
+                    localLogger.info(`[${ADDON_NAME}] Successfully deleted ${ids.length} sites`);
+                    return {
+                        success: true,
+                        error: null,
+                        siteId: ids.join(','),
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to delete sites:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        siteId: ids.join(','),
+                    };
+                }
+            },
+            openSite: async (_parent, args) => {
+                const { siteId, path = '/' } = args.input;
+                try {
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            error: `Site not found: ${siteId}`,
+                            url: null,
+                        };
+                    }
+                    // Check if site is running
+                    const status = await siteProcessManager.getSiteStatus(site);
+                    if (status !== 'running') {
+                        return {
+                            success: false,
+                            error: `Site "${site.name}" must be running to open in browser. Start it first.`,
+                            url: null,
+                        };
+                    }
+                    const protocol = site.isStarred ? 'https' : 'http';
+                    const url = `${protocol}://${site.domain}${path}`;
+                    localLogger.info(`[${ADDON_NAME}] Opening site in browser: ${url}`);
+                    if (browserManager) {
+                        await browserManager.openInBrowser(url);
+                    }
+                    else {
+                        // Fallback to shell.openExternal
+                        const { shell } = require('electron');
+                        await shell.openExternal(url);
+                    }
+                    return {
+                        success: true,
+                        error: null,
+                        url,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to open site:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        url: null,
+                    };
+                }
+            },
+            cloneSite: async (_parent, args) => {
+                const { siteId, newName } = args.input;
+                try {
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            error: `Site not found: ${siteId}`,
+                            newSiteId: null,
+                            newSiteName: null,
+                            newSiteDomain: null,
+                        };
+                    }
+                    // Check if site is running - needed for database cloning
+                    const status = await siteProcessManager.getSiteStatus(site);
+                    if (status !== 'running') {
+                        return {
+                            success: false,
+                            error: `Site "${site.name}" must be running to clone. Start it first.`,
+                            newSiteId: null,
+                            newSiteName: null,
+                            newSiteDomain: null,
+                        };
+                    }
+                    localLogger.info(`[${ADDON_NAME}] Cloning site ${site.name} to ${newName}`);
+                    const newSite = await cloneSiteService.cloneSite({
+                        site,
+                        newSiteName: newName,
+                    });
+                    localLogger.info(`[${ADDON_NAME}] Successfully cloned site: ${newSite.name} (${newSite.id})`);
+                    return {
+                        success: true,
+                        error: null,
+                        newSiteId: newSite.id,
+                        newSiteName: newSite.name,
+                        newSiteDomain: newSite.domain,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to clone site:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        newSiteId: null,
+                        newSiteName: null,
+                        newSiteDomain: null,
+                    };
+                }
+            },
+            exportSite: async (_parent, args) => {
+                const { siteId, outputPath } = args.input;
+                const os = require('os');
+                const path = require('path');
+                try {
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            error: `Site not found: ${siteId}`,
+                            exportPath: null,
+                        };
+                    }
+                    // Check if site is running - needed for database export
+                    const status = await siteProcessManager.getSiteStatus(site);
+                    if (status !== 'running') {
+                        return {
+                            success: false,
+                            error: `Site "${site.name}" must be running to export. Start it first.`,
+                            exportPath: null,
+                        };
+                    }
+                    // Default to Downloads folder
+                    const outputDir = outputPath || path.join(os.homedir(), 'Downloads');
+                    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+                    const fileName = `${site.name}-${timestamp}.zip`;
+                    const fullPath = path.join(outputDir, fileName);
+                    localLogger.info(`[${ADDON_NAME}] Exporting site ${site.name} to ${fullPath}`);
+                    // Use default export filter (excludes archive files)
+                    const defaultExportFilter = '*.zip, *.tar.gz, *.bz2, *.tgz';
+                    await exportSiteService.exportSite({
+                        site,
+                        outputPath: fullPath,
+                        filter: defaultExportFilter,
+                    });
+                    localLogger.info(`[${ADDON_NAME}] Successfully exported site to: ${fullPath}`);
+                    return {
+                        success: true,
+                        error: null,
+                        exportPath: fullPath,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to export site:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        exportPath: null,
+                    };
+                }
+            },
+            saveBlueprint: async (_parent, args) => {
+                const { siteId, name } = args.input;
+                try {
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            error: `Site not found: ${siteId}`,
+                            blueprintName: null,
+                        };
+                    }
+                    // Check if site is running - needed for database export
+                    const status = await siteProcessManager.getSiteStatus(site);
+                    if (status !== 'running') {
+                        return {
+                            success: false,
+                            error: `Site "${site.name}" must be running to save as blueprint. Start it first.`,
+                            blueprintName: null,
+                        };
+                    }
+                    localLogger.info(`[${ADDON_NAME}] Saving site ${site.name} as blueprint: ${name}`);
+                    // Use default export filter (excludes archive files)
+                    const defaultFilter = '*.zip, *.tar.gz, *.bz2, *.tgz';
+                    await blueprintsService.saveBlueprint({
+                        name,
+                        siteId,
+                        filter: defaultFilter,
+                    });
+                    localLogger.info(`[${ADDON_NAME}] Successfully saved blueprint: ${name}`);
+                    return {
+                        success: true,
+                        error: null,
+                        blueprintName: name,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to save blueprint:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        blueprintName: null,
+                    };
+                }
+            },
+            // Phase 8: WordPress Development Tools
+            exportDatabase: async (_parent, args) => {
+                const { siteId, outputPath } = args.input;
+                const os = require('os');
+                const pathModule = require('path');
+                try {
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            error: `Site not found: ${siteId}`,
+                            outputPath: null,
+                        };
+                    }
+                    // Check if site is running - database must be accessible
+                    const status = await siteProcessManager.getSiteStatus(site);
+                    if (status !== 'running') {
+                        return {
+                            success: false,
+                            error: `Site "${site.name}" must be running to export database. Start it first.`,
+                            outputPath: null,
+                        };
+                    }
+                    // Default to Downloads folder with site name
+                    const defaultPath = pathModule.join(os.homedir(), 'Downloads', `${site.name.replace(/[^a-z0-9]/gi, '-')}.sql`);
+                    const finalPath = outputPath || defaultPath;
+                    localLogger.info(`[${ADDON_NAME}] Exporting database for ${site.name} to ${finalPath}`);
+                    // Use siteDatabase.dump() which properly sets up MySQL environment
+                    if (!siteDatabase) {
+                        return {
+                            success: false,
+                            error: 'Database service not available',
+                            outputPath: null,
+                        };
+                    }
+                    await siteDatabase.dump(site, finalPath);
+                    localLogger.info(`[${ADDON_NAME}] Successfully exported database to: ${finalPath}`);
+                    return {
+                        success: true,
+                        error: null,
+                        outputPath: finalPath,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to export database:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        outputPath: null,
+                    };
+                }
+            },
+            importDatabase: async (_parent, args) => {
+                const { siteId, sqlPath } = args.input;
+                const fs = require('fs');
+                try {
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            error: `Site not found: ${siteId}`,
+                        };
+                    }
+                    if (!fs.existsSync(sqlPath)) {
+                        return {
+                            success: false,
+                            error: `SQL file not found: ${sqlPath}`,
+                        };
+                    }
+                    // Check if site is running - database must be accessible
+                    const status = await siteProcessManager.getSiteStatus(site);
+                    if (status !== 'running') {
+                        return {
+                            success: false,
+                            error: `Site "${site.name}" must be running to import database. Start it first.`,
+                        };
+                    }
+                    localLogger.info(`[${ADDON_NAME}] Importing database for ${site.name} from ${sqlPath}`);
+                    // Use importSQLFile service which properly sets up MySQL environment
+                    if (!importSQLFileService) {
+                        return {
+                            success: false,
+                            error: 'Import SQL file service not available',
+                        };
+                    }
+                    await importSQLFileService(site, sqlPath);
+                    localLogger.info(`[${ADDON_NAME}] Successfully imported database from: ${sqlPath}`);
+                    return {
+                        success: true,
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to import database:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                    };
+                }
+            },
+            openAdminer: async (_parent, args) => {
+                const { siteId } = args.input;
+                try {
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            error: `Site not found: ${siteId}`,
+                        };
+                    }
+                    // Check if site is running - database must be accessible
+                    const status = await siteProcessManager.getSiteStatus(site);
+                    if (status !== 'running') {
+                        return {
+                            success: false,
+                            error: `Site "${site.name}" must be running to open Adminer. Start it first.`,
+                        };
+                    }
+                    localLogger.info(`[${ADDON_NAME}] Opening Adminer for ${site.name}`);
+                    if (adminer) {
+                        await adminer.open(site);
+                    }
+                    else {
+                        return {
+                            success: false,
+                            error: 'Adminer service not available',
+                        };
+                    }
+                    return {
+                        success: true,
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to open Adminer:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                    };
+                }
+            },
+            trustSsl: async (_parent, args) => {
+                const { siteId } = args.input;
+                try {
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            error: `Site not found: ${siteId}`,
+                        };
+                    }
+                    localLogger.info(`[${ADDON_NAME}] Trusting SSL for ${site.name}`);
+                    if (x509Cert) {
+                        await x509Cert.trustCert(site);
+                    }
+                    else {
+                        return {
+                            success: false,
+                            error: 'X509 certificate service not available',
+                        };
+                    }
+                    return {
+                        success: true,
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to trust SSL:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                    };
+                }
+            },
+            mcpRenameSite: async (_parent, args) => {
+                const { siteId, newName } = args.input;
+                try {
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            error: `Site not found: ${siteId}`,
+                            newName: null,
+                        };
+                    }
+                    localLogger.info(`[${ADDON_NAME}] Renaming ${site.name} to ${newName}`);
+                    // Update site name via siteData
+                    site.name = newName;
+                    await siteData.updateSite(siteId, { name: newName });
+                    localLogger.info(`[${ADDON_NAME}] Successfully renamed site to: ${newName}`);
+                    return {
+                        success: true,
+                        error: null,
+                        newName,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to rename site:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        newName: null,
+                    };
+                }
+            },
+            changePhpVersion: async (_parent, args) => {
+                const { siteId, phpVersion } = args.input;
+                try {
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            error: `Site not found: ${siteId}`,
+                            phpVersion: null,
+                        };
+                    }
+                    localLogger.info(`[${ADDON_NAME}] Changing PHP version for ${site.name} to ${phpVersion}`);
+                    if (siteProvisioner) {
+                        await siteProvisioner.swapService(site, 'php', phpVersion);
+                    }
+                    else {
+                        return {
+                            success: false,
+                            error: 'Site provisioner service not available',
+                            phpVersion: null,
+                        };
+                    }
+                    localLogger.info(`[${ADDON_NAME}] Successfully changed PHP version to: ${phpVersion}`);
+                    return {
+                        success: true,
+                        error: null,
+                        phpVersion,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to change PHP version:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        phpVersion: null,
+                    };
+                }
+            },
+            importSite: async (_parent, args) => {
+                const { zipPath, siteName } = args.input;
+                const fs = require('fs');
+                try {
+                    if (!fs.existsSync(zipPath)) {
+                        return {
+                            success: false,
+                            error: `Zip file not found: ${zipPath}`,
+                            siteId: null,
+                            siteName: null,
+                        };
+                    }
+                    localLogger.info(`[${ADDON_NAME}] Importing site from ${zipPath}`);
+                    if (!importSiteService) {
+                        return {
+                            success: false,
+                            error: 'Import site service not available',
+                            siteId: null,
+                            siteName: null,
+                        };
+                    }
+                    const result = await importSiteService.run({
+                        zipPath,
+                        siteName: siteName || undefined,
+                    });
+                    localLogger.info(`[${ADDON_NAME}] Successfully imported site: ${result.name}`);
+                    return {
+                        success: true,
+                        error: null,
+                        siteId: result.id,
+                        siteName: result.name,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to import site:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        siteId: null,
+                        siteName: null,
+                    };
+                }
+            },
+            // Phase 9: Site Configuration & Dev Tools
+            toggleXdebug: async (_parent, args) => {
+                const { siteId, enabled } = args.input;
+                try {
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            error: `Site not found: ${siteId}`,
+                            enabled: null,
+                        };
+                    }
+                    localLogger.info(`[${ADDON_NAME}] ${enabled ? 'Enabling' : 'Disabling'} Xdebug for ${site.name}`);
+                    // Update the site's xdebugEnabled property
+                    await siteData.updateSite(siteId, { xdebugEnabled: enabled });
+                    // Restart the site if it's running to apply the change
+                    const status = await siteProcessManager.getSiteStatus(site);
+                    if (status === 'running') {
+                        localLogger.info(`[${ADDON_NAME}] Restarting site to apply Xdebug change`);
+                        await siteProcessManager.restart(site);
+                    }
+                    localLogger.info(`[${ADDON_NAME}] Successfully ${enabled ? 'enabled' : 'disabled'} Xdebug`);
+                    return {
+                        success: true,
+                        error: null,
+                        enabled,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to toggle Xdebug:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        enabled: null,
+                    };
+                }
+            },
+            getSiteLogs: async (_parent, args) => {
+                const { siteId, logType = 'php', lines = 100 } = args.input;
+                const fs = require('fs');
+                const fsPromises = fs.promises;
+                const pathModule = require('path');
+                // Helper for async file existence check
+                const fileExists = async (filePath) => {
+                    try {
+                        await fsPromises.access(filePath);
+                        return true;
+                    }
+                    catch {
+                        return false;
+                    }
+                };
+                // Helper to read last N lines of a file
+                const readLastLines = async (filePath, numLines) => {
+                    try {
+                        const content = await fsPromises.readFile(filePath, 'utf-8');
+                        const logLines = content.split('\n');
+                        return logLines.slice(-numLines).join('\n') || '(empty)';
+                    }
+                    catch {
+                        return '';
+                    }
+                };
+                try {
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            error: `Site not found: ${siteId}`,
+                            logs: [],
+                        };
+                    }
+                    localLogger.info(`[${ADDON_NAME}] Getting ${logType} logs for ${site.name}`);
+                    const logs = [];
+                    const logsDir = pathModule.join(site.path, 'logs');
+                    const logFiles = {
+                        php: ['php', 'php-fpm'],
+                        nginx: ['nginx'],
+                        mysql: ['mysql'],
+                        all: ['php', 'php-fpm', 'nginx', 'mysql'],
+                    };
+                    const targetLogs = logFiles[logType] || logFiles.php;
+                    for (const logName of targetLogs) {
+                        // Check for error and access logs
+                        for (const suffix of ['error.log', 'access.log', '.log']) {
+                            const logPath = pathModule.join(logsDir, `${logName}${suffix === '.log' ? '' : '/'}${suffix}`);
+                            const altLogPath = pathModule.join(logsDir, `${logName}${suffix}`);
+                            let finalPath = null;
+                            if (await fileExists(logPath)) {
+                                finalPath = logPath;
+                            }
+                            else if (await fileExists(altLogPath)) {
+                                finalPath = altLogPath;
+                            }
+                            if (finalPath) {
+                                const content = await readLastLines(finalPath, lines);
+                                if (content) {
+                                    logs.push({
+                                        type: logName,
+                                        content,
+                                        path: finalPath,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    if (logs.length === 0) {
+                        // Try to find any log files
+                        if (await fileExists(logsDir)) {
+                            const entries = await fsPromises.readdir(logsDir, { withFileTypes: true });
+                            for (const entry of entries) {
+                                if (entry.isDirectory()) {
+                                    const subDir = pathModule.join(logsDir, entry.name);
+                                    const subEntries = await fsPromises.readdir(subDir);
+                                    for (const subFile of subEntries) {
+                                        if (subFile.endsWith('.log')) {
+                                            const logPath = pathModule.join(subDir, subFile);
+                                            const content = await readLastLines(logPath, lines);
+                                            if (content) {
+                                                logs.push({
+                                                    type: entry.name,
+                                                    content,
+                                                    path: logPath,
+                                                });
+                                            }
+                                        }
+                                    }
+                                }
+                                else if (entry.name.endsWith('.log')) {
+                                    const logPath = pathModule.join(logsDir, entry.name);
+                                    const content = await readLastLines(logPath, lines);
+                                    if (content) {
+                                        logs.push({
+                                            type: entry.name.replace('.log', ''),
+                                            content,
+                                            path: logPath,
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    return {
+                        success: true,
+                        error: null,
+                        logs,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to get logs:`, error);
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        logs: [],
+                    };
+                }
+            },
+            // Phase 10: Cloud Backup Mutations
+            createBackup: async (_parent, args) => {
+                const { siteId, provider, note } = args;
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Creating backup for site ${siteId} to ${provider}`);
+                    // Get site
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            snapshotId: null,
+                            timestamp: null,
+                            message: null,
+                            error: `Site not found: ${siteId}`,
+                        };
+                    }
+                    // Get providers from Cloud Backups addon
+                    const providers = await getBackupProviders();
+                    if (providers.length === 0) {
+                        return {
+                            success: false,
+                            snapshotId: null,
+                            timestamp: null,
+                            message: null,
+                            error: 'No cloud storage providers configured. Connect Google Drive or Dropbox in Local Hub.',
+                        };
+                    }
+                    // Find the matching provider (map 'googleDrive' to 'google' for the addon)
+                    const providerMap = { googleDrive: 'google', dropbox: 'dropbox' };
+                    const providerId = providerMap[provider] || provider;
+                    const matchedProvider = providers.find((p) => p.id === providerId);
+                    if (!matchedProvider) {
+                        return {
+                            success: false,
+                            snapshotId: null,
+                            timestamp: null,
+                            message: null,
+                            error: `Provider '${provider}' not configured. Available: ${providers.map((p) => p.name).join(', ')}`,
+                        };
+                    }
+                    // Map the Hub provider ID to rclone backend name
+                    // The addon uses 'google' in enabled-providers but expects 'drive' for backup operations
+                    const backupProviderMap = { google: 'drive', dropbox: 'dropbox' };
+                    const backupProviderId = backupProviderMap[matchedProvider.id] || matchedProvider.id;
+                    localLogger.info(`[${ADDON_NAME}] Using backup provider ID: ${backupProviderId} (from ${matchedProvider.id})`);
+                    // Create backup via IPC (use long timeout for backup operations)
+                    const description = note || 'Backup created via MCP';
+                    const result = await invokeBackupIPC('backups:backup-site', BACKUP_IPC_TIMEOUT, siteId, backupProviderId, description);
+                    localLogger.info(`[${ADDON_NAME}] Backup IPC result: ${JSON.stringify(result)}`);
+                    // Check for top-level IPC error
+                    if (result.error) {
+                        return {
+                            success: false,
+                            snapshotId: null,
+                            timestamp: null,
+                            message: null,
+                            error: result.error.message || 'Backup creation failed',
+                        };
+                    }
+                    // Unwrap nested result structure - the actual result is at result.result
+                    const backupResult = result.result;
+                    // Check if the backup result contains an error (nested at result.result.error)
+                    if (backupResult?.error) {
+                        const errorMsg = backupResult.error.message || backupResult.error.original?.message || 'Backup failed';
+                        return {
+                            success: false,
+                            snapshotId: null,
+                            timestamp: null,
+                            message: null,
+                            error: errorMsg,
+                        };
+                    }
+                    // Try to extract snapshot ID (may be nested in result.result.result)
+                    let snapshotId = backupResult?.snapshotId || backupResult?.id;
+                    if (!snapshotId && backupResult?.result) {
+                        snapshotId = backupResult.result.snapshotId || backupResult.result.id;
+                    }
+                    // If no error was returned, the backup succeeded even if no snapshot ID is provided
+                    // The addon doesn't always return the snapshot ID in its IPC response
+                    return {
+                        success: true,
+                        snapshotId: snapshotId || null,
+                        timestamp: new Date().toISOString(),
+                        message: `Backup created successfully to ${matchedProvider.name}`,
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to create backup:`, error);
+                    return {
+                        success: false,
+                        snapshotId: null,
+                        timestamp: null,
+                        message: null,
+                        error: error.message || 'Unknown error',
+                    };
+                }
+            },
+            restoreBackup: async (_parent, args) => {
+                const { siteId, provider, snapshotId, confirm = false } = args;
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Restoring backup ${snapshotId} for site ${siteId}`);
+                    // Check confirmation
+                    if (!confirm) {
+                        return {
+                            success: false,
+                            message: null,
+                            error: 'Restore requires confirm=true to prevent accidental data loss. Current site files and database will be overwritten.',
+                        };
+                    }
+                    // Get site
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            message: null,
+                            error: `Site not found: ${siteId}`,
+                        };
+                    }
+                    // Get providers from Cloud Backups addon
+                    const providers = await getBackupProviders();
+                    if (providers.length === 0) {
+                        return {
+                            success: false,
+                            message: null,
+                            error: 'No cloud storage providers configured. Connect Google Drive or Dropbox in Local Hub.',
+                        };
+                    }
+                    // Find the matching provider (map 'googleDrive' to 'google' for the addon)
+                    const providerMap = { googleDrive: 'google', dropbox: 'dropbox' };
+                    const providerId = providerMap[provider] || provider;
+                    const matchedProvider = providers.find((p) => p.id === providerId);
+                    if (!matchedProvider) {
+                        return {
+                            success: false,
+                            message: null,
+                            error: `Provider '${provider}' not configured. Available: ${providers.map((p) => p.name).join(', ')}`,
+                        };
+                    }
+                    // Map the Hub provider ID to rclone backend name
+                    const backupProviderMap = { google: 'drive', dropbox: 'dropbox' };
+                    const backupProviderId = backupProviderMap[matchedProvider.id] || matchedProvider.id;
+                    // Restore backup via IPC (use long timeout for restore operations)
+                    const result = await invokeBackupIPC('backups:restore-backup', BACKUP_IPC_TIMEOUT, siteId, backupProviderId, snapshotId);
+                    localLogger.info(`[${ADDON_NAME}] Restore result: ${JSON.stringify(result)}`);
+                    // Check for errors - can be at result.error or result.result.error (IPC async pattern)
+                    const ipcError = result.error || result.result?.error;
+                    if (ipcError) {
+                        const errorMessage = typeof ipcError === 'string' ? ipcError : ipcError.message || 'Restore failed';
+                        return {
+                            success: false,
+                            message: null,
+                            error: errorMessage,
+                        };
+                    }
+                    return {
+                        success: true,
+                        message: `Site restored from backup ${snapshotId}`,
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to restore backup:`, error);
+                    return {
+                        success: false,
+                        message: null,
+                        error: error.message || 'Unknown error',
+                    };
+                }
+            },
+            deleteBackup: async (_parent, args) => {
+                const { siteId, provider, snapshotId, confirm = false } = args;
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Deleting backup ${snapshotId} for site ${siteId}`);
+                    // Check confirmation
+                    if (!confirm) {
+                        return {
+                            success: false,
+                            deletedSnapshotId: null,
+                            message: null,
+                            error: 'Delete requires confirm=true to prevent accidental deletion.',
+                        };
+                    }
+                    // Get site
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            deletedSnapshotId: null,
+                            message: null,
+                            error: `Site not found: ${siteId}`,
+                        };
+                    }
+                    // Get providers from Cloud Backups addon
+                    const providers = await getBackupProviders();
+                    if (providers.length === 0) {
+                        return {
+                            success: false,
+                            deletedSnapshotId: null,
+                            message: null,
+                            error: 'No cloud storage providers configured. Connect Google Drive or Dropbox in Local Hub.',
+                        };
+                    }
+                    // Find the matching provider (map 'googleDrive' to 'google' for the addon)
+                    const providerMap = { googleDrive: 'google', dropbox: 'dropbox' };
+                    const providerId = providerMap[provider] || provider;
+                    const matchedProvider = providers.find((p) => p.id === providerId);
+                    if (!matchedProvider) {
+                        return {
+                            success: false,
+                            deletedSnapshotId: null,
+                            message: null,
+                            error: `Provider '${provider}' not configured. Available: ${providers.map((p) => p.name).join(', ')}`,
+                        };
+                    }
+                    // Map the Hub provider ID to rclone backend name
+                    const backupProviderMap = { google: 'drive', dropbox: 'dropbox' };
+                    const backupProviderId = backupProviderMap[matchedProvider.id] || matchedProvider.id;
+                    // Try to delete backup via IPC (may not be supported by the addon)
+                    const result = await invokeBackupIPC('backups:delete-backup', DEFAULT_IPC_TIMEOUT, siteId, backupProviderId, snapshotId);
+                    if (result.error) {
+                        // If the IPC channel doesn't exist or isn't supported, provide helpful message
+                        if (result.error.message?.includes('timed out')) {
+                            return {
+                                success: false,
+                                deletedSnapshotId: null,
+                                message: null,
+                                error: 'Delete backup operation is not available via MCP. Please delete backups through the Local UI.',
+                            };
+                        }
+                        return {
+                            success: false,
+                            deletedSnapshotId: null,
+                            message: null,
+                            error: result.error.message || 'Delete failed',
+                        };
+                    }
+                    return {
+                        success: true,
+                        deletedSnapshotId: snapshotId,
+                        message: 'Backup deleted',
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to delete backup:`, error);
+                    return {
+                        success: false,
+                        deletedSnapshotId: null,
+                        message: null,
+                        error: error.message || 'Unknown error',
+                    };
+                }
+            },
+            downloadBackup: async (_parent, args) => {
+                const { siteId, provider, snapshotId } = args;
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Downloading backup ${snapshotId} for site ${siteId}`);
+                    // Get site
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            filePath: null,
+                            message: null,
+                            error: `Site not found: ${siteId}`,
+                        };
+                    }
+                    // Get providers from Cloud Backups addon
+                    const providers = await getBackupProviders();
+                    if (providers.length === 0) {
+                        return {
+                            success: false,
+                            filePath: null,
+                            message: null,
+                            error: 'No cloud storage providers configured. Connect Google Drive or Dropbox in Local Hub.',
+                        };
+                    }
+                    // Find the matching provider (map 'googleDrive' to 'google' for the addon)
+                    const providerMap = { googleDrive: 'google', dropbox: 'dropbox' };
+                    const providerId = providerMap[provider] || provider;
+                    const matchedProvider = providers.find((p) => p.id === providerId);
+                    if (!matchedProvider) {
+                        return {
+                            success: false,
+                            filePath: null,
+                            message: null,
+                            error: `Provider '${provider}' not configured. Available: ${providers.map((p) => p.name).join(', ')}`,
+                        };
+                    }
+                    // Map the Hub provider ID to rclone backend name
+                    const backupProviderMap = { google: 'drive', dropbox: 'dropbox' };
+                    const backupProviderId = backupProviderMap[matchedProvider.id] || matchedProvider.id;
+                    // Try to download backup via IPC (use long timeout for downloads)
+                    const result = await invokeBackupIPC('backups:download-backup', BACKUP_IPC_TIMEOUT, siteId, backupProviderId, snapshotId);
+                    if (result.error) {
+                        // If the IPC channel doesn't exist or isn't supported, provide helpful message
+                        if (result.error.message?.includes('timed out')) {
+                            return {
+                                success: false,
+                                filePath: null,
+                                message: null,
+                                error: 'Download backup operation is not available via MCP. Please download backups through the Local UI.',
+                            };
+                        }
+                        return {
+                            success: false,
+                            filePath: null,
+                            message: null,
+                            error: result.error.message || 'Download failed',
+                        };
+                    }
+                    return {
+                        success: true,
+                        filePath: result.result?.filePath || null,
+                        message: 'Backup downloaded to Downloads folder',
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to download backup:`, error);
+                    return {
+                        success: false,
+                        filePath: null,
+                        message: null,
+                        error: error.message || 'Unknown error',
+                    };
+                }
+            },
+            editBackupNote: async (_parent, args) => {
+                const { siteId, provider, snapshotId, note } = args;
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Editing backup note for ${snapshotId}`);
+                    // Get site
+                    const site = siteData.getSite(siteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            snapshotId: null,
+                            note: null,
+                            error: `Site not found: ${siteId}`,
+                        };
+                    }
+                    // Get providers from Cloud Backups addon
+                    const providers = await getBackupProviders();
+                    if (providers.length === 0) {
+                        return {
+                            success: false,
+                            snapshotId: null,
+                            note: null,
+                            error: 'No cloud storage providers configured. Connect Google Drive or Dropbox in Local Hub.',
+                        };
+                    }
+                    // Find the matching provider (map 'googleDrive' to 'google' for the addon)
+                    const providerMap = { googleDrive: 'google', dropbox: 'dropbox' };
+                    const providerId = providerMap[provider] || provider;
+                    const matchedProvider = providers.find((p) => p.id === providerId);
+                    if (!matchedProvider) {
+                        return {
+                            success: false,
+                            snapshotId: null,
+                            note: null,
+                            error: `Provider '${provider}' not configured. Available: ${providers.map((p) => p.name).join(', ')}`,
+                        };
+                    }
+                    // Map the Hub provider ID to rclone backend name
+                    const backupProviderMap = { google: 'drive', dropbox: 'dropbox' };
+                    const backupProviderId = backupProviderMap[matchedProvider.id] || matchedProvider.id;
+                    // Try to edit backup note via IPC (quick metadata operation)
+                    const result = await invokeBackupIPC('backups:edit-note', DEFAULT_IPC_TIMEOUT, siteId, backupProviderId, snapshotId, note);
+                    if (result.error) {
+                        // If the IPC channel doesn't exist or isn't supported, provide helpful message
+                        if (result.error.message?.includes('timed out')) {
+                            return {
+                                success: false,
+                                snapshotId: null,
+                                note: null,
+                                error: 'Edit backup note operation is not available via MCP. Please edit backup notes through the Local UI.',
+                            };
+                        }
+                        return {
+                            success: false,
+                            snapshotId: null,
+                            note: null,
+                            error: result.error.message || 'Edit note failed',
+                        };
+                    }
+                    return {
+                        success: true,
+                        snapshotId,
+                        note,
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to edit backup note:`, error);
+                    return {
+                        success: false,
+                        snapshotId: null,
+                        note: null,
+                        error: error.message || 'Unknown error',
+                    };
+                }
+            },
+            // Phase 11: WP Engine Connect
+            wpeAuthenticate: async () => {
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Initiating WP Engine authentication`);
+                    if (!wpeOAuthService) {
+                        return {
+                            success: false,
+                            email: null,
+                            message: null,
+                            error: 'WP Engine OAuth service not available',
+                        };
+                    }
+                    // Trigger OAuth flow - this will open browser for user consent
+                    // authenticate() returns OAuthTokens on success
+                    const tokens = await wpeOAuthService.authenticate();
+                    if (tokens && tokens.accessToken) {
+                        // Try to get user email from CAPI
+                        let email = null;
+                        if (capiService) {
+                            try {
+                                const currentUser = await capiService.getCurrentUser();
+                                email = currentUser?.email || null;
+                            }
+                            catch {
+                                // User info not available
+                            }
+                        }
+                        localLogger.info(`[${ADDON_NAME}] Successfully authenticated with WPE${email ? ` as ${email}` : ''}`);
+                        return {
+                            success: true,
+                            email,
+                            message: 'Successfully authenticated with WP Engine',
+                            error: null,
+                        };
+                    }
+                    return {
+                        success: true,
+                        email: null,
+                        message: 'Authentication initiated. Please complete the login in your browser.',
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] WPE authentication failed:`, error);
+                    return {
+                        success: false,
+                        email: null,
+                        message: null,
+                        error: error.message || 'Authentication failed',
+                    };
+                }
+            },
+            wpeLogout: async () => {
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Logging out from WP Engine`);
+                    if (!wpeOAuthService) {
+                        return {
+                            success: false,
+                            message: null,
+                            error: 'WP Engine OAuth service not available',
+                        };
+                    }
+                    // clearTokens() is the logout method
+                    await wpeOAuthService.clearTokens();
+                    localLogger.info(`[${ADDON_NAME}] Successfully logged out from WPE`);
+                    return {
+                        success: true,
+                        message: 'Logged out from WP Engine',
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] WPE logout failed:`, error);
+                    return {
+                        success: false,
+                        message: null,
+                        error: error.message || 'Logout failed',
+                    };
+                }
+            },
+            // Phase 11c: Push to WP Engine
+            pushToWpe: async (_parent, args) => {
+                const { localSiteId, remoteInstallId, includeSql = false, confirm = false } = args;
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Push to WPE: site=${localSiteId}, remote=${remoteInstallId}, includeSql=${includeSql}`);
+                    // Require confirmation for push operations
+                    if (!confirm) {
+                        return {
+                            success: false,
+                            message: null,
+                            error: 'Push requires confirm=true to prevent accidental overwrites. Set confirm=true to proceed.',
+                        };
+                    }
+                    // Verify site exists
+                    const site = siteData.getSite(localSiteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            message: null,
+                            error: `Site not found: ${localSiteId}`,
+                        };
+                    }
+                    // Check WPE connection exists
+                    const wpeConnection = site.hostConnections?.find((c) => c.hostId === 'wpe');
+                    if (!wpeConnection) {
+                        return {
+                            success: false,
+                            message: null,
+                            error: 'Site is not linked to WP Engine. Use Connect in Local to link the site first.',
+                        };
+                    }
+                    // Check push service availability
+                    if (!wpePushService || typeof wpePushService.push !== 'function') {
+                        return {
+                            success: false,
+                            message: null,
+                            error: 'WPE Push service not available',
+                        };
+                    }
+                    // Get install details from CAPI to get required parameters
+                    let installName = remoteInstallId;
+                    let primaryDomain = '';
+                    let installId = '';
+                    if (capiService && typeof capiService.getInstallList === 'function') {
+                        const installs = await capiService.getInstallList();
+                        const matchingInstall = installs?.find((i) => i.site?.id === wpeConnection.remoteSiteId &&
+                            (!wpeConnection.remoteSiteEnv || i.environment === wpeConnection.remoteSiteEnv));
+                        if (matchingInstall) {
+                            installName = matchingInstall.name;
+                            primaryDomain =
+                                matchingInstall.primary_domain ||
+                                    matchingInstall.cname ||
+                                    `${matchingInstall.name}.wpengine.com`;
+                            installId = matchingInstall.id;
+                        }
+                    }
+                    if (!primaryDomain) {
+                        return {
+                            success: false,
+                            message: null,
+                            error: 'Could not determine WP Engine install details. Please ensure you are authenticated.',
+                        };
+                    }
+                    // Start the push operation (async - returns immediately)
+                    wpePushService
+                        .push({
+                        includeSql,
+                        wpengineInstallName: installName,
+                        wpengineInstallId: installId,
+                        wpengineSiteId: wpeConnection.remoteSiteId,
+                        wpenginePrimaryDomain: primaryDomain,
+                        localSiteId: site.id,
+                        environment: wpeConnection.remoteSiteEnv,
+                        isMagicSync: false,
+                    })
+                        .catch((err) => {
+                        localLogger.error(`[${ADDON_NAME}] Push failed:`, err);
+                    });
+                    return {
+                        success: true,
+                        message: `Push started to ${installName}. Check Local UI for progress.`,
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to start push:`, error);
+                    return {
+                        success: false,
+                        message: null,
+                        error: error.message || 'Failed to start push',
+                    };
+                }
+            },
+            // Phase 11c: Pull from WP Engine
+            pullFromWpe: async (_parent, args) => {
+                const { localSiteId, remoteInstallId, includeSql = false } = args;
+                try {
+                    localLogger.info(`[${ADDON_NAME}] Pull from WPE: site=${localSiteId}, remote=${remoteInstallId}, includeSql=${includeSql}`);
+                    // Verify site exists
+                    const site = siteData.getSite(localSiteId);
+                    if (!site) {
+                        return {
+                            success: false,
+                            message: null,
+                            error: `Site not found: ${localSiteId}`,
+                        };
+                    }
+                    // Check WPE connection exists
+                    const wpeConnection = site.hostConnections?.find((c) => c.hostId === 'wpe');
+                    if (!wpeConnection) {
+                        return {
+                            success: false,
+                            message: null,
+                            error: 'Site is not linked to WP Engine. Use Connect in Local to link the site first.',
+                        };
+                    }
+                    // Check pull service availability
+                    if (!wpePullService || typeof wpePullService.pull !== 'function') {
+                        return {
+                            success: false,
+                            message: null,
+                            error: 'WPE Pull service not available',
+                        };
+                    }
+                    // Get install details from CAPI
+                    let installName = remoteInstallId;
+                    let primaryDomain = '';
+                    let installId = '';
+                    if (capiService && typeof capiService.getInstallList === 'function') {
+                        const installs = await capiService.getInstallList();
+                        const matchingInstall = installs?.find((i) => i.site?.id === wpeConnection.remoteSiteId &&
+                            (!wpeConnection.remoteSiteEnv || i.environment === wpeConnection.remoteSiteEnv));
+                        if (matchingInstall) {
+                            installName = matchingInstall.name;
+                            primaryDomain =
+                                matchingInstall.primary_domain ||
+                                    matchingInstall.cname ||
+                                    `${matchingInstall.name}.wpengine.com`;
+                            installId = matchingInstall.id;
+                        }
+                    }
+                    if (!primaryDomain) {
+                        return {
+                            success: false,
+                            message: null,
+                            error: 'Could not determine WP Engine install details. Please ensure you are authenticated.',
+                        };
+                    }
+                    // Start the pull operation (async - returns immediately)
+                    wpePullService
+                        .pull({
+                        includeSql,
+                        wpengineInstallName: installName,
+                        wpengineInstallId: installId,
+                        wpengineSiteId: wpeConnection.remoteSiteId,
+                        wpenginePrimaryDomain: primaryDomain,
+                        localSiteId: site.id,
+                        environment: wpeConnection.remoteSiteEnv,
+                        isMagicSync: false,
+                    })
+                        .catch((err) => {
+                        localLogger.error(`[${ADDON_NAME}] Pull failed:`, err);
+                    });
+                    return {
+                        success: true,
+                        message: `Pull started from ${installName}. Check Local UI for progress.`,
+                        error: null,
+                    };
+                }
+                catch (error) {
+                    localLogger.error(`[${ADDON_NAME}] Failed to start pull:`, error);
+                    return {
+                        success: false,
+                        message: null,
+                        error: error.message || 'Failed to start pull',
+                    };
+                }
+            },
+        },
+    };
+}
+/**
+ * Start the MCP server
+ */
+async function startMcpServer(services, logger) {
+    if (mcpServer) {
+        logger.warn(`[${ADDON_NAME}] MCP server already running`);
+        return;
+    }
+    try {
+        mcpServer = new McpServer_1.McpServer({ port: constants_1.MCP_SERVER.DEFAULT_PORT }, services, logger);
+        await mcpServer.start();
+        const info = mcpServer.getConnectionInfo();
+        logger.info(`[${ADDON_NAME}] MCP server started on port ${info.port}`);
+        logger.info(`[${ADDON_NAME}] MCP connection info saved to: ~/Library/Application Support/Local/mcp-connection-info.json`);
+        logger.info(`[${ADDON_NAME}] Available tools: ${info.tools.join(', ')}`);
+    }
+    catch (error) {
+        logger.error(`[${ADDON_NAME}] Failed to start MCP server:`, error);
+    }
+}
+/**
+ * Stop the MCP server
+ */
+async function stopMcpServer(logger) {
+    if (mcpServer) {
+        await mcpServer.stop();
+        mcpServer = null;
+        logger.info(`[${ADDON_NAME}] MCP server stopped`);
+    }
+}
+/**
+ * Register IPC handlers for renderer communication
+ */
+function registerIpcHandlers(services, logger) {
+    // Get MCP server status
+    electron_1.ipcMain.handle('mcp:getStatus', async () => {
+        if (!mcpServer) {
+            return { running: false, port: 0, uptime: 0 };
+        }
+        return mcpServer.getStatus();
+    });
+    // Get connection info
+    electron_1.ipcMain.handle('mcp:getConnectionInfo', async () => {
+        if (!mcpServer) {
+            return null;
+        }
+        return mcpServer.getConnectionInfo();
+    });
+    // Start MCP server
+    electron_1.ipcMain.handle('mcp:start', async () => {
+        try {
+            await startMcpServer(services, logger);
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    });
+    // Stop MCP server
+    electron_1.ipcMain.handle('mcp:stop', async () => {
+        try {
+            await stopMcpServer(logger);
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    });
+    // Restart MCP server
+    electron_1.ipcMain.handle('mcp:restart', async () => {
+        try {
+            await stopMcpServer(logger);
+            await startMcpServer(services, logger);
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    });
+    // Regenerate auth token
+    electron_1.ipcMain.handle('mcp:regenerateToken', async () => {
+        if (!mcpServer) {
+            return { success: false, error: 'MCP server not running' };
+        }
+        try {
+            const newToken = await mcpServer.regenerateToken();
+            return { success: true, token: newToken };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    });
+    logger.info(`[${ADDON_NAME}] Registered IPC handlers: mcp:getStatus, mcp:getConnectionInfo, mcp:start, mcp:stop, mcp:restart, mcp:regenerateToken`);
+}
+/**
+ * Main addon initialization function
+ */
+function default_1(_context) {
+    const services = LocalMain.getServiceContainer().cradle;
+    const { localLogger, graphql } = services;
+    try {
+        localLogger.info(`[${ADDON_NAME}] Initializing...`);
+        // Register GraphQL extensions (for local-cli and MCP)
+        const resolvers = createResolvers(services);
+        graphql.registerGraphQLService('mcp-server', typeDefs, resolvers);
+        localLogger.info(`[${ADDON_NAME}] Registered GraphQL: 29 tools (Phase 1-11b)`);
+        // Start MCP server (for AI tools)
+        const localServices = {
+            siteData: services.siteData,
+            siteProcessManager: services.siteProcessManager,
+            wpCli: services.wpCli,
+            deleteSite: services.deleteSite,
+            addSite: services.addSite,
+            localLogger: services.localLogger,
+            adminer: services.adminer,
+            x509Cert: services.x509Cert,
+            siteProvisioner: services.siteProvisioner,
+            importSite: services.importSite,
+            lightningServices: services.lightningServices,
+            // Phase 11: WP Engine Connect
+            wpeOAuth: services.wpeOAuth,
+            capi: services.capi,
+        };
+        // MCP server disabled - CLI-only mode
+        // To enable MCP server for AI tool integration, uncomment the following:
+        // startMcpServer(localServices, localLogger);
+        // registerIpcHandlers(localServices, localLogger);
+        localLogger.info(`[${ADDON_NAME}] Successfully initialized (CLI-only mode)`);
+    }
+    catch (error) {
+        localLogger.error(`[${ADDON_NAME}] Failed to initialize:`, error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/main/index.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwsHH,4BAuCC;AA7uHD,mEAAqD;AACrD,uCAAmC;AACnC,8DAA8B;AAC9B,+CAA4C;AAC5C,mDAAiD;AAGjD,MAAM,UAAU,GAAG,YAAY,CAAC;AAEhC,IAAI,SAAS,GAAqB,IAAI,CAAC;AAEvC;;GAEG;AACH,MAAM,QAAQ,GAAG,IAAA,qBAAG,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4vBnB,CAAC;AAEF;;GAEG;AACH,SAAS,eAAe,CAAC,QAAa;IACpC,MAAM,EACJ,UAAU,EAAE,iBAAiB,EAC7B,QAAQ,EACR,WAAW,EACX,KAAK,EACL,kBAAkB,EAClB,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,gBAAgB,EAC3B,UAAU,EAAE,iBAAiB,EAC7B,UAAU,EAAE,iBAAiB,EAC7B,cAAc,EACd,OAAO,EACP,QAAQ,EACR,eAAe,EACf,UAAU,EAAE,iBAAiB,EAC7B,iBAAiB,EACjB,YAAY,EACZ,aAAa,EAAE,oBAAoB;IACnC,8BAA8B;IAC9B,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,WAAW;IACjB,2BAA2B;IAC3B,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,cAAc,EACvB,cAAc,EAAE,qBAAqB,EACrC,cAAc,EAAE,qBAAqB;IACrC,uFAAuF;IACvF,gEAAgE;MACjE,GAAG,QAAQ,CAAC;IAEb,wDAAwD;IACxD,mDAAmD;IACnD,4DAA4D;IAC5D,MAAM,kBAAkB,GAAG,MAAM,CAAC,CAAC,mCAAmC;IACtE,MAAM,mBAAmB,GAAG,KAAK,CAAC,CAAC,kCAAkC;IAErE,MAAM,eAAe,GAAG,KAAK,EAC3B,OAAe,EACf,YAAoB,kBAAkB,EACtC,GAAG,IAAW,EACA,EAAE;QAChB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YACvD,MAAM,mBAAmB,GAAG,GAAG,OAAO,YAAY,SAAS,IAAI,MAAM,EAAE,CAAC;YACxE,MAAM,iBAAiB,GAAG,GAAG,OAAO,UAAU,SAAS,IAAI,MAAM,EAAE,CAAC;YAEpE,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;YACpD,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC9B,kBAAO,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;gBAChD,kBAAO,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;gBAC9C,MAAM,CAAC,IAAI,KAAK,CAAC,eAAe,OAAO,oBAAoB,cAAc,UAAU,CAAC,CAAC,CAAC;YACxF,CAAC,EAAE,SAAS,CAAC,CAAC;YAEd,kBAAO,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC,MAAW,EAAE,MAAW,EAAE,EAAE;gBAC7D,YAAY,CAAC,OAAO,CAAC,CAAC;gBACtB,kBAAO,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;gBAC9C,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,sBAAsB,OAAO,EAAE,CAAC,CAAC;gBAChE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;YACtB,CAAC,CAAC,CAAC;YAEH,kBAAO,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC,MAAW,EAAE,KAAU,EAAE,EAAE;gBAC1D,YAAY,CAAC,OAAO,CAAC,CAAC;gBACtB,kBAAO,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;gBAChD,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,oBAAoB,OAAO,KAAK,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;gBAClF,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;YACrB,CAAC,CAAC,CAAC;YAEH,MAAM,SAAS,GAAG;gBAChB,KAAK,EAAE,CAAC,YAAoB,EAAE,IAAS,EAAE,EAAE;oBACzC,kBAAO,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;gBACzC,CAAC;gBACD,MAAM,EAAE;oBACN,IAAI,EAAE,CAAC,YAAoB,EAAE,IAAS,EAAE,EAAE;wBACxC,kBAAO,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;oBACzC,CAAC;iBACF;aACF,CAAC;YAEF,MAAM,aAAa,GAAG,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,CAAC;YACjE,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,0BAA0B,OAAO,EAAE,CAAC,CAAC;YACpE,kBAAO,CAAC,IAAI,CAAC,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC,CAAC;QAC3D,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,8DAA8D;IAC9D,MAAM,kBAAkB,GAAG,KAAK,IAAkD,EAAE;QAClF,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,2BAA2B,EAAE,mBAAmB,CAAC,CAAC;YACvF,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,qBAAqB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YAE9E,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;gBACjB,WAAW,CAAC,KAAK,CACf,IAAI,UAAU,qCAAqC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,CAC1E,CAAC;gBACF,OAAO,EAAE,CAAC;YACZ,CAAC;YAED,yEAAyE;YACzE,oDAAoD;YACpD,IAAI,SAAS,GAAQ,MAAM,CAAC,MAAM,CAAC;YAEnC,kCAAkC;YAClC,IAAI,SAAS,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;gBAC5E,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;oBACpC,SAAS,GAAG,SAAS,CAAC,MAAM,CAAC;gBAC/B,CAAC;qBAAM,IAAI,SAAS,CAAC,MAAM,IAAI,OAAO,SAAS,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;oBACpE,sBAAsB;oBACtB,SAAS,GAAG,SAAS,CAAC,MAAM,CAAC;gBAC/B,CAAC;YACH,CAAC;YAED,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,0BAA0B,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;YAEtF,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;gBAC7B,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,SAAS,SAAS,CAAC,MAAM,mBAAmB,CAAC,CAAC;gBAC7E,OAAO,SAAS,CAAC;YACnB,CAAC;YAED,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,mDAAmD,OAAO,SAAS,EAAE,CACpF,CAAC;YACF,OAAO,EAAE,CAAC;QACZ,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,qCAAqC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACtF,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC,CAAC;IAEF,gCAAgC;IAChC,MAAM,YAAY,GAAG,KAAK,EACxB,OAAY,EACZ,IAAgG,EAChG,EAAE;QACF,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI,EAAE,UAAU,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;QAEnF,IAAI,CAAC;YACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,wBAAwB,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAE3E,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YACtC,IAAI,CAAC,IAAI,EAAE,CAAC;gBACV,OAAO;oBACL,OAAO,EAAE,KAAK;oBACd,MAAM,EAAE,IAAI;oBACZ,KAAK,EAAE,mBAAmB,MAAM,EAAE;iBACnC,CAAC;YACJ,CAAC;YAED,MAAM,MAAM,GAAG,MAAM,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;YAC5D,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACzB,OAAO;oBACL,OAAO,EAAE,KAAK;oBACd,MAAM,EAAE,IAAI;oBACZ,KAAK,EAAE,SAAS,IAAI,CAAC,IAAI,0DAA0D,IAAI,CAAC,IAAI,EAAE;iBAC/F,CAAC;YACJ,CAAC;YAED,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE;gBAC3C,WAAW;gBACX,UAAU;gBACV,YAAY,EAAE,KAAK;aACpB,CAAC,CAAC;YAEH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,iCAAiC,CAAC,CAAC;YAElE,OAAO;gBACL,OAAO,EAAE,IAAI;gBACb,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE;gBAC5B,KAAK,EAAE,IAAI;aACZ,CAAC;QACJ,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,kBAAkB,EAAE,KAAK,CAAC,CAAC;YAC3D,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,MAAM,EAAE,IAAI;gBACZ,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;aACxC,CAAC;QACJ,CAAC;IACH,CAAC,CAAC;IAEF,OAAO;QACL,KAAK,EAAE;YACL,UAAU,EAAE,YAAY;YAExB,UAAU,EAAE,KAAK,IAAI,EAAE;gBACrB,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,uBAAuB,CAAC,CAAC;oBAExD,MAAM,cAAc,GAAG,MAAM,iBAAiB,CAAC,aAAa,EAAE,CAAC;oBAE/D,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,UAAU,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC,EAAO,EAAE,EAAE,CAAC,CAAC;4BAC3C,IAAI,EAAE,EAAE,CAAC,IAAI;4BACb,YAAY,EAAE,EAAE,CAAC,YAAY;4BAC7B,4DAA4D;4BAC5D,UAAU,EACR,OAAO,EAAE,CAAC,UAAU,KAAK,QAAQ;gCAC/B,CAAC,CAAC,EAAE,CAAC,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,UAAU,EAAE,OAAO;gCAC/C,CAAC,CAAC,EAAE,CAAC,UAAU;4BACnB,SAAS,EACP,OAAO,EAAE,CAAC,SAAS,KAAK,QAAQ;gCAC9B,CAAC,CAAC,EAAE,CAAC,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,SAAS,EAAE,IAAI;gCAC1C,CAAC,CAAC,EAAE,CAAC,SAAS;4BAClB,QAAQ,EACN,OAAO,EAAE,CAAC,QAAQ,KAAK,QAAQ;gCAC7B,CAAC,CAAC,EAAE,CAAC,QAAQ,EAAE,IAAI,IAAI,EAAE,CAAC,QAAQ,EAAE,IAAI;gCACxC,CAAC,CAAC,EAAE,CAAC,QAAQ;yBAClB,CAAC,CAAC;qBACJ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,+BAA+B,EAAE,KAAK,CAAC,CAAC;oBACxE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;wBACvC,UAAU,EAAE,EAAE;qBACf,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,YAAY,EAAE,KAAK,EAAE,OAAY,EAAE,IAAuB,EAAE,EAAE;gBAC5D,MAAM,EAAE,IAAI,GAAG,KAAK,EAAE,GAAG,IAAI,CAAC;gBAE9B,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,6BAA6B,IAAI,GAAG,CAAC,CAAC;oBAErE,IAAI,CAAC,iBAAiB,EAAE,CAAC;wBACvB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,kCAAkC;4BACzC,QAAQ,EAAE,EAAE;yBACb,CAAC;oBACJ,CAAC;oBAED,MAAM,OAAO,GAA2B;wBACtC,GAAG,EAAE,KAAK;wBACV,QAAQ,EAAE,OAAO;wBACjB,SAAS,EAAE,OAAO;qBACnB,CAAC;oBAEF,MAAM,UAAU,GAAG,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;oBAC9D,MAAM,kBAAkB,GAAG,iBAAiB,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAC;oBAE/E,MAAM,WAAW,GAA2D,EAAE,CAAC;oBAE/E,KAAK,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,kBAAkB,CAAC,EAAE,CAAC;wBAClE,KAAK,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAA+B,CAAC,EAAE,CAAC;4BAC9E,WAAW,CAAC,IAAI,CAAC;gCACf,IAAI;gCACJ,IAAI,EAAE,IAAI,EAAE,IAAI,IAAI,IAAI;gCACxB,OAAO;6BACR,CAAC,CAAC;wBACL,CAAC;oBACH,CAAC;oBAED,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,QAAQ,EAAE,WAAW;qBACtB,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,4BAA4B,EAAE,KAAK,CAAC,CAAC;oBACrE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;wBACvC,QAAQ,EAAE,EAAE;qBACb,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,8BAA8B;YAC9B,SAAS,EAAE,KAAK,IAAI,EAAE;gBACpB,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,4CAA4C,CAAC,CAAC;oBAE7E,IAAI,CAAC,eAAe,EAAE,CAAC;wBACrB,OAAO;4BACL,aAAa,EAAE,KAAK;4BACpB,KAAK,EAAE,IAAI;4BACX,SAAS,EAAE,IAAI;4BACf,WAAW,EAAE,IAAI;4BACjB,WAAW,EAAE,IAAI;4BACjB,KAAK,EAAE,uCAAuC;yBAC/C,CAAC;oBACJ,CAAC;oBAED,mEAAmE;oBACnE,MAAM,WAAW,GAAG,MAAM,eAAe,CAAC,cAAc,EAAE,CAAC;oBAE3D,IAAI,CAAC,WAAW,EAAE,CAAC;wBACjB,OAAO;4BACL,aAAa,EAAE,KAAK;4BACpB,KAAK,EAAE,IAAI;4BACX,SAAS,EAAE,IAAI;4BACf,WAAW,EAAE,IAAI;4BACjB,WAAW,EAAE,IAAI;4BACjB,KAAK,EAAE,IAAI;yBACZ,CAAC;oBACJ,CAAC;oBAED,8CAA8C;oBAC9C,IAAI,KAAK,GAAG,IAAI,CAAC;oBACjB,IAAI,WAAW,EAAE,CAAC;wBAChB,IAAI,CAAC;4BACH,MAAM,WAAW,GAAG,MAAM,WAAW,CAAC,cAAc,EAAE,CAAC;4BACvD,KAAK,GAAG,WAAW,EAAE,KAAK,IAAI,IAAI,CAAC;wBACrC,CAAC;wBAAC,MAAM,CAAC;4BACP,mDAAmD;wBACrD,CAAC;oBACH,CAAC;oBAED,OAAO;wBACL,aAAa,EAAE,IAAI;wBACnB,KAAK;wBACL,SAAS,EAAE,IAAI;wBACf,WAAW,EAAE,IAAI;wBACjB,WAAW,EAAE,IAAI;wBACjB,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,+BAA+B,EAAE,KAAK,CAAC,CAAC;oBACxE,OAAO;wBACL,aAAa,EAAE,KAAK;wBACpB,KAAK,EAAE,IAAI;wBACX,SAAS,EAAE,IAAI;wBACf,WAAW,EAAE,IAAI;wBACjB,WAAW,EAAE,IAAI;wBACjB,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;qBACxC,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,YAAY,EAAE,KAAK,EAAE,OAAY,EAAE,IAA4B,EAAE,EAAE;gBACjE,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;gBAE3B,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,4BAA4B,SAAS,CAAC,CAAC,CAAC,gBAAgB,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CACzF,CAAC;oBAEF,IAAI,CAAC,eAAe,EAAE,CAAC;wBACrB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,uCAAuC;4BAC9C,KAAK,EAAE,EAAE;4BACT,KAAK,EAAE,CAAC;yBACT,CAAC;oBACJ,CAAC;oBAED,uDAAuD;oBACvD,MAAM,WAAW,GAAG,MAAM,eAAe,CAAC,cAAc,EAAE,CAAC;oBAC3D,IAAI,CAAC,WAAW,EAAE,CAAC;wBACjB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,+DAA+D;4BACtE,KAAK,EAAE,EAAE;4BACT,KAAK,EAAE,CAAC;yBACT,CAAC;oBACJ,CAAC;oBAED,IAAI,CAAC,WAAW,EAAE,CAAC;wBACjB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,sCAAsC;4BAC7C,KAAK,EAAE,EAAE;4BACT,KAAK,EAAE,CAAC;yBACT,CAAC;oBACJ,CAAC;oBAED,8CAA8C;oBAC9C,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC,cAAc,EAAE,CAAC;oBAEpD,IAAI,CAAC,QAAQ,EAAE,CAAC;wBACd,OAAO;4BACL,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,IAAI;4BACX,KAAK,EAAE,EAAE;4BACT,KAAK,EAAE,CAAC;yBACT,CAAC;oBACJ,CAAC;oBAED,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAY,EAAE,EAAE,CAAC,CAAC;wBAC5C,EAAE,EAAE,OAAO,CAAC,EAAE;wBACd,IAAI,EAAE,OAAO,CAAC,IAAI;wBAClB,WAAW,EAAE,OAAO,CAAC,WAAW,IAAI,YAAY;wBAChD,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,IAAI;wBACtC,aAAa,EAAE,OAAO,CAAC,aAAa,IAAI,OAAO,CAAC,KAAK,IAAI,IAAI;wBAC7D,SAAS,EAAE,OAAO,CAAC,SAAS,IAAI,SAAS,IAAI,IAAI;wBACjD,WAAW,EAAE,OAAO,CAAC,WAAW,IAAI,IAAI;wBACxC,QAAQ,EAAE,GAAG,OAAO,CAAC,IAAI,mBAAmB;wBAC5C,QAAQ,EAAE,OAAO,CAAC,IAAI;qBACvB,CAAC,CAAC,CAAC;oBAEJ,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,KAAK;wBACL,KAAK,EAAE,KAAK,CAAC,MAAM;qBACpB,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,6BAA6B,EAAE,KAAK,CAAC,CAAC;oBACtE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;wBACvC,KAAK,EAAE,EAAE;wBACT,KAAK,EAAE,CAAC;qBACT,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,0BAA0B;YAC1B,UAAU,EAAE,KAAK,EAAE,OAAY,EAAE,IAAwB,EAAE,EAAE;gBAC3D,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;gBAExB,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,qCAAqC,MAAM,EAAE,CAAC,CAAC;oBAE9E,yBAAyB;oBACzB,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,MAAM,EAAE,KAAK;4BACb,QAAQ,EAAE,IAAI;4BACd,WAAW,EAAE,EAAE;4BACf,eAAe,EAAE,CAAC;4BAClB,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,mBAAmB,MAAM,EAAE;yBACnC,CAAC;oBACJ,CAAC;oBAED,gCAAgC;oBAChC,MAAM,eAAe,GAAG,IAAI,CAAC,eAAe,IAAI,EAAE,CAAC;oBACnD,MAAM,cAAc,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,CAAC;oBAE9E,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBAChC,OAAO;4BACL,MAAM,EAAE,KAAK;4BACb,QAAQ,EAAE,IAAI,CAAC,IAAI;4BACnB,WAAW,EAAE,EAAE;4BACf,eAAe,EAAE,CAAC;4BAClB,OAAO,EACL,gGAAgG;4BAClG,KAAK,EAAE,IAAI;yBACZ,CAAC;oBACJ,CAAC;oBAED,0EAA0E;oBAC1E,MAAM,WAAW,GAAG,MAAM,OAAO,CAAC,GAAG,CACnC,cAAc,CAAC,GAAG,CAAC,KAAK,EAAE,CAAM,EAAE,EAAE;wBAClC,IAAI,WAAW,GAAG,CAAC,CAAC,YAAY,CAAC,CAAC,kBAAkB;wBACpD,IAAI,SAAS,GAAG,IAAI,CAAC;wBACrB,IAAI,aAAa,GAAG,IAAI,CAAC;wBAEzB,8DAA8D;wBAC9D,qEAAqE;wBACrE,IAAI,WAAW,IAAI,OAAO,WAAW,CAAC,cAAc,KAAK,UAAU,EAAE,CAAC;4BACpE,IAAI,CAAC;gCACH,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,sCAAsC,CAAC,CAAC,YAAY,SAAS,CAAC,CAAC,aAAa,EAAE,CAC7F,CAAC;gCACF,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC,cAAc,EAAE,CAAC;gCACpD,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,SAAS,QAAQ,EAAE,MAAM,IAAI,CAAC,qBAAqB,CAClE,CAAC;gCACF,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oCACpC,4CAA4C;oCAC5C,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,+BAA+B,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CACpF,CAAC;oCAEF,qEAAqE;oCACrE,0CAA0C;oCAC1C,MAAM,eAAe,GAAG,QAAQ,CAAC,IAAI,CACnC,CAAC,CAAM,EAAE,EAAE,CACT,CAAC,CAAC,IAAI,EAAE,EAAE,KAAK,CAAC,CAAC,YAAY;wCAC7B,CAAC,CAAC,CAAC,CAAC,aAAa,IAAI,CAAC,CAAC,WAAW,KAAK,CAAC,CAAC,aAAa,CAAC,CAC1D,CAAC;oCAEF,IAAI,eAAe,EAAE,CAAC;wCACpB,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,kBAAkB,eAAe,CAAC,IAAI,EAAE,CAAC,CAAC;wCACzE,WAAW,GAAG,eAAe,CAAC,IAAI,CAAC;wCACnC,SAAS,GAAG,oCAAoC,eAAe,CAAC,IAAI,EAAE,CAAC;wCACvE,aAAa;4CACX,eAAe,CAAC,cAAc,IAAI,eAAe,CAAC,KAAK,IAAI,IAAI,CAAC;oCACpE,CAAC;yCAAM,CAAC;wCACN,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,2CAA2C,CAAC,CAAC,YAAY,EAAE,CAC1E,CAAC;oCACJ,CAAC;gCACH,CAAC;4BACH,CAAC;4BAAC,OAAO,CAAM,EAAE,CAAC;gCAChB,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,0CAA0C,CAAC,CAAC,OAAO,EAAE,CACpE,CAAC;4BACJ,CAAC;wBACH,CAAC;6BAAM,CAAC;4BACN,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,+CAA+C,CAAC,CAAC;wBAClF,CAAC;wBAED,OAAO;4BACL,eAAe,EAAE,CAAC,CAAC,YAAY;4BAC/B,WAAW;4BACX,WAAW,EAAE,CAAC,CAAC,aAAa,IAAI,IAAI;4BACpC,SAAS,EAAE,CAAC,CAAC,SAAS,IAAI,IAAI;4BAC9B,SAAS;4BACT,aAAa;yBACd,CAAC;oBACJ,CAAC,CAAC,CACH,CAAC;oBAEF,2DAA2D;oBAC3D,MAAM,YAAY,GAAG;wBACnB,OAAO,EAAE,IAAI;wBACb,OAAO,EAAE,IAAI;wBACb,SAAS,EAAE,CAAC,WAAW,EAAE,cAAc,EAAE,eAAe,CAAC;wBACzD,kBAAkB,EAAE,IAAI;wBACxB,qBAAqB,EAAE,IAAI;qBAC5B,CAAC;oBAEF,OAAO;wBACL,MAAM,EAAE,IAAI;wBACZ,QAAQ,EAAE,IAAI,CAAC,IAAI;wBACnB,WAAW;wBACX,eAAe,EAAE,WAAW,CAAC,MAAM;wBACnC,YAAY;wBACZ,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,2BAA2B,EAAE,KAAK,CAAC,CAAC;oBACpE,OAAO;wBACL,MAAM,EAAE,KAAK;wBACb,QAAQ,EAAE,IAAI;wBACd,WAAW,EAAE,EAAE;wBACf,eAAe,EAAE,CAAC;wBAClB,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;qBACxC,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,0BAA0B;YAC1B,YAAY,EAAE,KAAK,IAAI,EAAE;gBACvB,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,0BAA0B,CAAC,CAAC;oBAE3D,iDAAiD;oBACjD,MAAM,SAAS,GAAG,MAAM,kBAAkB,EAAE,CAAC;oBAC7C,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,SAAS,SAAS,CAAC,MAAM,mBAAmB,CAAC,CAAC;oBAE7E,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBAC3B,OAAO;4BACL,SAAS,EAAE,KAAK;4BAChB,cAAc,EAAE,KAAK;4BACrB,OAAO,EAAE,IAAI;4BACb,WAAW,EAAE,IAAI;4BACjB,OAAO,EACL,6HAA6H;4BAC/H,KAAK,EAAE,IAAI;yBACZ,CAAC;oBACJ,CAAC;oBAED,2CAA2C;oBAC3C,MAAM,eAAe,GAAG,SAAS,CAAC,IAAI,CACpC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,SAAS,IAAI,CAAC,CAAC,IAAI,EAAE,WAAW,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CACrE,CAAC;oBACT,MAAM,cAAc,GAAG,SAAS,CAAC,IAAI,CACnC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,QAAQ,IAAI,CAAC,CAAC,IAAI,EAAE,WAAW,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CACnE,CAAC;oBAET,MAAM,aAAa,GAAG,eAAe;wBACnC,CAAC,CAAC;4BACE,aAAa,EAAE,IAAI;4BACnB,SAAS,EAAE,eAAe,CAAC,EAAE;4BAC7B,KAAK,EAAE,eAAe,CAAC,KAAK,IAAI,IAAI;yBACrC;wBACH,CAAC,CAAC;4BACE,aAAa,EAAE,KAAK;4BACpB,SAAS,EAAE,IAAqB;4BAChC,KAAK,EAAE,IAAqB;yBAC7B,CAAC;oBAEN,MAAM,iBAAiB,GAAG,cAAc;wBACtC,CAAC,CAAC;4BACE,aAAa,EAAE,IAAI;4BACnB,SAAS,EAAE,cAAc,CAAC,EAAE;4BAC5B,KAAK,EAAE,cAAc,CAAC,KAAK,IAAI,IAAI;yBACpC;wBACH,CAAC,CAAC;4BACE,aAAa,EAAE,KAAK;4BACpB,SAAS,EAAE,IAAqB;4BAChC,KAAK,EAAE,IAAqB;yBAC7B,CAAC;oBAEN,MAAM,WAAW,GAAG,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;oBAEzC,OAAO;wBACL,SAAS,EAAE,WAAW;wBACtB,cAAc,EAAE,IAAI;wBACpB,OAAO,EAAE,aAAa;wBACtB,WAAW,EAAE,iBAAiB;wBAC9B,OAAO,EAAE,WAAW;4BAClB,CAAC,CAAC,IAAI;4BACN,CAAC,CAAC,6FAA6F;wBACjG,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,kCAAkC,EAAE,KAAK,CAAC,CAAC;oBAC3E,OAAO;wBACL,SAAS,EAAE,KAAK;wBAChB,cAAc,EAAE,KAAK;wBACrB,OAAO,EAAE,IAAI;wBACb,WAAW,EAAE,IAAI;wBACjB,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;qBACxC,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,WAAW,EAAE,KAAK,EAAE,OAAY,EAAE,IAA0C,EAAE,EAAE;gBAC9E,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;gBAElC,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,8BAA8B,MAAM,SAAS,QAAQ,EAAE,CAAC,CAAC;oBAExF,WAAW;oBACX,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,QAAQ,EAAE,IAAI;4BACd,QAAQ;4BACR,OAAO,EAAE,EAAE;4BACX,KAAK,EAAE,CAAC;4BACR,KAAK,EAAE,mBAAmB,MAAM,EAAE;yBACnC,CAAC;oBACJ,CAAC;oBAED,yCAAyC;oBACzC,MAAM,SAAS,GAAG,MAAM,kBAAkB,EAAE,CAAC;oBAC7C,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBAC3B,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,QAAQ,EAAE,IAAI,CAAC,IAAI;4BACnB,QAAQ;4BACR,OAAO,EAAE,EAAE;4BACX,KAAK,EAAE,CAAC;4BACR,KAAK,EACH,sFAAsF;yBACzF,CAAC;oBACJ,CAAC;oBAED,2EAA2E;oBAC3E,MAAM,WAAW,GAA2B,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;oBAC1F,MAAM,UAAU,GAAG,WAAW,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC;oBACrD,MAAM,eAAe,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,UAAU,CAAC,CAAC;oBAExE,IAAI,CAAC,eAAe,EAAE,CAAC;wBACrB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,QAAQ,EAAE,IAAI,CAAC,IAAI;4BACnB,QAAQ;4BACR,OAAO,EAAE,EAAE;4BACX,KAAK,EAAE,CAAC;4BACR,KAAK,EAAE,aAAa,QAAQ,gCAAgC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;yBAC3G,CAAC;oBACJ,CAAC;oBAED,2EAA2E;oBAC3E,yFAAyF;oBACzF,oDAAoD;oBACpD,MAAM,MAAM,GAAG,MAAM,eAAe,CAClC,4BAA4B,EAC5B,mBAAmB,EACnB,MAAM,EACN,eAAe,CAAC,EAAE,EAClB,CAAC,CACF,CAAC;oBACF,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,oCAAoC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAC3E,CAAC;oBAEF,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;wBACjB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,QAAQ,EAAE,IAAI,CAAC,IAAI;4BACnB,QAAQ;4BACR,OAAO,EAAE,EAAE;4BACX,KAAK,EAAE,CAAC;4BACR,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,OAAO,IAAI,wBAAwB;yBACxD,CAAC;oBACJ,CAAC;oBAED,wDAAwD;oBACxD,IAAI,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC;oBAChC,IAAI,WAAW,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;wBAClF,6CAA6C;wBAC7C,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC;4BACtC,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC;wBACnC,CAAC;6BAAM,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,CAAC;4BAChD,WAAW,GAAG,WAAW,CAAC,SAAS,CAAC;wBACtC,CAAC;6BAAM,IAAI,WAAW,CAAC,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;4BAC7E,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC,SAAS,CAAC;wBAC7C,CAAC;oBACH,CAAC;oBAED,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;oBAC9D,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,eAAe,OAAO,CAAC,MAAM,UAAU,CAAC,CAAC;oBAExE,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,QAAQ,EAAE,IAAI,CAAC,IAAI;wBACnB,QAAQ;wBACR,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC;4BAChC,mFAAmF;4BACnF,kDAAkD;4BAClD,UAAU,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,UAAU,IAAI,CAAC,CAAC,QAAQ;4BAChD,SAAS,EAAE,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,OAAO;4BAC3E,IAAI,EACF,CAAC,CAAC,YAAY,EAAE,WAAW,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC,IAAI,EAAE,WAAW,IAAI,EAAE;4BACrF,UAAU,EAAE,CAAC,CAAC,YAAY,EAAE,IAAI;gCAC9B,CAAC,CAAC,GAAG,CAAC,CAAC,YAAY,CAAC,IAAI,QAAQ;gCAChC,CAAC,CAAC,CAAC,CAAC,UAAU,IAAI,IAAI,CAAC,MAAM;4BAC/B,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,YAAY,EAAE,QAAQ,IAAI,CAAC,CAAC,QAAQ,IAAI,EAAE,CAAC;yBACvE,CAAC,CAAC;wBACH,KAAK,EAAE,OAAO,CAAC,MAAM;wBACrB,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,2BAA2B,EAAE,KAAK,CAAC,CAAC;oBACpE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,QAAQ,EAAE,IAAI;wBACd,QAAQ;wBACR,OAAO,EAAE,EAAE;wBACX,KAAK,EAAE,CAAC;wBACR,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;qBACxC,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,0BAA0B;YAC1B,cAAc,EAAE,KAAK,EAAE,OAAY,EAAE,IAAwC,EAAE,EAAE;gBAC/E,MAAM,EAAE,MAAM,EAAE,KAAK,GAAG,EAAE,EAAE,GAAG,IAAI,CAAC;gBAEpC,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,mCAAmC,MAAM,EAAE,CAAC,CAAC;oBAE5E,+BAA+B;oBAC/B,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,QAAQ,EAAE,IAAI;4BACd,MAAM,EAAE,EAAE;4BACV,KAAK,EAAE,CAAC;4BACR,KAAK,EAAE,mBAAmB,MAAM,EAAE;yBACnC,CAAC;oBACJ,CAAC;oBAED,+CAA+C;oBAC/C,IAAI,CAAC,qBAAqB,IAAI,OAAO,qBAAqB,CAAC,SAAS,KAAK,UAAU,EAAE,CAAC;wBACpF,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,QAAQ,EAAE,IAAI,CAAC,IAAI;4BACnB,MAAM,EAAE,EAAE;4BACV,KAAK,EAAE,CAAC;4BACR,KAAK,EAAE,oCAAoC;yBAC5C,CAAC;oBACJ,CAAC;oBAED,MAAM,MAAM,GAAG,qBAAqB,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;oBACvD,MAAM,aAAa,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;oBAE7C,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,QAAQ,EAAE,IAAI,CAAC,IAAI;wBACnB,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC;4BACrC,iBAAiB,EAAE,CAAC,CAAC,iBAAiB,IAAI,IAAI;4BAC9C,SAAS,EAAE,CAAC,CAAC,SAAS;4BACtB,WAAW,EAAE,CAAC,CAAC,WAAW;4BAC1B,SAAS,EAAE,CAAC,CAAC,SAAS;4BACtB,MAAM,EAAE,CAAC,CAAC,MAAM,IAAI,IAAI;yBACzB,CAAC,CAAC;wBACH,KAAK,EAAE,aAAa,CAAC,MAAM;wBAC3B,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,+BAA+B,EAAE,KAAK,CAAC,CAAC;oBACxE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,QAAQ,EAAE,IAAI;wBACd,MAAM,EAAE,EAAE;wBACV,KAAK,EAAE,CAAC;wBACR,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;qBACxC,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,8DAA8D;YAC9D,cAAc,EAAE,KAAK,EAAE,OAAY,EAAE,IAA4C,EAAE,EAAE;gBACnF,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC;gBAE5C,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,8BAA8B,MAAM,eAAe,SAAS,EAAE,CAC7E,CAAC;oBAEF,qBAAqB;oBACrB,IAAI,SAAS,KAAK,MAAM,IAAI,SAAS,KAAK,MAAM,EAAE,CAAC;wBACjD,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,QAAQ,EAAE,IAAI;4BACd,SAAS;4BACT,KAAK,EAAE,EAAE;4BACT,QAAQ,EAAE,EAAE;4BACZ,OAAO,EAAE,EAAE;4BACX,YAAY,EAAE,CAAC;4BACf,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,8CAA8C;yBACtD,CAAC;oBACJ,CAAC;oBAED,WAAW;oBACX,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,QAAQ,EAAE,IAAI;4BACd,SAAS;4BACT,KAAK,EAAE,EAAE;4BACT,QAAQ,EAAE,EAAE;4BACZ,OAAO,EAAE,EAAE;4BACX,YAAY,EAAE,CAAC;4BACf,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,mBAAmB,MAAM,EAAE;yBACnC,CAAC;oBACJ,CAAC;oBAED,uBAAuB;oBACvB,MAAM,aAAa,GAAG,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,CAAC;oBACjF,IAAI,CAAC,aAAa,EAAE,CAAC;wBACnB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,QAAQ,EAAE,IAAI,CAAC,IAAI;4BACnB,SAAS;4BACT,KAAK,EAAE,EAAE;4BACT,QAAQ,EAAE,EAAE;4BACZ,OAAO,EAAE,EAAE;4BACX,YAAY,EAAE,CAAC;4BACf,OAAO,EAAE,IAAI;4BACb,KAAK,EACH,+EAA+E;yBAClF,CAAC;oBACJ,CAAC;oBAED,6BAA6B;oBAC7B,IACE,CAAC,qBAAqB;wBACtB,OAAO,qBAAqB,CAAC,iBAAiB,KAAK,UAAU,EAC7D,CAAC;wBACD,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,QAAQ,EAAE,IAAI,CAAC,IAAI;4BACnB,SAAS;4BACT,KAAK,EAAE,EAAE;4BACT,QAAQ,EAAE,EAAE;4BACZ,OAAO,EAAE,EAAE;4BACX,YAAY,EAAE,CAAC;4BACf,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,mCAAmC;yBAC3C,CAAC;oBACJ,CAAC;oBAED,gCAAgC;oBAChC,IAAI,WAAW,GAAG,aAAa,CAAC,YAAY,CAAC;oBAC7C,IAAI,aAAa,GAAG,EAAE,CAAC;oBACvB,IAAI,SAAS,GAAG,EAAE,CAAC;oBAEnB,IAAI,WAAW,IAAI,OAAO,WAAW,CAAC,cAAc,KAAK,UAAU,EAAE,CAAC;wBACpE,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC,cAAc,EAAE,CAAC;wBACpD,MAAM,eAAe,GAAG,QAAQ,EAAE,IAAI,CACpC,CAAC,CAAM,EAAE,EAAE,CACT,CAAC,CAAC,IAAI,EAAE,EAAE,KAAK,aAAa,CAAC,YAAY;4BACzC,CAAC,CAAC,aAAa,CAAC,aAAa,IAAI,CAAC,CAAC,WAAW,KAAK,aAAa,CAAC,aAAa,CAAC,CAClF,CAAC;wBACF,IAAI,eAAe,EAAE,CAAC;4BACpB,WAAW,GAAG,eAAe,CAAC,IAAI,CAAC;4BACnC,aAAa;gCACX,eAAe,CAAC,cAAc;oCAC9B,eAAe,CAAC,KAAK;oCACrB,GAAG,eAAe,CAAC,IAAI,eAAe,CAAC;4BACzC,SAAS,GAAG,eAAe,CAAC,EAAE,CAAC;wBACjC,CAAC;oBACH,CAAC;oBAED,IAAI,CAAC,aAAa,EAAE,CAAC;wBACnB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,QAAQ,EAAE,IAAI,CAAC,IAAI;4BACnB,SAAS;4BACT,KAAK,EAAE,EAAE;4BACT,QAAQ,EAAE,EAAE;4BACZ,OAAO,EAAE,EAAE;4BACX,YAAY,EAAE,CAAC;4BACf,OAAO,EAAE,IAAI;4BACb,KAAK,EACH,qFAAqF;yBACxF,CAAC;oBACJ,CAAC;oBAED,oDAAoD;oBACpD,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,mCAAmC,WAAW,EAAE,CAAC,CAAC;oBACjF,MAAM,aAAa,GAAG,MAAM,qBAAqB,CAAC,iBAAiB,CAAC;wBAClE,WAAW,EAAE;4BACX,mBAAmB,EAAE,WAAW;4BAChC,iBAAiB,EAAE,SAAS;4BAC5B,cAAc,EAAE,aAAa,CAAC,YAAY;4BAC1C,qBAAqB,EAAE,aAAa;4BACpC,WAAW,EAAE,IAAI,CAAC,EAAE;yBACrB;wBACD,SAAS,EAAE,SAA4B;wBACvC,cAAc,EAAE,KAAK;qBACtB,CAAC,CAAC;oBAEH,qBAAqB;oBACrB,MAAM,KAAK,GAAG,aAAa;yBACxB,MAAM,CACL,CAAC,CAAM,EAAE,EAAE,CACT,CAAC,CAAC,WAAW,KAAK,QAAQ;wBAC1B,CAAC,CAAC,WAAW,KAAK,QAAQ;wBAC1B,CAAC,CAAC,WAAW,KAAK,UAAU,CAC/B;yBACA,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC;wBAChB,IAAI,EAAE,CAAC,CAAC,IAAI;wBACZ,WAAW,EAAE,CAAC,CAAC,WAAW;wBAC1B,IAAI,EAAE,CAAC,CAAC,IAAI;wBACZ,IAAI,EAAE,CAAC,CAAC,IAAI;qBACb,CAAC,CAAC,CAAC;oBAEN,MAAM,QAAQ,GAAG,aAAa;yBAC3B,MAAM,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,QAAQ,CAAC;yBAC9C,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC;wBAChB,IAAI,EAAE,CAAC,CAAC,IAAI;wBACZ,WAAW,EAAE,CAAC,CAAC,WAAW;wBAC1B,IAAI,EAAE,CAAC,CAAC,IAAI;wBACZ,IAAI,EAAE,CAAC,CAAC,IAAI;qBACb,CAAC,CAAC,CAAC;oBAEN,MAAM,OAAO,GAAG,aAAa;yBAC1B,MAAM,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,QAAQ,CAAC;yBAC9C,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC;wBAChB,IAAI,EAAE,CAAC,CAAC,IAAI;wBACZ,WAAW,EAAE,CAAC,CAAC,WAAW;wBAC1B,IAAI,EAAE,CAAC,CAAC,IAAI;wBACZ,IAAI,EAAE,CAAC,CAAC,IAAI;qBACb,CAAC,CAAC,CAAC;oBAEN,MAAM,YAAY,GAAG,KAAK,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;oBACrE,MAAM,cAAc,GAAG,SAAS,KAAK,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC;oBAE5E,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,QAAQ,EAAE,IAAI,CAAC,IAAI;wBACnB,SAAS;wBACT,KAAK;wBACL,QAAQ;wBACR,OAAO;wBACP,YAAY;wBACZ,OAAO,EACL,YAAY,GAAG,CAAC;4BACd,CAAC,CAAC,GAAG,YAAY,qBAAqB,cAAc,MAAM,KAAK,CAAC,MAAM,WAAW,QAAQ,CAAC,MAAM,cAAc,OAAO,CAAC,MAAM,UAAU;4BACtI,CAAC,CAAC,wBAAwB,cAAc,GAAG;wBAC/C,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,+BAA+B,EAAE,KAAK,CAAC,CAAC;oBACxE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,QAAQ,EAAE,IAAI;wBACd,SAAS;wBACT,KAAK,EAAE,EAAE;wBACT,QAAQ,EAAE,EAAE;wBACZ,OAAO,EAAE,EAAE;wBACX,YAAY,EAAE,CAAC;wBACf,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;qBACxC,CAAC;gBACJ,CAAC;YACH,CAAC;SACF;QACD,QAAQ,EAAE;YACR,KAAK,EAAE,YAAY;YAEnB,UAAU,EAAE,KAAK,EACf,OAAY,EACZ,IAWC,EACD,EAAE;gBACF,+BAA+B;gBAC/B,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,kCAAkC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gBAEzF,MAAM,EACJ,IAAI,EACJ,UAAU,EACV,SAAS,GAAG,OAAO,EACnB,QAAQ,GAAG,OAAO,EAClB,eAAe,GAAG,OAAO,EACzB,eAAe,GAAG,UAAU,EAC5B,YAAY,GAAG,kBAAkB,EACjC,SAAS,GACV,GAAG,IAAI,CAAC,KAAK,CAAC;gBAEf,iCAAiC;gBACjC,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,0BAA0B,IAAI,gBAAgB,SAAS,uBAAuB,OAAO,SAAS,EAAE,CAC/G,CAAC;gBAEF,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,oBAAoB,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,oBAAoB,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAC5F,CAAC;oBAEF,qCAAqC;oBACrC,MAAM,QAAQ,GAAG,IAAI;yBAClB,WAAW,EAAE;yBACb,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC;yBAC3B,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;oBACzB,MAAM,UAAU,GAAG,GAAG,QAAQ,QAAQ,CAAC;oBAEvC,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;oBACzB,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;oBAC7B,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;oBACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,aAAa,EAAE,QAAQ,CAAC,CAAC;oBAElE,4EAA4E;oBAC5E,IAAI,SAAS,EAAE,CAAC;wBACd,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,mCAAmC,SAAS,EAAE,CAAC,CAAC;wBAE/E,yCAAyC;wBACzC,MAAM,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;wBACpC,MAAM,YAAY,GAAG,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;wBAC7C,MAAM,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,YAAY,EAAE,GAAG,SAAS,MAAM,CAAC,CAAC;wBAEnF,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,+BAA+B,gBAAgB,EAAE,CAAC,CAAC;wBAElF,0BAA0B;wBAC1B,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC,EAAE,CAAC;4BACrC,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,6BAA6B,gBAAgB,EAAE,CAAC,CAAC;4BACjF,OAAO;gCACL,OAAO,EAAE,KAAK;gCACd,KAAK,EAAE,wBAAwB,SAAS,oDAAoD;gCAC5F,MAAM,EAAE,IAAI;gCACZ,QAAQ,EAAE,IAAI;gCACd,UAAU,EAAE,IAAI;6BACjB,CAAC;wBACJ,CAAC;wBAED,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,yBAAyB,gBAAgB,EAAE,CAAC,CAAC;wBAE5E,kEAAkE;wBAClE,IAAI,aAAkB,CAAC;wBACvB,IAAI,CAAC;4BACH,MAAM,SAAS,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;4BAC7C,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,uCAAuC,CAAC,CAAC;4BAExE,MAAM,GAAG,GAAG,IAAI,SAAS,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,CAAC;4BAC5D,MAAM,OAAO,GAAG,MAAM,GAAG,CAAC,OAAO,EAAE,CAAC;4BACpC,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,gCAAgC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,CAC5E,CAAC;4BAEF,MAAM,QAAQ,GAAG,OAAO,CAAC,iBAAiB,CAAC;gCACzC,CAAC,CAAC,iBAAiB;gCACnB,CAAC,CAAC,sBAAsB,CAAC;4BAC3B,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,4BAA4B,QAAQ,EAAE,CAAC,CAAC;4BAEvE,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;4BAC3C,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;4BAClD,MAAM,GAAG,CAAC,KAAK,EAAE,CAAC;4BAClB,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,+BAA+B,EAC7C,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,CAChD,CAAC;wBACJ,CAAC;wBAAC,OAAO,QAAa,EAAE,CAAC;4BACvB,WAAW,CAAC,KAAK,CACf,IAAI,UAAU,mCAAmC,QAAQ,CAAC,OAAO,EAAE,EACnE,QAAQ,CACT,CAAC;4BACF,OAAO;gCACL,OAAO,EAAE,KAAK;gCACd,KAAK,EAAE,sCAAsC,QAAQ,CAAC,OAAO,EAAE;gCAC/D,MAAM,EAAE,IAAI;gCACZ,QAAQ,EAAE,IAAI;gCACd,UAAU,EAAE,IAAI;6BACjB,CAAC;wBACJ,CAAC;wBAED,wBAAwB;wBACxB,MAAM,cAAc,GAAQ;4BAC1B,QAAQ,EAAE,IAAI;4BACd,UAAU,EAAE,UAAU;4BACtB,QAAQ,EAAE,QAAQ;4BAClB,GAAG,EAAE,gBAAgB;4BACrB,UAAU,EAAE;gCACV,IAAI,EAAE,iBAAiB;gCACvB,OAAO,EAAE,aAAa;6BACvB;4BACD,WAAW,EAAE,aAAa,CAAC,WAAW,IAAI,UAAU;4BACpD,SAAS,EAAE,SAAS;yBACrB,CAAC;wBAEF,oDAAoD;wBACpD,IAAI,aAAa,CAAC,QAAQ,EAAE,CAAC;4BAC3B,sBAAsB;4BACtB,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,IAAI,CAC3D,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,KAAK,CACtB,CAAC;4BACT,IAAI,UAAU,EAAE,CAAC;gCACf,cAAc,CAAC,UAAU,GAAG,UAAU,CAAC,OAAO,CAAC;4BACjD,CAAC;4BAED,mBAAmB;4BACnB,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,IAAI,CAC1D,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,UAAU,IAAI,CAAC,CAAC,IAAI,KAAK,IAAI,CAC9C,CAAC;4BACT,IAAI,SAAS,EAAE,CAAC;gCACd,cAAc,CAAC,QAAQ,GAAG,GAAG,SAAS,CAAC,IAAI,IAAI,SAAS,CAAC,OAAO,EAAE,CAAC;4BACrE,CAAC;4BAED,qBAAqB;4BACrB,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,IAAI,CAC3D,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,IAAI,CAAC,CAAC,IAAI,KAAK,KAAK,CAC3C,CAAC;4BACT,IAAI,UAAU,EAAE,CAAC;gCACf,cAAc,CAAC,SAAS,GAAG,GAAG,UAAU,CAAC,IAAI,IAAI,UAAU,CAAC,OAAO,EAAE,CAAC;4BACxE,CAAC;wBACH,CAAC;6BAAM,IAAI,aAAa,CAAC,UAAU,EAAE,CAAC;4BACpC,cAAc,CAAC,UAAU,GAAG,aAAa,CAAC,UAAU,CAAC;wBACvD,CAAC;wBAED,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,6BAA6B,EAC3C,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,CACjD,CAAC;wBAEF,IAAI,CAAC,iBAAiB,EAAE,CAAC;4BACvB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,uCAAuC,CAAC,CAAC;4BACzE,OAAO;gCACL,OAAO,EAAE,KAAK;gCACd,KAAK,EAAE,8BAA8B;gCACrC,MAAM,EAAE,IAAI;gCACZ,QAAQ,EAAE,IAAI;gCACd,UAAU,EAAE,IAAI;6BACjB,CAAC;wBACJ,CAAC;wBAED,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,sCAAsC,CAAC,CAAC;wBAEvE,qDAAqD;wBACrD,MAAM,YAAY,GAAG,MAAM,iBAAiB,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;wBAEjE,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,kBAAkB,EAChC,IAAI,CAAC,SAAS,CAAC,YAAY,IAAI,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,CACzD,CAAC;wBAEF,IAAI,YAAY,IAAI,YAAY,CAAC,EAAE,EAAE,CAAC;4BACpC,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,+CAA+C,IAAI,KAAK,YAAY,CAAC,EAAE,GAAG,CACzF,CAAC;4BACF,OAAO;gCACL,OAAO,EAAE,IAAI;gCACb,KAAK,EAAE,IAAI;gCACX,MAAM,EAAE,YAAY,CAAC,EAAE;gCACvB,QAAQ,EAAE,IAAI;gCACd,UAAU,EAAE,UAAU;6BACvB,CAAC;wBACJ,CAAC;6BAAM,CAAC;4BACN,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,wCAAwC,CAAC,CAAC;4BACzE,OAAO;gCACL,OAAO,EAAE,IAAI;gCACb,KAAK,EAAE,IAAI;gCACX,MAAM,EAAE,IAAI;gCACZ,QAAQ,EAAE,IAAI;gCACd,UAAU,EAAE,UAAU;6BACvB,CAAC;wBACJ,CAAC;oBACH,CAAC;oBAED,qCAAqC;oBACrC,MAAM,WAAW,GAAQ;wBACvB,QAAQ,EAAE,IAAI;wBACd,UAAU,EAAE,UAAU;wBACtB,QAAQ,EAAE,QAAQ;wBAClB,SAAS,EAAE,SAAS;wBACpB,QAAQ,EAAE,QAAQ;qBACnB,CAAC;oBAEF,IAAI,UAAU,EAAE,CAAC;wBACf,WAAW,CAAC,UAAU,GAAG,UAAU,CAAC;oBACtC,CAAC;oBAED,MAAM,aAAa,GAAG;wBACpB,aAAa,EAAE,eAAe;wBAC9B,aAAa,EAAE,eAAe;wBAC9B,UAAU,EAAE,YAAY;qBACzB,CAAC;oBAEF,MAAM,IAAI,GAAG,MAAM,cAAc,CAAC,OAAO,CAAC;wBACxC,WAAW;wBACX,aAAa;wBACb,QAAQ,EAAE,KAAK;qBAChB,CAAC,CAAC;oBAEH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,gCAAgC,IAAI,KAAK,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;oBAEpF,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,MAAM,EAAE,IAAI,CAAC,EAAE;wBACf,QAAQ,EAAE,IAAI;wBACd,UAAU,EAAE,UAAU;qBACvB,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,0BAA0B,EAAE,KAAK,CAAC,CAAC;oBACnE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;wBACvC,MAAM,EAAE,IAAI;wBACZ,QAAQ,EAAE,IAAI;wBACd,UAAU,EAAE,IAAI;qBACjB,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,UAAU,EAAE,KAAK,EACf,OAAY,EACZ,IAA4E,EAC5E,EAAE;gBACF,MAAM,EAAE,EAAE,EAAE,UAAU,GAAG,IAAI,EAAE,WAAW,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;gBAEjE,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,oBAAoB,EAAE,EAAE,CAAC,CAAC;oBAEzD,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;oBAClC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,mBAAmB,EAAE,EAAE;4BAC9B,MAAM,EAAE,EAAE;yBACX,CAAC;oBACJ,CAAC;oBAED,MAAM,iBAAiB,CAAC,UAAU,CAAC;wBACjC,IAAI;wBACJ,UAAU;wBACV,WAAW;qBACZ,CAAC,CAAC;oBAEH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,gCAAgC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;oBAE5E,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,MAAM,EAAE,EAAE;qBACX,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,0BAA0B,EAAE,KAAK,CAAC,CAAC;oBACnE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;wBACvC,MAAM,EAAE,EAAE;qBACX,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,WAAW,EAAE,KAAK,EAAE,OAAY,EAAE,IAA6C,EAAE,EAAE;gBACjF,MAAM,EAAE,GAAG,EAAE,UAAU,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC;gBAExC,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,cAAc,GAAG,CAAC,MAAM,QAAQ,CAAC,CAAC;oBAEjE,MAAM,iBAAiB,CAAC,WAAW,CAAC;wBAClC,OAAO,EAAE,GAAG;wBACZ,UAAU;wBACV,WAAW,EAAE,IAAI;qBAClB,CAAC,CAAC;oBAEH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,0BAA0B,GAAG,CAAC,MAAM,QAAQ,CAAC,CAAC;oBAE7E,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC;qBACtB,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,2BAA2B,EAAE,KAAK,CAAC,CAAC;oBACpE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;wBACvC,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC;qBACtB,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,QAAQ,EAAE,KAAK,EAAE,OAAY,EAAE,IAAkD,EAAE,EAAE;gBACnF,MAAM,EAAE,MAAM,EAAE,IAAI,GAAG,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;gBAE1C,IAAI,CAAC;oBACH,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,mBAAmB,MAAM,EAAE;4BAClC,GAAG,EAAE,IAAI;yBACV,CAAC;oBACJ,CAAC;oBAED,2BAA2B;oBAC3B,MAAM,MAAM,GAAG,MAAM,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;oBAC5D,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;wBACzB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,SAAS,IAAI,CAAC,IAAI,uDAAuD;4BAChF,GAAG,EAAE,IAAI;yBACV,CAAC;oBACJ,CAAC;oBAED,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC;oBACnD,MAAM,GAAG,GAAG,GAAG,QAAQ,MAAM,IAAI,CAAC,MAAM,GAAG,IAAI,EAAE,CAAC;oBAElD,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,8BAA8B,GAAG,EAAE,CAAC,CAAC;oBAEpE,IAAI,cAAc,EAAE,CAAC;wBACnB,MAAM,cAAc,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;oBAC1C,CAAC;yBAAM,CAAC;wBACN,iCAAiC;wBACjC,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;wBACtC,MAAM,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;oBAChC,CAAC;oBAED,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,GAAG;qBACJ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,wBAAwB,EAAE,KAAK,CAAC,CAAC;oBACjE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;wBACvC,GAAG,EAAE,IAAI;qBACV,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,SAAS,EAAE,KAAK,EAAE,OAAY,EAAE,IAAoD,EAAE,EAAE;gBACtF,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;gBAEvC,IAAI,CAAC;oBACH,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,mBAAmB,MAAM,EAAE;4BAClC,SAAS,EAAE,IAAI;4BACf,WAAW,EAAE,IAAI;4BACjB,aAAa,EAAE,IAAI;yBACpB,CAAC;oBACJ,CAAC;oBAED,yDAAyD;oBACzD,MAAM,MAAM,GAAG,MAAM,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;oBAC5D,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;wBACzB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,SAAS,IAAI,CAAC,IAAI,6CAA6C;4BACtE,SAAS,EAAE,IAAI;4BACf,WAAW,EAAE,IAAI;4BACjB,aAAa,EAAE,IAAI;yBACpB,CAAC;oBACJ,CAAC;oBAED,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,kBAAkB,IAAI,CAAC,IAAI,OAAO,OAAO,EAAE,CAAC,CAAC;oBAE5E,MAAM,OAAO,GAAG,MAAM,gBAAgB,CAAC,SAAS,CAAC;wBAC/C,IAAI;wBACJ,WAAW,EAAE,OAAO;qBACrB,CAAC,CAAC;oBAEH,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,+BAA+B,OAAO,CAAC,IAAI,KAAK,OAAO,CAAC,EAAE,GAAG,CAC5E,CAAC;oBAEF,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,SAAS,EAAE,OAAO,CAAC,EAAE;wBACrB,WAAW,EAAE,OAAO,CAAC,IAAI;wBACzB,aAAa,EAAE,OAAO,CAAC,MAAM;qBAC9B,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,yBAAyB,EAAE,KAAK,CAAC,CAAC;oBAClE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;wBACvC,SAAS,EAAE,IAAI;wBACf,WAAW,EAAE,IAAI;wBACjB,aAAa,EAAE,IAAI;qBACpB,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,UAAU,EAAE,KAAK,EACf,OAAY,EACZ,IAAwD,EACxD,EAAE;gBACF,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;gBAC1C,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;gBACzB,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;gBAE7B,IAAI,CAAC;oBACH,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,mBAAmB,MAAM,EAAE;4BAClC,UAAU,EAAE,IAAI;yBACjB,CAAC;oBACJ,CAAC;oBAED,wDAAwD;oBACxD,MAAM,MAAM,GAAG,MAAM,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;oBAC5D,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;wBACzB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,SAAS,IAAI,CAAC,IAAI,8CAA8C;4BACvE,UAAU,EAAE,IAAI;yBACjB,CAAC;oBACJ,CAAC;oBAED,8BAA8B;oBAC9B,MAAM,SAAS,GAAG,UAAU,IAAI,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,WAAW,CAAC,CAAC;oBACrE,MAAM,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;oBAC9E,MAAM,QAAQ,GAAG,GAAG,IAAI,CAAC,IAAI,IAAI,SAAS,MAAM,CAAC;oBACjD,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;oBAEhD,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,oBAAoB,IAAI,CAAC,IAAI,OAAO,QAAQ,EAAE,CAAC,CAAC;oBAE/E,qDAAqD;oBACrD,MAAM,mBAAmB,GAAG,+BAA+B,CAAC;oBAE5D,MAAM,iBAAiB,CAAC,UAAU,CAAC;wBACjC,IAAI;wBACJ,UAAU,EAAE,QAAQ;wBACpB,MAAM,EAAE,mBAAmB;qBAC5B,CAAC,CAAC;oBAEH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,oCAAoC,QAAQ,EAAE,CAAC,CAAC;oBAE/E,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,UAAU,EAAE,QAAQ;qBACrB,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,0BAA0B,EAAE,KAAK,CAAC,CAAC;oBACnE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;wBACvC,UAAU,EAAE,IAAI;qBACjB,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,aAAa,EAAE,KAAK,EAAE,OAAY,EAAE,IAAiD,EAAE,EAAE;gBACvF,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;gBAEpC,IAAI,CAAC;oBACH,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,mBAAmB,MAAM,EAAE;4BAClC,aAAa,EAAE,IAAI;yBACpB,CAAC;oBACJ,CAAC;oBAED,wDAAwD;oBACxD,MAAM,MAAM,GAAG,MAAM,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;oBAC5D,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;wBACzB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,SAAS,IAAI,CAAC,IAAI,yDAAyD;4BAClF,aAAa,EAAE,IAAI;yBACpB,CAAC;oBACJ,CAAC;oBAED,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,iBAAiB,IAAI,CAAC,IAAI,kBAAkB,IAAI,EAAE,CAAC,CAAC;oBAEnF,qDAAqD;oBACrD,MAAM,aAAa,GAAG,+BAA+B,CAAC;oBAEtD,MAAM,iBAAiB,CAAC,aAAa,CAAC;wBACpC,IAAI;wBACJ,MAAM;wBACN,MAAM,EAAE,aAAa;qBACtB,CAAC,CAAC;oBAEH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,mCAAmC,IAAI,EAAE,CAAC,CAAC;oBAE1E,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,aAAa,EAAE,IAAI;qBACpB,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,6BAA6B,EAAE,KAAK,CAAC,CAAC;oBACtE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;wBACvC,aAAa,EAAE,IAAI;qBACpB,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,uCAAuC;YACvC,cAAc,EAAE,KAAK,EACnB,OAAY,EACZ,IAAwD,EACxD,EAAE;gBACF,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;gBAC1C,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;gBACzB,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;gBAEnC,IAAI,CAAC;oBACH,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,mBAAmB,MAAM,EAAE;4BAClC,UAAU,EAAE,IAAI;yBACjB,CAAC;oBACJ,CAAC;oBAED,yDAAyD;oBACzD,MAAM,MAAM,GAAG,MAAM,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;oBAC5D,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;wBACzB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,SAAS,IAAI,CAAC,IAAI,uDAAuD;4BAChF,UAAU,EAAE,IAAI;yBACjB,CAAC;oBACJ,CAAC;oBAED,6CAA6C;oBAC7C,MAAM,WAAW,GAAG,UAAU,CAAC,IAAI,CACjC,EAAE,CAAC,OAAO,EAAE,EACZ,WAAW,EACX,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC,MAAM,CAC/C,CAAC;oBACF,MAAM,SAAS,GAAG,UAAU,IAAI,WAAW,CAAC;oBAE5C,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,4BAA4B,IAAI,CAAC,IAAI,OAAO,SAAS,EAAE,CAAC,CAAC;oBAExF,mEAAmE;oBACnE,IAAI,CAAC,YAAY,EAAE,CAAC;wBAClB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,gCAAgC;4BACvC,UAAU,EAAE,IAAI;yBACjB,CAAC;oBACJ,CAAC;oBAED,MAAM,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;oBAEzC,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,wCAAwC,SAAS,EAAE,CAAC,CAAC;oBAEpF,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,UAAU,EAAE,SAAS;qBACtB,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,8BAA8B,EAAE,KAAK,CAAC,CAAC;oBACvE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;wBACvC,UAAU,EAAE,IAAI;qBACjB,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,cAAc,EAAE,KAAK,EACnB,OAAY,EACZ,IAAoD,EACpD,EAAE;gBACF,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;gBACvC,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;gBAEzB,IAAI,CAAC;oBACH,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,mBAAmB,MAAM,EAAE;yBACnC,CAAC;oBACJ,CAAC;oBAED,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;wBAC5B,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,uBAAuB,OAAO,EAAE;yBACxC,CAAC;oBACJ,CAAC;oBAED,yDAAyD;oBACzD,MAAM,MAAM,GAAG,MAAM,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;oBAC5D,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;wBACzB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,SAAS,IAAI,CAAC,IAAI,uDAAuD;yBACjF,CAAC;oBACJ,CAAC;oBAED,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,4BAA4B,IAAI,CAAC,IAAI,SAAS,OAAO,EAAE,CAAC,CAAC;oBAExF,qEAAqE;oBACrE,IAAI,CAAC,oBAAoB,EAAE,CAAC;wBAC1B,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,uCAAuC;yBAC/C,CAAC;oBACJ,CAAC;oBAED,MAAM,oBAAoB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;oBAE1C,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,0CAA0C,OAAO,EAAE,CAAC,CAAC;oBAEpF,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,8BAA8B,EAAE,KAAK,CAAC,CAAC;oBACvE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;qBACxC,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,WAAW,EAAE,KAAK,EAAE,OAAY,EAAE,IAAmC,EAAE,EAAE;gBACvE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;gBAE9B,IAAI,CAAC;oBACH,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,mBAAmB,MAAM,EAAE;yBACnC,CAAC;oBACJ,CAAC;oBAED,yDAAyD;oBACzD,MAAM,MAAM,GAAG,MAAM,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;oBAC5D,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;wBACzB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,SAAS,IAAI,CAAC,IAAI,oDAAoD;yBAC9E,CAAC;oBACJ,CAAC;oBAED,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,yBAAyB,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;oBAErE,IAAI,OAAO,EAAE,CAAC;wBACZ,MAAM,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBAC3B,CAAC;yBAAM,CAAC;wBACN,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,+BAA+B;yBACvC,CAAC;oBACJ,CAAC;oBAED,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,2BAA2B,EAAE,KAAK,CAAC,CAAC;oBACpE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;qBACxC,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,QAAQ,EAAE,KAAK,EAAE,OAAY,EAAE,IAAmC,EAAE,EAAE;gBACpE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;gBAE9B,IAAI,CAAC;oBACH,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,mBAAmB,MAAM,EAAE;yBACnC,CAAC;oBACJ,CAAC;oBAED,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,sBAAsB,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;oBAElE,IAAI,QAAQ,EAAE,CAAC;wBACb,MAAM,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;oBACjC,CAAC;yBAAM,CAAC;wBACN,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,wCAAwC;yBAChD,CAAC;oBACJ,CAAC;oBAED,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,wBAAwB,EAAE,KAAK,CAAC,CAAC;oBACjE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;qBACxC,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,aAAa,EAAE,KAAK,EAAE,OAAY,EAAE,IAAoD,EAAE,EAAE;gBAC1F,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;gBAEvC,IAAI,CAAC;oBACH,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,mBAAmB,MAAM,EAAE;4BAClC,OAAO,EAAE,IAAI;yBACd,CAAC;oBACJ,CAAC;oBAED,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,cAAc,IAAI,CAAC,IAAI,OAAO,OAAO,EAAE,CAAC,CAAC;oBAExE,gCAAgC;oBAChC,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC;oBACpB,MAAM,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;oBAErD,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,mCAAmC,OAAO,EAAE,CAAC,CAAC;oBAE7E,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,OAAO;qBACR,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,0BAA0B,EAAE,KAAK,CAAC,CAAC;oBACnE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;wBACvC,OAAO,EAAE,IAAI;qBACd,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,gBAAgB,EAAE,KAAK,EACrB,OAAY,EACZ,IAAuD,EACvD,EAAE;gBACF,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;gBAE1C,IAAI,CAAC;oBACH,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,mBAAmB,MAAM,EAAE;4BAClC,UAAU,EAAE,IAAI;yBACjB,CAAC;oBACJ,CAAC;oBAED,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,8BAA8B,IAAI,CAAC,IAAI,OAAO,UAAU,EAAE,CACzE,CAAC;oBAEF,IAAI,eAAe,EAAE,CAAC;wBACpB,MAAM,eAAe,CAAC,WAAW,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;oBAC7D,CAAC;yBAAM,CAAC;wBACN,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,wCAAwC;4BAC/C,UAAU,EAAE,IAAI;yBACjB,CAAC;oBACJ,CAAC;oBAED,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,0CAA0C,UAAU,EAAE,CAAC,CAAC;oBAEvF,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,UAAU;qBACX,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,iCAAiC,EAAE,KAAK,CAAC,CAAC;oBAC1E,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;wBACvC,UAAU,EAAE,IAAI;qBACjB,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,UAAU,EAAE,KAAK,EAAE,OAAY,EAAE,IAAuD,EAAE,EAAE;gBAC1F,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;gBACzC,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;gBAEzB,IAAI,CAAC;oBACH,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;wBAC5B,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,uBAAuB,OAAO,EAAE;4BACvC,MAAM,EAAE,IAAI;4BACZ,QAAQ,EAAE,IAAI;yBACf,CAAC;oBACJ,CAAC;oBAED,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,yBAAyB,OAAO,EAAE,CAAC,CAAC;oBAEnE,IAAI,CAAC,iBAAiB,EAAE,CAAC;wBACvB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,mCAAmC;4BAC1C,MAAM,EAAE,IAAI;4BACZ,QAAQ,EAAE,IAAI;yBACf,CAAC;oBACJ,CAAC;oBAED,MAAM,MAAM,GAAG,MAAM,iBAAiB,CAAC,GAAG,CAAC;wBACzC,OAAO;wBACP,QAAQ,EAAE,QAAQ,IAAI,SAAS;qBAChC,CAAC,CAAC;oBAEH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,iCAAiC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;oBAE/E,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,MAAM,EAAE,MAAM,CAAC,EAAE;wBACjB,QAAQ,EAAE,MAAM,CAAC,IAAI;qBACtB,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,0BAA0B,EAAE,KAAK,CAAC,CAAC;oBACnE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;wBACvC,MAAM,EAAE,IAAI;wBACZ,QAAQ,EAAE,IAAI;qBACf,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,0CAA0C;YAC1C,YAAY,EAAE,KAAK,EAAE,OAAY,EAAE,IAAqD,EAAE,EAAE;gBAC1F,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;gBAEvC,IAAI,CAAC;oBACH,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,mBAAmB,MAAM,EAAE;4BAClC,OAAO,EAAE,IAAI;yBACd,CAAC;oBACJ,CAAC;oBAED,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,WAAW,eAAe,IAAI,CAAC,IAAI,EAAE,CAChF,CAAC;oBAEF,2CAA2C;oBAC3C,MAAM,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC,CAAC;oBAE9D,uDAAuD;oBACvD,MAAM,MAAM,GAAG,MAAM,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;oBAC5D,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;wBACzB,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,0CAA0C,CAAC,CAAC;wBAC3E,MAAM,kBAAkB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;oBACzC,CAAC;oBAED,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,kBAAkB,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,SAAS,CAC1E,CAAC;oBAEF,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,OAAO;qBACR,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,4BAA4B,EAAE,KAAK,CAAC,CAAC;oBACrE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;wBACvC,OAAO,EAAE,IAAI;qBACd,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,WAAW,EAAE,KAAK,EAChB,OAAY,EACZ,IAAqE,EACrE,EAAE;gBACF,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,KAAK,EAAE,KAAK,GAAG,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;gBAC5D,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;gBACzB,MAAM,UAAU,GAAG,EAAE,CAAC,QAAQ,CAAC;gBAC/B,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;gBAEnC,wCAAwC;gBACxC,MAAM,UAAU,GAAG,KAAK,EAAE,QAAgB,EAAoB,EAAE;oBAC9D,IAAI,CAAC;wBACH,MAAM,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;wBAClC,OAAO,IAAI,CAAC;oBACd,CAAC;oBAAC,MAAM,CAAC;wBACP,OAAO,KAAK,CAAC;oBACf,CAAC;gBACH,CAAC,CAAC;gBAEF,wCAAwC;gBACxC,MAAM,aAAa,GAAG,KAAK,EAAE,QAAgB,EAAE,QAAgB,EAAmB,EAAE;oBAClF,IAAI,CAAC;wBACH,MAAM,OAAO,GAAG,MAAM,UAAU,CAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;wBAC7D,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;wBACrC,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,SAAS,CAAC;oBAC3D,CAAC;oBAAC,MAAM,CAAC;wBACP,OAAO,EAAE,CAAC;oBACZ,CAAC;gBACH,CAAC,CAAC;gBAEF,IAAI,CAAC;oBACH,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,mBAAmB,MAAM,EAAE;4BAClC,IAAI,EAAE,EAAE;yBACT,CAAC;oBACJ,CAAC;oBAED,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,aAAa,OAAO,aAAa,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;oBAE7E,MAAM,IAAI,GAA2D,EAAE,CAAC;oBACxE,MAAM,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;oBAEnD,MAAM,QAAQ,GAA6B;wBACzC,GAAG,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC;wBACvB,KAAK,EAAE,CAAC,OAAO,CAAC;wBAChB,KAAK,EAAE,CAAC,OAAO,CAAC;wBAChB,GAAG,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC;qBAC1C,CAAC;oBAEF,MAAM,UAAU,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,QAAQ,CAAC,GAAG,CAAC;oBAErD,KAAK,MAAM,OAAO,IAAI,UAAU,EAAE,CAAC;wBACjC,kCAAkC;wBAClC,KAAK,MAAM,MAAM,IAAI,CAAC,WAAW,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,CAAC;4BACzD,MAAM,OAAO,GAAG,UAAU,CAAC,IAAI,CAC7B,OAAO,EACP,GAAG,OAAO,GAAG,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,MAAM,EAAE,CACrD,CAAC;4BACF,MAAM,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,OAAO,GAAG,MAAM,EAAE,CAAC,CAAC;4BAEnE,IAAI,SAAS,GAAkB,IAAI,CAAC;4BACpC,IAAI,MAAM,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;gCAC9B,SAAS,GAAG,OAAO,CAAC;4BACtB,CAAC;iCAAM,IAAI,MAAM,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;gCACxC,SAAS,GAAG,UAAU,CAAC;4BACzB,CAAC;4BAED,IAAI,SAAS,EAAE,CAAC;gCACd,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;gCACtD,IAAI,OAAO,EAAE,CAAC;oCACZ,IAAI,CAAC,IAAI,CAAC;wCACR,IAAI,EAAE,OAAO;wCACb,OAAO;wCACP,IAAI,EAAE,SAAS;qCAChB,CAAC,CAAC;gCACL,CAAC;4BACH,CAAC;wBACH,CAAC;oBACH,CAAC;oBAED,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBACtB,4BAA4B;wBAC5B,IAAI,MAAM,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;4BAC9B,MAAM,OAAO,GAAG,MAAM,UAAU,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;4BAC3E,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;gCAC5B,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;oCACxB,MAAM,MAAM,GAAG,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;oCACpD,MAAM,UAAU,GAAG,MAAM,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oCACpD,KAAK,MAAM,OAAO,IAAI,UAAU,EAAE,CAAC;wCACjC,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;4CAC7B,MAAM,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;4CACjD,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;4CACpD,IAAI,OAAO,EAAE,CAAC;gDACZ,IAAI,CAAC,IAAI,CAAC;oDACR,IAAI,EAAE,KAAK,CAAC,IAAI;oDAChB,OAAO;oDACP,IAAI,EAAE,OAAO;iDACd,CAAC,CAAC;4CACL,CAAC;wCACH,CAAC;oCACH,CAAC;gCACH,CAAC;qCAAM,IAAI,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;oCACvC,MAAM,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;oCACrD,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;oCACpD,IAAI,OAAO,EAAE,CAAC;wCACZ,IAAI,CAAC,IAAI,CAAC;4CACR,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;4CACpC,OAAO;4CACP,IAAI,EAAE,OAAO;yCACd,CAAC,CAAC;oCACL,CAAC;gCACH,CAAC;4BACH,CAAC;wBACH,CAAC;oBACH,CAAC;oBAED,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,IAAI;qBACL,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,uBAAuB,EAAE,KAAK,CAAC,CAAC;oBAChE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;wBACvC,IAAI,EAAE,EAAE;qBACT,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,mCAAmC;YACnC,YAAY,EAAE,KAAK,EACjB,OAAY,EACZ,IAAyD,EACzD,EAAE;gBACF,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC;gBAExC,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,8BAA8B,MAAM,OAAO,QAAQ,EAAE,CAAC,CAAC;oBAEtF,WAAW;oBACX,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,UAAU,EAAE,IAAI;4BAChB,SAAS,EAAE,IAAI;4BACf,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,mBAAmB,MAAM,EAAE;yBACnC,CAAC;oBACJ,CAAC;oBAED,yCAAyC;oBACzC,MAAM,SAAS,GAAG,MAAM,kBAAkB,EAAE,CAAC;oBAC7C,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBAC3B,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,UAAU,EAAE,IAAI;4BAChB,SAAS,EAAE,IAAI;4BACf,OAAO,EAAE,IAAI;4BACb,KAAK,EACH,sFAAsF;yBACzF,CAAC;oBACJ,CAAC;oBAED,2EAA2E;oBAC3E,MAAM,WAAW,GAA2B,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;oBAC1F,MAAM,UAAU,GAAG,WAAW,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC;oBACrD,MAAM,eAAe,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,UAAU,CAAC,CAAC;oBAExE,IAAI,CAAC,eAAe,EAAE,CAAC;wBACrB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,UAAU,EAAE,IAAI;4BAChB,SAAS,EAAE,IAAI;4BACf,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,aAAa,QAAQ,gCAAgC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;yBAC3G,CAAC;oBACJ,CAAC;oBAED,iDAAiD;oBACjD,yFAAyF;oBACzF,MAAM,iBAAiB,GAA2B,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;oBAC1F,MAAM,gBAAgB,GAAG,iBAAiB,CAAC,eAAe,CAAC,EAAE,CAAC,IAAI,eAAe,CAAC,EAAE,CAAC;oBACrF,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,+BAA+B,gBAAgB,UAAU,eAAe,CAAC,EAAE,GAAG,CAC7F,CAAC;oBAEF,iEAAiE;oBACjE,MAAM,WAAW,GAAG,IAAI,IAAI,wBAAwB,CAAC;oBACrD,MAAM,MAAM,GAAG,MAAM,eAAe,CAClC,qBAAqB,EACrB,kBAAkB,EAClB,MAAM,EACN,gBAAgB,EAChB,WAAW,CACZ,CAAC;oBACF,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,wBAAwB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;oBAEjF,gCAAgC;oBAChC,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;wBACjB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,UAAU,EAAE,IAAI;4BAChB,SAAS,EAAE,IAAI;4BACf,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,OAAO,IAAI,wBAAwB;yBACxD,CAAC;oBACJ,CAAC;oBAED,yEAAyE;oBACzE,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC;oBAEnC,+EAA+E;oBAC/E,IAAI,YAAY,EAAE,KAAK,EAAE,CAAC;wBACxB,MAAM,QAAQ,GACZ,YAAY,CAAC,KAAK,CAAC,OAAO,IAAI,YAAY,CAAC,KAAK,CAAC,QAAQ,EAAE,OAAO,IAAI,eAAe,CAAC;wBACxF,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,UAAU,EAAE,IAAI;4BAChB,SAAS,EAAE,IAAI;4BACf,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,QAAQ;yBAChB,CAAC;oBACJ,CAAC;oBAED,qEAAqE;oBACrE,IAAI,UAAU,GAAG,YAAY,EAAE,UAAU,IAAI,YAAY,EAAE,EAAE,CAAC;oBAC9D,IAAI,CAAC,UAAU,IAAI,YAAY,EAAE,MAAM,EAAE,CAAC;wBACxC,UAAU,GAAG,YAAY,CAAC,MAAM,CAAC,UAAU,IAAI,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;oBACxE,CAAC;oBAED,oFAAoF;oBACpF,sEAAsE;oBACtE,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,UAAU,EAAE,UAAU,IAAI,IAAI;wBAC9B,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;wBACnC,OAAO,EAAE,kCAAkC,eAAe,CAAC,IAAI,EAAE;wBACjE,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,4BAA4B,EAAE,KAAK,CAAC,CAAC;oBACrE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,UAAU,EAAE,IAAI;wBAChB,SAAS,EAAE,IAAI;wBACf,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;qBACxC,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,aAAa,EAAE,KAAK,EAClB,OAAY,EACZ,IAAiF,EACjF,EAAE;gBACF,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,GAAG,KAAK,EAAE,GAAG,IAAI,CAAC;gBAE/D,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,sBAAsB,UAAU,aAAa,MAAM,EAAE,CAAC,CAAC;oBAEtF,qBAAqB;oBACrB,IAAI,CAAC,OAAO,EAAE,CAAC;wBACb,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EACH,qHAAqH;yBACxH,CAAC;oBACJ,CAAC;oBAED,WAAW;oBACX,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,mBAAmB,MAAM,EAAE;yBACnC,CAAC;oBACJ,CAAC;oBAED,yCAAyC;oBACzC,MAAM,SAAS,GAAG,MAAM,kBAAkB,EAAE,CAAC;oBAC7C,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBAC3B,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EACH,sFAAsF;yBACzF,CAAC;oBACJ,CAAC;oBAED,2EAA2E;oBAC3E,MAAM,WAAW,GAA2B,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;oBAC1F,MAAM,UAAU,GAAG,WAAW,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC;oBACrD,MAAM,eAAe,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,UAAU,CAAC,CAAC;oBAExE,IAAI,CAAC,eAAe,EAAE,CAAC;wBACrB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,aAAa,QAAQ,gCAAgC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;yBAC3G,CAAC;oBACJ,CAAC;oBAED,iDAAiD;oBACjD,MAAM,iBAAiB,GAA2B,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;oBAC1F,MAAM,gBAAgB,GAAG,iBAAiB,CAAC,eAAe,CAAC,EAAE,CAAC,IAAI,eAAe,CAAC,EAAE,CAAC;oBAErF,mEAAmE;oBACnE,MAAM,MAAM,GAAG,MAAM,eAAe,CAClC,wBAAwB,EACxB,kBAAkB,EAClB,MAAM,EACN,gBAAgB,EAChB,UAAU,CACX,CAAC;oBACF,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,qBAAqB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;oBAE9E,uFAAuF;oBACvF,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;oBACtD,IAAI,QAAQ,EAAE,CAAC;wBACb,MAAM,YAAY,GAChB,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,IAAI,gBAAgB,CAAC;wBACjF,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,YAAY;yBACpB,CAAC;oBACJ,CAAC;oBAED,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,OAAO,EAAE,6BAA6B,UAAU,EAAE;wBAClD,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,6BAA6B,EAAE,KAAK,CAAC,CAAC;oBACtE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;qBACxC,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,YAAY,EAAE,KAAK,EACjB,OAAY,EACZ,IAAiF,EACjF,EAAE;gBACF,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,GAAG,KAAK,EAAE,GAAG,IAAI,CAAC;gBAE/D,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,qBAAqB,UAAU,aAAa,MAAM,EAAE,CAAC,CAAC;oBAErF,qBAAqB;oBACrB,IAAI,CAAC,OAAO,EAAE,CAAC;wBACb,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,iBAAiB,EAAE,IAAI;4BACvB,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,8DAA8D;yBACtE,CAAC;oBACJ,CAAC;oBAED,WAAW;oBACX,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,iBAAiB,EAAE,IAAI;4BACvB,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,mBAAmB,MAAM,EAAE;yBACnC,CAAC;oBACJ,CAAC;oBAED,yCAAyC;oBACzC,MAAM,SAAS,GAAG,MAAM,kBAAkB,EAAE,CAAC;oBAC7C,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBAC3B,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,iBAAiB,EAAE,IAAI;4BACvB,OAAO,EAAE,IAAI;4BACb,KAAK,EACH,sFAAsF;yBACzF,CAAC;oBACJ,CAAC;oBAED,2EAA2E;oBAC3E,MAAM,WAAW,GAA2B,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;oBAC1F,MAAM,UAAU,GAAG,WAAW,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC;oBACrD,MAAM,eAAe,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,UAAU,CAAC,CAAC;oBAExE,IAAI,CAAC,eAAe,EAAE,CAAC;wBACrB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,iBAAiB,EAAE,IAAI;4BACvB,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,aAAa,QAAQ,gCAAgC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;yBAC3G,CAAC;oBACJ,CAAC;oBAED,iDAAiD;oBACjD,MAAM,iBAAiB,GAA2B,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;oBAC1F,MAAM,gBAAgB,GAAG,iBAAiB,CAAC,eAAe,CAAC,EAAE,CAAC,IAAI,eAAe,CAAC,EAAE,CAAC;oBAErF,mEAAmE;oBACnE,MAAM,MAAM,GAAG,MAAM,eAAe,CAClC,uBAAuB,EACvB,mBAAmB,EACnB,MAAM,EACN,gBAAgB,EAChB,UAAU,CACX,CAAC;oBAEF,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;wBACjB,+EAA+E;wBAC/E,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;4BAChD,OAAO;gCACL,OAAO,EAAE,KAAK;gCACd,iBAAiB,EAAE,IAAI;gCACvB,OAAO,EAAE,IAAI;gCACb,KAAK,EACH,+FAA+F;6BAClG,CAAC;wBACJ,CAAC;wBACD,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,iBAAiB,EAAE,IAAI;4BACvB,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,OAAO,IAAI,eAAe;yBAC/C,CAAC;oBACJ,CAAC;oBAED,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,iBAAiB,EAAE,UAAU;wBAC7B,OAAO,EAAE,gBAAgB;wBACzB,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,4BAA4B,EAAE,KAAK,CAAC,CAAC;oBACrE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,iBAAiB,EAAE,IAAI;wBACvB,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;qBACxC,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,cAAc,EAAE,KAAK,EACnB,OAAY,EACZ,IAA8D,EAC9D,EAAE;gBACF,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;gBAE9C,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,wBAAwB,UAAU,aAAa,MAAM,EAAE,CAAC,CAAC;oBAExF,WAAW;oBACX,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,QAAQ,EAAE,IAAI;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,mBAAmB,MAAM,EAAE;yBACnC,CAAC;oBACJ,CAAC;oBAED,yCAAyC;oBACzC,MAAM,SAAS,GAAG,MAAM,kBAAkB,EAAE,CAAC;oBAC7C,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBAC3B,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,QAAQ,EAAE,IAAI;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EACH,sFAAsF;yBACzF,CAAC;oBACJ,CAAC;oBAED,2EAA2E;oBAC3E,MAAM,WAAW,GAA2B,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;oBAC1F,MAAM,UAAU,GAAG,WAAW,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC;oBACrD,MAAM,eAAe,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,UAAU,CAAC,CAAC;oBAExE,IAAI,CAAC,eAAe,EAAE,CAAC;wBACrB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,QAAQ,EAAE,IAAI;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,aAAa,QAAQ,gCAAgC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;yBAC3G,CAAC;oBACJ,CAAC;oBAED,iDAAiD;oBACjD,MAAM,iBAAiB,GAA2B,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;oBAC1F,MAAM,gBAAgB,GAAG,iBAAiB,CAAC,eAAe,CAAC,EAAE,CAAC,IAAI,eAAe,CAAC,EAAE,CAAC;oBAErF,kEAAkE;oBAClE,MAAM,MAAM,GAAG,MAAM,eAAe,CAClC,yBAAyB,EACzB,kBAAkB,EAClB,MAAM,EACN,gBAAgB,EAChB,UAAU,CACX,CAAC;oBAEF,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;wBACjB,+EAA+E;wBAC/E,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;4BAChD,OAAO;gCACL,OAAO,EAAE,KAAK;gCACd,QAAQ,EAAE,IAAI;gCACd,OAAO,EAAE,IAAI;gCACb,KAAK,EACH,mGAAmG;6BACtG,CAAC;wBACJ,CAAC;wBACD,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,QAAQ,EAAE,IAAI;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,OAAO,IAAI,iBAAiB;yBACjD,CAAC;oBACJ,CAAC;oBAED,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,IAAI,IAAI;wBACzC,OAAO,EAAE,uCAAuC;wBAChD,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,8BAA8B,EAAE,KAAK,CAAC,CAAC;oBACvE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,QAAQ,EAAE,IAAI;wBACd,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;qBACxC,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,cAAc,EAAE,KAAK,EACnB,OAAY,EACZ,IAA4E,EAC5E,EAAE;gBACF,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC;gBAEpD,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,6BAA6B,UAAU,EAAE,CAAC,CAAC;oBAE1E,WAAW;oBACX,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBACtC,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,UAAU,EAAE,IAAI;4BAChB,IAAI,EAAE,IAAI;4BACV,KAAK,EAAE,mBAAmB,MAAM,EAAE;yBACnC,CAAC;oBACJ,CAAC;oBAED,yCAAyC;oBACzC,MAAM,SAAS,GAAG,MAAM,kBAAkB,EAAE,CAAC;oBAC7C,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBAC3B,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,UAAU,EAAE,IAAI;4BAChB,IAAI,EAAE,IAAI;4BACV,KAAK,EACH,sFAAsF;yBACzF,CAAC;oBACJ,CAAC;oBAED,2EAA2E;oBAC3E,MAAM,WAAW,GAA2B,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;oBAC1F,MAAM,UAAU,GAAG,WAAW,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC;oBACrD,MAAM,eAAe,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,UAAU,CAAC,CAAC;oBAExE,IAAI,CAAC,eAAe,EAAE,CAAC;wBACrB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,UAAU,EAAE,IAAI;4BAChB,IAAI,EAAE,IAAI;4BACV,KAAK,EAAE,aAAa,QAAQ,gCAAgC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;yBAC3G,CAAC;oBACJ,CAAC;oBAED,iDAAiD;oBACjD,MAAM,iBAAiB,GAA2B,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;oBAC1F,MAAM,gBAAgB,GAAG,iBAAiB,CAAC,eAAe,CAAC,EAAE,CAAC,IAAI,eAAe,CAAC,EAAE,CAAC;oBAErF,6DAA6D;oBAC7D,MAAM,MAAM,GAAG,MAAM,eAAe,CAClC,mBAAmB,EACnB,mBAAmB,EACnB,MAAM,EACN,gBAAgB,EAChB,UAAU,EACV,IAAI,CACL,CAAC;oBAEF,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;wBACjB,+EAA+E;wBAC/E,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;4BAChD,OAAO;gCACL,OAAO,EAAE,KAAK;gCACd,UAAU,EAAE,IAAI;gCAChB,IAAI,EAAE,IAAI;gCACV,KAAK,EACH,qGAAqG;6BACxG,CAAC;wBACJ,CAAC;wBACD,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,UAAU,EAAE,IAAI;4BAChB,IAAI,EAAE,IAAI;4BACV,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,OAAO,IAAI,kBAAkB;yBAClD,CAAC;oBACJ,CAAC;oBAED,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,UAAU;wBACV,IAAI;wBACJ,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,+BAA+B,EAAE,KAAK,CAAC,CAAC;oBACxE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,UAAU,EAAE,IAAI;wBAChB,IAAI,EAAE,IAAI;wBACV,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;qBACxC,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,8BAA8B;YAC9B,eAAe,EAAE,KAAK,IAAI,EAAE;gBAC1B,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,uCAAuC,CAAC,CAAC;oBAExE,IAAI,CAAC,eAAe,EAAE,CAAC;wBACrB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,KAAK,EAAE,IAAI;4BACX,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,uCAAuC;yBAC/C,CAAC;oBACJ,CAAC;oBAED,+DAA+D;oBAC/D,gDAAgD;oBAChD,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,YAAY,EAAE,CAAC;oBAEpD,IAAI,MAAM,IAAI,MAAM,CAAC,WAAW,EAAE,CAAC;wBACjC,kCAAkC;wBAClC,IAAI,KAAK,GAAG,IAAI,CAAC;wBACjB,IAAI,WAAW,EAAE,CAAC;4BAChB,IAAI,CAAC;gCACH,MAAM,WAAW,GAAG,MAAM,WAAW,CAAC,cAAc,EAAE,CAAC;gCACvD,KAAK,GAAG,WAAW,EAAE,KAAK,IAAI,IAAI,CAAC;4BACrC,CAAC;4BAAC,MAAM,CAAC;gCACP,0BAA0B;4BAC5B,CAAC;wBACH,CAAC;wBAED,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,wCAAwC,KAAK,CAAC,CAAC,CAAC,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CACpF,CAAC;wBACF,OAAO;4BACL,OAAO,EAAE,IAAI;4BACb,KAAK;4BACL,OAAO,EAAE,2CAA2C;4BACpD,KAAK,EAAE,IAAI;yBACZ,CAAC;oBACJ,CAAC;oBAED,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,IAAI;wBACX,OAAO,EAAE,sEAAsE;wBAC/E,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,8BAA8B,EAAE,KAAK,CAAC,CAAC;oBACvE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,KAAK,EAAE,IAAI;wBACX,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,uBAAuB;qBAChD,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,SAAS,EAAE,KAAK,IAAI,EAAE;gBACpB,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,8BAA8B,CAAC,CAAC;oBAE/D,IAAI,CAAC,eAAe,EAAE,CAAC;wBACrB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,uCAAuC;yBAC/C,CAAC;oBACJ,CAAC;oBAED,qCAAqC;oBACrC,MAAM,eAAe,CAAC,WAAW,EAAE,CAAC;oBAEpC,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,oCAAoC,CAAC,CAAC;oBACrE,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,OAAO,EAAE,2BAA2B;wBACpC,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,sBAAsB,EAAE,KAAK,CAAC,CAAC;oBAC/D,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;qBACxC,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,+BAA+B;YAC/B,SAAS,EAAE,KAAK,EACd,OAAY,EACZ,IAKC,EACD,EAAE;gBACF,MAAM,EAAE,WAAW,EAAE,eAAe,EAAE,UAAU,GAAG,KAAK,EAAE,OAAO,GAAG,KAAK,EAAE,GAAG,IAAI,CAAC;gBAEnF,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,uBAAuB,WAAW,YAAY,eAAe,gBAAgB,UAAU,EAAE,CACxG,CAAC;oBAEF,2CAA2C;oBAC3C,IAAI,CAAC,OAAO,EAAE,CAAC;wBACb,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EACH,2FAA2F;yBAC9F,CAAC;oBACJ,CAAC;oBAED,qBAAqB;oBACrB,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBAC3C,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,mBAAmB,WAAW,EAAE;yBACxC,CAAC;oBACJ,CAAC;oBAED,8BAA8B;oBAC9B,MAAM,aAAa,GAAG,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,CAAC;oBACjF,IAAI,CAAC,aAAa,EAAE,CAAC;wBACnB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EACH,+EAA+E;yBAClF,CAAC;oBACJ,CAAC;oBAED,kCAAkC;oBAClC,IAAI,CAAC,cAAc,IAAI,OAAO,cAAc,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;wBACjE,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,gCAAgC;yBACxC,CAAC;oBACJ,CAAC;oBAED,2DAA2D;oBAC3D,IAAI,WAAW,GAAG,eAAe,CAAC;oBAClC,IAAI,aAAa,GAAG,EAAE,CAAC;oBACvB,IAAI,SAAS,GAAG,EAAE,CAAC;oBAEnB,IAAI,WAAW,IAAI,OAAO,WAAW,CAAC,cAAc,KAAK,UAAU,EAAE,CAAC;wBACpE,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC,cAAc,EAAE,CAAC;wBACpD,MAAM,eAAe,GAAG,QAAQ,EAAE,IAAI,CACpC,CAAC,CAAM,EAAE,EAAE,CACT,CAAC,CAAC,IAAI,EAAE,EAAE,KAAK,aAAa,CAAC,YAAY;4BACzC,CAAC,CAAC,aAAa,CAAC,aAAa,IAAI,CAAC,CAAC,WAAW,KAAK,aAAa,CAAC,aAAa,CAAC,CAClF,CAAC;wBACF,IAAI,eAAe,EAAE,CAAC;4BACpB,WAAW,GAAG,eAAe,CAAC,IAAI,CAAC;4BACnC,aAAa;gCACX,eAAe,CAAC,cAAc;oCAC9B,eAAe,CAAC,KAAK;oCACrB,GAAG,eAAe,CAAC,IAAI,eAAe,CAAC;4BACzC,SAAS,GAAG,eAAe,CAAC,EAAE,CAAC;wBACjC,CAAC;oBACH,CAAC;oBAED,IAAI,CAAC,aAAa,EAAE,CAAC;wBACnB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EACH,qFAAqF;yBACxF,CAAC;oBACJ,CAAC;oBAED,yDAAyD;oBACzD,cAAc;yBACX,IAAI,CAAC;wBACJ,UAAU;wBACV,mBAAmB,EAAE,WAAW;wBAChC,iBAAiB,EAAE,SAAS;wBAC5B,cAAc,EAAE,aAAa,CAAC,YAAY;wBAC1C,qBAAqB,EAAE,aAAa;wBACpC,WAAW,EAAE,IAAI,CAAC,EAAE;wBACpB,WAAW,EAAE,aAAa,CAAC,aAAa;wBACxC,WAAW,EAAE,KAAK;qBACnB,CAAC;yBACD,KAAK,CAAC,CAAC,GAAQ,EAAE,EAAE;wBAClB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,gBAAgB,EAAE,GAAG,CAAC,CAAC;oBACzD,CAAC,CAAC,CAAC;oBAEL,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,OAAO,EAAE,mBAAmB,WAAW,gCAAgC;wBACvE,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,yBAAyB,EAAE,KAAK,CAAC,CAAC;oBAClE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,sBAAsB;qBAC/C,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,iCAAiC;YACjC,WAAW,EAAE,KAAK,EAChB,OAAY,EACZ,IAIC,EACD,EAAE;gBACF,MAAM,EAAE,WAAW,EAAE,eAAe,EAAE,UAAU,GAAG,KAAK,EAAE,GAAG,IAAI,CAAC;gBAElE,IAAI,CAAC;oBACH,WAAW,CAAC,IAAI,CACd,IAAI,UAAU,yBAAyB,WAAW,YAAY,eAAe,gBAAgB,UAAU,EAAE,CAC1G,CAAC;oBAEF,qBAAqB;oBACrB,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBAC3C,IAAI,CAAC,IAAI,EAAE,CAAC;wBACV,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,mBAAmB,WAAW,EAAE;yBACxC,CAAC;oBACJ,CAAC;oBAED,8BAA8B;oBAC9B,MAAM,aAAa,GAAG,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,CAAC;oBACjF,IAAI,CAAC,aAAa,EAAE,CAAC;wBACnB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EACH,+EAA+E;yBAClF,CAAC;oBACJ,CAAC;oBAED,kCAAkC;oBAClC,IAAI,CAAC,cAAc,IAAI,OAAO,cAAc,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;wBACjE,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EAAE,gCAAgC;yBACxC,CAAC;oBACJ,CAAC;oBAED,gCAAgC;oBAChC,IAAI,WAAW,GAAG,eAAe,CAAC;oBAClC,IAAI,aAAa,GAAG,EAAE,CAAC;oBACvB,IAAI,SAAS,GAAG,EAAE,CAAC;oBAEnB,IAAI,WAAW,IAAI,OAAO,WAAW,CAAC,cAAc,KAAK,UAAU,EAAE,CAAC;wBACpE,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC,cAAc,EAAE,CAAC;wBACpD,MAAM,eAAe,GAAG,QAAQ,EAAE,IAAI,CACpC,CAAC,CAAM,EAAE,EAAE,CACT,CAAC,CAAC,IAAI,EAAE,EAAE,KAAK,aAAa,CAAC,YAAY;4BACzC,CAAC,CAAC,aAAa,CAAC,aAAa,IAAI,CAAC,CAAC,WAAW,KAAK,aAAa,CAAC,aAAa,CAAC,CAClF,CAAC;wBACF,IAAI,eAAe,EAAE,CAAC;4BACpB,WAAW,GAAG,eAAe,CAAC,IAAI,CAAC;4BACnC,aAAa;gCACX,eAAe,CAAC,cAAc;oCAC9B,eAAe,CAAC,KAAK;oCACrB,GAAG,eAAe,CAAC,IAAI,eAAe,CAAC;4BACzC,SAAS,GAAG,eAAe,CAAC,EAAE,CAAC;wBACjC,CAAC;oBACH,CAAC;oBAED,IAAI,CAAC,aAAa,EAAE,CAAC;wBACnB,OAAO;4BACL,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI;4BACb,KAAK,EACH,qFAAqF;yBACxF,CAAC;oBACJ,CAAC;oBAED,yDAAyD;oBACzD,cAAc;yBACX,IAAI,CAAC;wBACJ,UAAU;wBACV,mBAAmB,EAAE,WAAW;wBAChC,iBAAiB,EAAE,SAAS;wBAC5B,cAAc,EAAE,aAAa,CAAC,YAAY;wBAC1C,qBAAqB,EAAE,aAAa;wBACpC,WAAW,EAAE,IAAI,CAAC,EAAE;wBACpB,WAAW,EAAE,aAAa,CAAC,aAAa;wBACxC,WAAW,EAAE,KAAK;qBACnB,CAAC;yBACD,KAAK,CAAC,CAAC,GAAQ,EAAE,EAAE;wBAClB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,gBAAgB,EAAE,GAAG,CAAC,CAAC;oBACzD,CAAC,CAAC,CAAC;oBAEL,OAAO;wBACL,OAAO,EAAE,IAAI;wBACb,OAAO,EAAE,qBAAqB,WAAW,gCAAgC;wBACzE,KAAK,EAAE,IAAI;qBACZ,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAU,EAAE,CAAC;oBACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,yBAAyB,EAAE,KAAK,CAAC,CAAC;oBAClE,OAAO;wBACL,OAAO,EAAE,KAAK;wBACd,OAAO,EAAE,IAAI;wBACb,KAAK,EAAE,KAAK,CAAC,OAAO,IAAI,sBAAsB;qBAC/C,CAAC;gBACJ,CAAC;YACH,CAAC;SACF;KACF,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,cAAc,CAAC,QAAuB,EAAE,MAAW;IAChE,IAAI,SAAS,EAAE,CAAC;QACd,MAAM,CAAC,IAAI,CAAC,IAAI,UAAU,8BAA8B,CAAC,CAAC;QAC1D,OAAO;IACT,CAAC;IAED,IAAI,CAAC;QACH,SAAS,GAAG,IAAI,qBAAS,CAAC,EAAE,IAAI,EAAE,sBAAU,CAAC,YAAY,EAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;QAE/E,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC;QAExB,MAAM,IAAI,GAAG,SAAS,CAAC,iBAAiB,EAAE,CAAC;QAC3C,MAAM,CAAC,IAAI,CAAC,IAAI,UAAU,gCAAgC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QACvE,MAAM,CAAC,IAAI,CACT,IAAI,UAAU,8FAA8F,CAC7G,CAAC;QACF,MAAM,CAAC,IAAI,CAAC,IAAI,UAAU,sBAAsB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC3E,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,MAAM,CAAC,KAAK,CAAC,IAAI,UAAU,+BAA+B,EAAE,KAAK,CAAC,CAAC;IACrE,CAAC;AACH,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,aAAa,CAAC,MAAW;IACtC,IAAI,SAAS,EAAE,CAAC;QACd,MAAM,SAAS,CAAC,IAAI,EAAE,CAAC;QACvB,SAAS,GAAG,IAAI,CAAC;QACjB,MAAM,CAAC,IAAI,CAAC,IAAI,UAAU,sBAAsB,CAAC,CAAC;IACpD,CAAC;AACH,CAAC;AAED;;GAEG;AACH,SAAS,mBAAmB,CAAC,QAAuB,EAAE,MAAW;IAC/D,wBAAwB;IACxB,kBAAO,CAAC,MAAM,CAAC,eAAe,EAAE,KAAK,IAAI,EAAE;QACzC,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;QAChD,CAAC;QACD,OAAO,SAAS,CAAC,SAAS,EAAE,CAAC;IAC/B,CAAC,CAAC,CAAC;IAEH,sBAAsB;IACtB,kBAAO,CAAC,MAAM,CAAC,uBAAuB,EAAE,KAAK,IAAI,EAAE;QACjD,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,SAAS,CAAC,iBAAiB,EAAE,CAAC;IACvC,CAAC,CAAC,CAAC;IAEH,mBAAmB;IACnB,kBAAO,CAAC,MAAM,CAAC,WAAW,EAAE,KAAK,IAAI,EAAE;QACrC,IAAI,CAAC;YACH,MAAM,cAAc,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YACvC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;QAC3B,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;QAClD,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,kBAAkB;IAClB,kBAAO,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,IAAI,EAAE;QACpC,IAAI,CAAC;YACH,MAAM,aAAa,CAAC,MAAM,CAAC,CAAC;YAC5B,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;QAC3B,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;QAClD,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,qBAAqB;IACrB,kBAAO,CAAC,MAAM,CAAC,aAAa,EAAE,KAAK,IAAI,EAAE;QACvC,IAAI,CAAC;YACH,MAAM,aAAa,CAAC,MAAM,CAAC,CAAC;YAC5B,MAAM,cAAc,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YACvC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;QAC3B,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;QAClD,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,wBAAwB;IACxB,kBAAO,CAAC,MAAM,CAAC,qBAAqB,EAAE,KAAK,IAAI,EAAE;QAC/C,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,wBAAwB,EAAE,CAAC;QAC7D,CAAC;QACD,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC,eAAe,EAAE,CAAC;YACnD,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;QAC5C,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;QAClD,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,IAAI,CACT,IAAI,UAAU,wHAAwH,CACvI,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,mBAAyB,QAAoC;IAC3D,MAAM,QAAQ,GAAG,SAAS,CAAC,mBAAmB,EAAE,CAAC,MAAa,CAAC;IAC/D,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,QAAQ,CAAC;IAE1C,IAAI,CAAC;QACH,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,mBAAmB,CAAC,CAAC;QAEpD,sDAAsD;QACtD,MAAM,SAAS,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAC;QAC5C,OAAO,CAAC,sBAAsB,CAAC,YAAY,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;QAClE,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,8CAA8C,CAAC,CAAC;QAE/E,kCAAkC;QAClC,MAAM,aAAa,GAAkB;YACnC,QAAQ,EAAE,QAAQ,CAAC,QAAQ;YAC3B,kBAAkB,EAAE,QAAQ,CAAC,kBAAkB;YAC/C,KAAK,EAAE,QAAQ,CAAC,KAAK;YACrB,UAAU,EAAE,QAAQ,CAAC,UAAU;YAC/B,OAAO,EAAE,QAAQ,CAAC,OAAO;YACzB,WAAW,EAAE,QAAQ,CAAC,WAAW;YACjC,OAAO,EAAE,QAAQ,CAAC,OAAO;YACzB,QAAQ,EAAE,QAAQ,CAAC,QAAQ;YAC3B,eAAe,EAAE,QAAQ,CAAC,eAAe;YACzC,UAAU,EAAE,QAAQ,CAAC,UAAU;YAC/B,iBAAiB,EAAE,QAAQ,CAAC,iBAAiB;YAC7C,8BAA8B;YAC9B,QAAQ,EAAE,QAAQ,CAAC,QAAQ;YAC3B,IAAI,EAAE,QAAQ,CAAC,IAAI;SACpB,CAAC;QAEF,sCAAsC;QACtC,yEAAyE;QACzE,8CAA8C;QAC9C,mDAAmD;QAEnD,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,4CAA4C,CAAC,CAAC;IAC/E,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,WAAW,CAAC,KAAK,CAAC,IAAI,UAAU,yBAAyB,EAAE,KAAK,CAAC,CAAC;IACpE,CAAC;AACH,CAAC","sourcesContent":["/**\n * CLI Bridge Addon - Main Process Entry Point\n *\n * This addon extends Local's capabilities:\n * - GraphQL mutations for deleteSite, wpCli (for local-cli)\n * - MCP Server for AI tool integration (Claude Code, ChatGPT, etc.)\n */\n\nimport * as LocalMain from '@getflywheel/local/main';\nimport { ipcMain } from 'electron';\nimport gql from 'graphql-tag';\nimport { McpServer } from './mcp/McpServer';\nimport { MCP_SERVER } from '../common/constants';\nimport { LocalServices } from '../common/types';\n\nconst ADDON_NAME = 'MCP Server';\n\nlet mcpServer: McpServer | null = null;\n\n/**\n * GraphQL type definitions for CLI Bridge\n */\nconst typeDefs = gql`\n  input DeleteSiteInput {\n    \"The site ID to delete\"\n    id: ID!\n    \"Whether to move site files to trash (true) or just remove from Local (false)\"\n    trashFiles: Boolean = true\n    \"Whether to update the hosts file\"\n    updateHosts: Boolean = true\n  }\n\n  type DeleteSiteResult {\n    \"Whether the deletion was successful\"\n    success: Boolean!\n    \"Error message if deletion failed\"\n    error: String\n    \"The ID of the deleted site\"\n    siteId: ID\n  }\n\n  input WpCliInput {\n    \"The site ID to run WP-CLI against\"\n    siteId: ID!\n    \"WP-CLI command and arguments (e.g., ['plugin', 'list', '--format=json'])\"\n    args: [String!]!\n    \"Skip loading plugins (default: true)\"\n    skipPlugins: Boolean = true\n    \"Skip loading themes (default: true)\"\n    skipThemes: Boolean = true\n  }\n\n  type WpCliResult {\n    \"Whether the command executed successfully\"\n    success: Boolean!\n    \"Command output (stdout)\"\n    output: String\n    \"Error message if command failed\"\n    error: String\n  }\n\n  input CreateSiteInput {\n    \"Site name (required)\"\n    name: String!\n    \"PHP version (e.g., '8.2.10'). Uses Local default if not specified.\"\n    phpVersion: String\n    \"Web server type\"\n    webServer: String\n    \"Database type\"\n    database: String\n    \"WordPress admin username (default: admin)\"\n    wpAdminUsername: String\n    \"WordPress admin password (default: password)\"\n    wpAdminPassword: String\n    \"WordPress admin email (default: admin@local.test)\"\n    wpAdminEmail: String\n    \"Blueprint name to create site from. Use list_blueprints to see available blueprints.\"\n    blueprint: String\n  }\n\n  type CreateSiteResult {\n    \"Whether site creation was initiated successfully\"\n    success: Boolean!\n    \"Error message if creation failed\"\n    error: String\n    \"The created site ID\"\n    siteId: ID\n    \"The site name\"\n    siteName: String\n    \"The site domain\"\n    siteDomain: String\n  }\n\n  input OpenSiteInput {\n    \"The site ID to open\"\n    siteId: ID!\n    \"Path to open (default: /, use /wp-admin for admin)\"\n    path: String = \"/\"\n  }\n\n  type OpenSiteResult {\n    \"Whether the site was opened successfully\"\n    success: Boolean!\n    \"Error message if failed\"\n    error: String\n    \"The URL that was opened\"\n    url: String\n  }\n\n  input CloneSiteInput {\n    \"The site ID to clone\"\n    siteId: ID!\n    \"Name for the cloned site\"\n    newName: String!\n  }\n\n  type CloneSiteResult {\n    \"Whether cloning was successful\"\n    success: Boolean!\n    \"Error message if failed\"\n    error: String\n    \"The new site ID\"\n    newSiteId: ID\n    \"The new site name\"\n    newSiteName: String\n    \"The new site domain\"\n    newSiteDomain: String\n  }\n\n  input ExportSiteInput {\n    \"The site ID to export\"\n    siteId: ID!\n    \"Output directory path (default: ~/Downloads)\"\n    outputPath: String\n  }\n\n  type ExportSiteResult {\n    \"Whether export was successful\"\n    success: Boolean!\n    \"Error message if failed\"\n    error: String\n    \"Path to the exported zip file\"\n    exportPath: String\n  }\n\n  type Blueprint {\n    \"Blueprint name\"\n    name: String!\n    \"Last modified date\"\n    lastModified: String\n    \"PHP version\"\n    phpVersion: String\n    \"Web server type\"\n    webServer: String\n    \"Database type\"\n    database: String\n  }\n\n  type BlueprintsResult {\n    \"Whether query was successful\"\n    success: Boolean!\n    \"Error message if failed\"\n    error: String\n    \"List of blueprints\"\n    blueprints: [Blueprint!]\n  }\n\n  input SaveBlueprintInput {\n    \"The site ID to save as blueprint\"\n    siteId: ID!\n    \"Name for the blueprint\"\n    name: String!\n  }\n\n  type SaveBlueprintResult {\n    \"Whether save was successful\"\n    success: Boolean!\n    \"Error message if failed\"\n    error: String\n    \"The blueprint name\"\n    blueprintName: String\n  }\n\n  # Phase 8: WordPress Development Tools\n  input ExportDatabaseInput {\n    \"The site ID\"\n    siteId: ID!\n    \"Output file path (optional, defaults to ~/Downloads/<site-name>.sql)\"\n    outputPath: String\n  }\n\n  type ExportDatabaseResult {\n    \"Whether export was successful\"\n    success: Boolean!\n    \"Error message if failed\"\n    error: String\n    \"Path to the exported SQL file\"\n    outputPath: String\n  }\n\n  input ImportDatabaseInput {\n    \"The site ID\"\n    siteId: ID!\n    \"Path to the SQL file to import\"\n    sqlPath: String!\n  }\n\n  type ImportDatabaseResult {\n    \"Whether import was successful\"\n    success: Boolean!\n    \"Error message if failed\"\n    error: String\n  }\n\n  input OpenAdminerInput {\n    \"The site ID\"\n    siteId: ID!\n  }\n\n  type OpenAdminerResult {\n    \"Whether opening was successful\"\n    success: Boolean!\n    \"Error message if failed\"\n    error: String\n  }\n\n  input TrustSslInput {\n    \"The site ID\"\n    siteId: ID!\n  }\n\n  type TrustSslResult {\n    \"Whether trust was successful\"\n    success: Boolean!\n    \"Error message if failed\"\n    error: String\n  }\n\n  input McpRenameSiteInput {\n    \"The site ID\"\n    siteId: ID!\n    \"New name for the site\"\n    newName: String!\n  }\n\n  type McpRenameSiteResult {\n    \"Whether rename was successful\"\n    success: Boolean!\n    \"Error message if failed\"\n    error: String\n    \"The new name\"\n    newName: String\n  }\n\n  input ChangePhpVersionInput {\n    \"The site ID\"\n    siteId: ID!\n    \"Target PHP version\"\n    phpVersion: String!\n  }\n\n  type ChangePhpVersionResult {\n    \"Whether change was successful\"\n    success: Boolean!\n    \"Error message if failed\"\n    error: String\n    \"The new PHP version\"\n    phpVersion: String\n  }\n\n  input ImportSiteInput {\n    \"Path to the zip file to import\"\n    zipPath: String!\n    \"Name for the imported site (optional)\"\n    siteName: String\n  }\n\n  type ImportSiteResult {\n    \"Whether import was successful\"\n    success: Boolean!\n    \"Error message if failed\"\n    error: String\n    \"The imported site ID\"\n    siteId: ID\n    \"The imported site name\"\n    siteName: String\n  }\n\n  # Phase 9: Site Configuration & Dev Tools\n  input ToggleXdebugInput {\n    \"The site ID\"\n    siteId: ID!\n    \"Whether to enable or disable Xdebug\"\n    enabled: Boolean!\n  }\n\n  type ToggleXdebugResult {\n    \"Whether toggle was successful\"\n    success: Boolean!\n    \"Error message if failed\"\n    error: String\n    \"Current Xdebug state\"\n    enabled: Boolean\n  }\n\n  input GetSiteLogsInput {\n    \"The site ID\"\n    siteId: ID!\n    \"Type of logs to retrieve (php, nginx, mysql, all)\"\n    logType: String = \"php\"\n    \"Number of lines to return\"\n    lines: Int = 100\n  }\n\n  type LogEntry {\n    \"Log type\"\n    type: String!\n    \"Log content\"\n    content: String!\n    \"Log file path\"\n    path: String!\n  }\n\n  type GetSiteLogsResult {\n    \"Whether retrieval was successful\"\n    success: Boolean!\n    \"Error message if failed\"\n    error: String\n    \"Log entries\"\n    logs: [LogEntry!]\n  }\n\n  type ServiceInfo {\n    \"Service role (php, database, webserver)\"\n    role: String!\n    \"Service name\"\n    name: String!\n    \"Service version\"\n    version: String!\n  }\n\n  type ListServicesResult {\n    \"Whether listing was successful\"\n    success: Boolean!\n    \"Error message if failed\"\n    error: String\n    \"Available services\"\n    services: [ServiceInfo!]\n  }\n\n  extend type Mutation {\n    \"Create a new WordPress site with full WordPress installation\"\n    createSite(input: CreateSiteInput!): CreateSiteResult!\n\n    \"Delete a site from Local\"\n    deleteSite(input: DeleteSiteInput!): DeleteSiteResult!\n\n    \"Delete multiple sites from Local\"\n    deleteSites(ids: [ID!]!, trashFiles: Boolean = true): DeleteSiteResult!\n\n    \"Run a WP-CLI command against a site\"\n    wpCli(input: WpCliInput!): WpCliResult!\n\n    \"Open a site in the default browser\"\n    openSite(input: OpenSiteInput!): OpenSiteResult!\n\n    \"Clone an existing site\"\n    cloneSite(input: CloneSiteInput!): CloneSiteResult!\n\n    \"Export a site to a zip file\"\n    exportSite(input: ExportSiteInput!): ExportSiteResult!\n\n    \"Save a site as a blueprint\"\n    saveBlueprint(input: SaveBlueprintInput!): SaveBlueprintResult!\n\n    # Phase 8: WordPress Development Tools\n    \"Export site database to SQL file\"\n    exportDatabase(input: ExportDatabaseInput!): ExportDatabaseResult!\n\n    \"Import SQL file into site database\"\n    importDatabase(input: ImportDatabaseInput!): ImportDatabaseResult!\n\n    \"Open Adminer database management UI\"\n    openAdminer(input: OpenAdminerInput!): OpenAdminerResult!\n\n    \"Trust site SSL certificate\"\n    trustSsl(input: TrustSslInput!): TrustSslResult!\n\n    \"Rename a site (MCP version)\"\n    mcpRenameSite(input: McpRenameSiteInput!): McpRenameSiteResult!\n\n    \"Change site PHP version\"\n    changePhpVersion(input: ChangePhpVersionInput!): ChangePhpVersionResult!\n\n    \"Import site from zip file\"\n    importSite(input: ImportSiteInput!): ImportSiteResult!\n\n    # Phase 9: Site Configuration & Dev Tools\n    \"Toggle Xdebug for a site\"\n    toggleXdebug(input: ToggleXdebugInput!): ToggleXdebugResult!\n\n    \"Get site log files\"\n    getSiteLogs(input: GetSiteLogsInput!): GetSiteLogsResult!\n  }\n\n  extend type Query {\n    \"Run a WP-CLI command against a site (read-only operations)\"\n    wpCliQuery(input: WpCliInput!): WpCliResult!\n\n    \"List all available blueprints\"\n    blueprints: BlueprintsResult!\n\n    \"List available service versions\"\n    listServices(type: String): ListServicesResult!\n\n    # Phase 11: WP Engine Connect\n    \"Check WP Engine authentication status\"\n    wpeStatus: WpeAuthStatus!\n\n    \"List all sites from WP Engine account\"\n    listWpeSites(accountId: String): ListWpeSitesResult!\n\n    # Phase 11b: Site Linking\n    \"Get WP Engine connection details for a local site\"\n    getWpeLink(siteId: ID!): GetWpeLinkResult!\n  }\n\n  # Phase 11: WP Engine Connect Types\n  type WpeAuthStatus {\n    \"Whether authenticated with WP Engine\"\n    authenticated: Boolean!\n    \"User email if authenticated\"\n    email: String\n    \"Account ID if authenticated\"\n    accountId: String\n    \"Account name if authenticated\"\n    accountName: String\n    \"Token expiry time\"\n    tokenExpiry: String\n    \"Error message if status check failed\"\n    error: String\n  }\n\n  type WpeAuthResult {\n    \"Whether authentication was successful\"\n    success: Boolean!\n    \"User email if successful\"\n    email: String\n    \"Message about the authentication result\"\n    message: String\n    \"Error message if failed\"\n    error: String\n  }\n\n  type WpeLogoutResult {\n    \"Whether logout was successful\"\n    success: Boolean!\n    \"Message about the logout result\"\n    message: String\n    \"Error message if failed\"\n    error: String\n  }\n\n  type WpeSite {\n    \"Install ID\"\n    id: String!\n    \"Install name\"\n    name: String!\n    \"Environment (production, staging, development)\"\n    environment: String!\n    \"PHP version\"\n    phpVersion: String\n    \"Primary domain\"\n    primaryDomain: String\n    \"Account ID\"\n    accountId: String\n    \"Account name\"\n    accountName: String\n    \"SFTP host\"\n    sftpHost: String\n    \"SFTP user\"\n    sftpUser: String\n  }\n\n  type ListWpeSitesResult {\n    \"Whether query was successful\"\n    success: Boolean!\n    \"Error message if failed\"\n    error: String\n    \"List of WP Engine sites\"\n    sites: [WpeSite!]\n    \"Total count of sites\"\n    count: Int\n  }\n\n  # Phase 11b: Site Linking Types\n  type WpeConnection {\n    \"Remote install ID (UUID from WP Engine)\"\n    remoteInstallId: String!\n    \"Install name (human-readable, used in portal URLs)\"\n    installName: String\n    \"Environment (production, staging, development)\"\n    environment: String\n    \"Account ID\"\n    accountId: String\n    \"WP Engine portal URL\"\n    portalUrl: String\n    \"Primary domain/CNAME\"\n    primaryDomain: String\n  }\n\n  \"Sync capabilities available for WPE-connected sites\"\n  type WpeSyncCapabilities {\n    \"Whether user can push to WP Engine\"\n    canPush: Boolean!\n    \"Whether user can pull from WP Engine\"\n    canPull: Boolean!\n    \"Available sync modes\"\n    syncModes: [String!]!\n    \"Whether Magic Sync (select files) is available\"\n    magicSyncAvailable: Boolean!\n    \"Whether database sync is available\"\n    databaseSyncAvailable: Boolean!\n  }\n\n  type GetWpeLinkResult {\n    \"Whether site is linked to WP Engine\"\n    linked: Boolean!\n    \"Site name\"\n    siteName: String\n    \"WP Engine connections\"\n    connections: [WpeConnection!]\n    \"Number of connections\"\n    connectionCount: Int\n    \"Sync capabilities (only present if linked)\"\n    capabilities: WpeSyncCapabilities\n    \"Message (for unlinked sites)\"\n    message: String\n    \"Error message if failed\"\n    error: String\n  }\n\n  # Phase 11c: Sync Operations Types\n  type SyncHistoryEvent {\n    \"Remote install name\"\n    remoteInstallName: String\n    \"Unix timestamp\"\n    timestamp: Float!\n    \"Environment (production, staging, development)\"\n    environment: String!\n    \"Sync direction\"\n    direction: String!\n    \"Sync status\"\n    status: String\n  }\n\n  type GetSyncHistoryResult {\n    \"Whether the query was successful\"\n    success: Boolean!\n    \"Site name\"\n    siteName: String\n    \"Sync history events\"\n    events: [SyncHistoryEvent!]\n    \"Number of events\"\n    count: Int\n    \"Error message if failed\"\n    error: String\n  }\n\n  type SyncResult {\n    \"Whether the sync was initiated successfully\"\n    success: Boolean!\n    \"Status message\"\n    message: String\n    \"Error message if failed\"\n    error: String\n  }\n\n  # File change detection\n  type FileChange {\n    \"File path relative to site root\"\n    path: String!\n    \"Change type: create, upload, download, delete, modify\"\n    instruction: String!\n    \"File size in bytes\"\n    size: Int\n    \"File type: - (file) or d (directory)\"\n    type: String\n  }\n\n  type GetSiteChangesResult {\n    \"Whether the query was successful\"\n    success: Boolean!\n    \"Site name\"\n    siteName: String\n    \"Direction of comparison\"\n    direction: String\n    \"Files that would be added/uploaded\"\n    added: [FileChange!]\n    \"Files that would be modified\"\n    modified: [FileChange!]\n    \"Files that would be deleted\"\n    deleted: [FileChange!]\n    \"Total number of changes\"\n    totalChanges: Int\n    \"Summary message\"\n    message: String\n    \"Error message if failed\"\n    error: String\n  }\n\n  # Phase 10: Cloud Backup Types\n  type BackupProviderStatus {\n    \"Whether authenticated with provider\"\n    authenticated: Boolean!\n    \"Account ID\"\n    accountId: String\n    \"Account email\"\n    email: String\n  }\n\n  type BackupStatusResult {\n    \"Whether backups are available\"\n    available: Boolean!\n    \"Whether the feature is enabled\"\n    featureEnabled: Boolean!\n    \"Dropbox authentication status\"\n    dropbox: BackupProviderStatus\n    \"Google Drive authentication status\"\n    googleDrive: BackupProviderStatus\n    \"Message if backups unavailable\"\n    message: String\n    \"Error message if failed\"\n    error: String\n  }\n\n  type BackupMetadata {\n    \"Snapshot ID\"\n    snapshotId: String!\n    \"Backup timestamp (ISO format)\"\n    timestamp: String\n    \"Backup note/description\"\n    note: String\n    \"Site domain\"\n    siteDomain: String\n    \"Services info (JSON)\"\n    services: String\n  }\n\n  type ListBackupsResult {\n    \"Whether query was successful\"\n    success: Boolean!\n    \"Site name\"\n    siteName: String\n    \"Backup provider\"\n    provider: String\n    \"List of backups\"\n    backups: [BackupMetadata!]\n    \"Number of backups\"\n    count: Int\n    \"Error message if failed\"\n    error: String\n  }\n\n  type CreateBackupResult {\n    \"Whether backup was created successfully\"\n    success: Boolean!\n    \"Snapshot ID\"\n    snapshotId: String\n    \"Backup timestamp\"\n    timestamp: String\n    \"Status message\"\n    message: String\n    \"Error message if failed\"\n    error: String\n  }\n\n  type RestoreBackupResult {\n    \"Whether restore was successful\"\n    success: Boolean!\n    \"Status message\"\n    message: String\n    \"Error message if failed\"\n    error: String\n  }\n\n  type DeleteBackupResult {\n    \"Whether deletion was successful\"\n    success: Boolean!\n    \"Deleted snapshot ID\"\n    deletedSnapshotId: String\n    \"Status message\"\n    message: String\n    \"Error message if failed\"\n    error: String\n  }\n\n  type DownloadBackupResult {\n    \"Whether download was successful\"\n    success: Boolean!\n    \"Path to downloaded file\"\n    filePath: String\n    \"Status message\"\n    message: String\n    \"Error message if failed\"\n    error: String\n  }\n\n  type EditBackupNoteResult {\n    \"Whether edit was successful\"\n    success: Boolean!\n    \"Updated snapshot ID\"\n    snapshotId: String\n    \"Updated note\"\n    note: String\n    \"Error message if failed\"\n    error: String\n  }\n\n  extend type Query {\n    # Phase 10: Cloud Backups\n    \"Check if cloud backups are available and authenticated\"\n    backupStatus: BackupStatusResult!\n\n    \"List all backups for a site\"\n    listBackups(siteId: ID!, provider: String!): ListBackupsResult!\n\n    # Phase 11c: Sync Operations\n    \"Get sync history for a local site\"\n    getSyncHistory(siteId: ID!, limit: Int): GetSyncHistoryResult!\n\n    \"Get file changes between local site and WP Engine (dry-run comparison)\"\n    getSiteChanges(siteId: ID!, direction: String = \"push\"): GetSiteChangesResult!\n  }\n\n  extend type Mutation {\n    # Phase 10: Cloud Backups\n    \"Create a backup of a site to cloud storage\"\n    createBackup(siteId: ID!, provider: String!, note: String): CreateBackupResult!\n\n    \"Restore a site from a cloud backup\"\n    restoreBackup(\n      siteId: ID!\n      provider: String!\n      snapshotId: String!\n      confirm: Boolean = false\n    ): RestoreBackupResult!\n\n    \"Delete a backup from cloud storage\"\n    deleteBackup(\n      siteId: ID!\n      provider: String!\n      snapshotId: String!\n      confirm: Boolean = false\n    ): DeleteBackupResult!\n\n    \"Download a backup as a ZIP file\"\n    downloadBackup(siteId: ID!, provider: String!, snapshotId: String!): DownloadBackupResult!\n\n    \"Update the note/description for a backup\"\n    editBackupNote(\n      siteId: ID!\n      provider: String!\n      snapshotId: String!\n      note: String!\n    ): EditBackupNoteResult!\n\n    # Phase 11: WP Engine Connect\n    \"Authenticate with WP Engine (opens browser for OAuth)\"\n    wpeAuthenticate: WpeAuthResult!\n\n    \"Logout from WP Engine\"\n    wpeLogout: WpeLogoutResult!\n\n    # Phase 11c: Sync Operations\n    \"Push local site to WP Engine\"\n    pushToWpe(\n      localSiteId: ID!\n      remoteInstallId: ID!\n      includeSql: Boolean = false\n      confirm: Boolean = false\n    ): SyncResult!\n\n    \"Pull from WP Engine to local site\"\n    pullFromWpe(localSiteId: ID!, remoteInstallId: ID!, includeSql: Boolean = false): SyncResult!\n  }\n`;\n\n/**\n * Create GraphQL resolvers that use Local's internal services\n */\nfunction createResolvers(services: any) {\n  const {\n    deleteSite: deleteSiteService,\n    siteData,\n    localLogger,\n    wpCli,\n    siteProcessManager,\n    addSite: addSiteService,\n    cloneSite: cloneSiteService,\n    exportSite: exportSiteService,\n    blueprints: blueprintsService,\n    browserManager,\n    adminer,\n    x509Cert,\n    siteProvisioner,\n    importSite: importSiteService,\n    lightningServices,\n    siteDatabase,\n    importSQLFile: importSQLFileService,\n    // Phase 11: WP Engine Connect\n    wpeOAuth: wpeOAuthService,\n    capi: capiService,\n    // Phase 11c: Sync services\n    wpePush: wpePushService,\n    wpePull: wpePullService,\n    connectHistory: connectHistoryService,\n    wpeConnectBase: wpeConnectBaseService,\n    // Note: Phase 10 Cloud Backup services are accessed via IPC to the Cloud Backups addon\n    // (backupService, dropbox, googleDrive, featureFlags, userData)\n  } = services;\n\n  // Helper to invoke IPC calls to the Cloud Backups addon\n  // This uses the same pattern as the BackupAIBridge\n  // Timeout constants for backup operations (in milliseconds)\n  const BACKUP_IPC_TIMEOUT = 600000; // 10 minutes for backup operations\n  const DEFAULT_IPC_TIMEOUT = 30000; // 30 seconds for quick operations\n\n  const invokeBackupIPC = async (\n    channel: string,\n    timeoutMs: number = BACKUP_IPC_TIMEOUT,\n    ...args: any[]\n  ): Promise<any> => {\n    return new Promise((resolve, reject) => {\n      const timestamp = Date.now();\n      const random = Math.random().toString(36).substr(2, 9);\n      const successReplyChannel = `${channel}-success-${timestamp}-${random}`;\n      const errorReplyChannel = `${channel}-error-${timestamp}-${random}`;\n\n      const timeoutSeconds = Math.round(timeoutMs / 1000);\n      const timeout = setTimeout(() => {\n        ipcMain.removeAllListeners(successReplyChannel);\n        ipcMain.removeAllListeners(errorReplyChannel);\n        reject(new Error(`IPC call to ${channel} timed out after ${timeoutSeconds} seconds`));\n      }, timeoutMs);\n\n      ipcMain.once(successReplyChannel, (_event: any, result: any) => {\n        clearTimeout(timeout);\n        ipcMain.removeAllListeners(errorReplyChannel);\n        localLogger.info(`[${ADDON_NAME}] IPC success from ${channel}`);\n        resolve({ result });\n      });\n\n      ipcMain.once(errorReplyChannel, (_event: any, error: any) => {\n        clearTimeout(timeout);\n        ipcMain.removeAllListeners(successReplyChannel);\n        localLogger.error(`[${ADDON_NAME}] IPC error from ${channel}: ${error?.message}`);\n        resolve({ error });\n      });\n\n      const mockEvent = {\n        reply: (replyChannel: string, data: any) => {\n          ipcMain.emit(replyChannel, null, data);\n        },\n        sender: {\n          send: (replyChannel: string, data: any) => {\n            ipcMain.emit(replyChannel, null, data);\n          },\n        },\n      };\n\n      const replyChannels = { successReplyChannel, errorReplyChannel };\n      localLogger.info(`[${ADDON_NAME}] Invoking backup IPC: ${channel}`);\n      ipcMain.emit(channel, mockEvent, replyChannels, ...args);\n    });\n  };\n\n  // Helper to get backup providers from the Cloud Backups addon\n  const getBackupProviders = async (): Promise<Array<{ id: string; name: string }>> => {\n    try {\n      const result = await invokeBackupIPC('backups:enabled-providers', DEFAULT_IPC_TIMEOUT);\n      localLogger.info(`[${ADDON_NAME}] Raw IPC result: ${JSON.stringify(result)}`);\n\n      if (result.error) {\n        localLogger.error(\n          `[${ADDON_NAME}] Failed to get backup providers: ${result.error.message}`\n        );\n        return [];\n      }\n\n      // The response is double-nested: result.result.result contains the array\n      // Structure: { result: { result: [providers...] } }\n      let providers: any = result.result;\n\n      // Unwrap nested result if present\n      if (providers && typeof providers === 'object' && !Array.isArray(providers)) {\n        if (Array.isArray(providers.result)) {\n          providers = providers.result;\n        } else if (providers.result && typeof providers.result === 'object') {\n          // Even deeper nesting\n          providers = providers.result;\n        }\n      }\n\n      localLogger.info(`[${ADDON_NAME}] Extracted providers: ${JSON.stringify(providers)}`);\n\n      if (Array.isArray(providers)) {\n        localLogger.info(`[${ADDON_NAME}] Got ${providers.length} backup providers`);\n        return providers;\n      }\n\n      localLogger.warn(\n        `[${ADDON_NAME}] Unexpected providers format after unwrapping: ${typeof providers}`\n      );\n      return [];\n    } catch (error: any) {\n      localLogger.error(`[${ADDON_NAME}] Error getting backup providers: ${error.message}`);\n      return [];\n    }\n  };\n\n  // Shared WP-CLI execution logic\n  const executeWpCli = async (\n    _parent: any,\n    args: { input: { siteId: string; args: string[]; skipPlugins?: boolean; skipThemes?: boolean } }\n  ) => {\n    const { siteId, args: wpArgs, skipPlugins = true, skipThemes = true } = args.input;\n\n    try {\n      localLogger.info(`[${ADDON_NAME}] Running WP-CLI: wp ${wpArgs.join(' ')}`);\n\n      const site = siteData.getSite(siteId);\n      if (!site) {\n        return {\n          success: false,\n          output: null,\n          error: `Site not found: ${siteId}`,\n        };\n      }\n\n      const status = await siteProcessManager.getSiteStatus(site);\n      if (status !== 'running') {\n        return {\n          success: false,\n          output: null,\n          error: `Site \"${site.name}\" is not running. Start it first with: local-cli start ${site.name}`,\n        };\n      }\n\n      const output = await wpCli.run(site, wpArgs, {\n        skipPlugins,\n        skipThemes,\n        ignoreErrors: false,\n      });\n\n      localLogger.info(`[${ADDON_NAME}] WP-CLI completed successfully`);\n\n      return {\n        success: true,\n        output: output?.trim() || '',\n        error: null,\n      };\n    } catch (error: any) {\n      localLogger.error(`[${ADDON_NAME}] WP-CLI failed:`, error);\n      return {\n        success: false,\n        output: null,\n        error: error.message || 'Unknown error',\n      };\n    }\n  };\n\n  return {\n    Query: {\n      wpCliQuery: executeWpCli,\n\n      blueprints: async () => {\n        try {\n          localLogger.info(`[${ADDON_NAME}] Fetching blueprints`);\n\n          const blueprintsList = await blueprintsService.getBlueprints();\n\n          return {\n            success: true,\n            error: null,\n            blueprints: blueprintsList.map((bp: any) => ({\n              name: bp.name,\n              lastModified: bp.lastModified,\n              // Handle nested objects - extract just the name/type string\n              phpVersion:\n                typeof bp.phpVersion === 'object'\n                  ? bp.phpVersion?.name || bp.phpVersion?.version\n                  : bp.phpVersion,\n              webServer:\n                typeof bp.webServer === 'object'\n                  ? bp.webServer?.name || bp.webServer?.type\n                  : bp.webServer,\n              database:\n                typeof bp.database === 'object'\n                  ? bp.database?.name || bp.database?.type\n                  : bp.database,\n            })),\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to fetch blueprints:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n            blueprints: [],\n          };\n        }\n      },\n\n      listServices: async (_parent: any, args: { type?: string }) => {\n        const { type = 'all' } = args;\n\n        try {\n          localLogger.info(`[${ADDON_NAME}] Listing services (type: ${type})`);\n\n          if (!lightningServices) {\n            return {\n              success: false,\n              error: 'Lightning services not available',\n              services: [],\n            };\n          }\n\n          const roleMap: Record<string, string> = {\n            php: 'php',\n            database: 'mysql',\n            webserver: 'nginx',\n          };\n\n          const roleFilter = type !== 'all' ? roleMap[type] : undefined;\n          const registeredServices = lightningServices.getRegisteredServices(roleFilter);\n\n          const serviceList: Array<{ role: string; name: string; version: string }> = [];\n\n          for (const [role, versions] of Object.entries(registeredServices)) {\n            for (const [version, info] of Object.entries(versions as Record<string, any>)) {\n              serviceList.push({\n                role,\n                name: info?.name || role,\n                version,\n              });\n            }\n          }\n\n          return {\n            success: true,\n            error: null,\n            services: serviceList,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to list services:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n            services: [],\n          };\n        }\n      },\n\n      // Phase 11: WP Engine Connect\n      wpeStatus: async () => {\n        try {\n          localLogger.info(`[${ADDON_NAME}] Checking WP Engine authentication status`);\n\n          if (!wpeOAuthService) {\n            return {\n              authenticated: false,\n              email: null,\n              accountId: null,\n              accountName: null,\n              tokenExpiry: null,\n              error: 'WP Engine OAuth service not available',\n            };\n          }\n\n          // Check if we have valid credentials by trying to get access token\n          const accessToken = await wpeOAuthService.getAccessToken();\n\n          if (!accessToken) {\n            return {\n              authenticated: false,\n              email: null,\n              accountId: null,\n              accountName: null,\n              tokenExpiry: null,\n              error: null,\n            };\n          }\n\n          // Try to get user info from CAPI if available\n          let email = null;\n          if (capiService) {\n            try {\n              const currentUser = await capiService.getCurrentUser();\n              email = currentUser?.email || null;\n            } catch {\n              // User info not available, but still authenticated\n            }\n          }\n\n          return {\n            authenticated: true,\n            email,\n            accountId: null,\n            accountName: null,\n            tokenExpiry: null,\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to check WPE status:`, error);\n          return {\n            authenticated: false,\n            email: null,\n            accountId: null,\n            accountName: null,\n            tokenExpiry: null,\n            error: error.message || 'Unknown error',\n          };\n        }\n      },\n\n      listWpeSites: async (_parent: any, args: { accountId?: string }) => {\n        const { accountId } = args;\n\n        try {\n          localLogger.info(\n            `[${ADDON_NAME}] Listing WP Engine sites${accountId ? ` for account ${accountId}` : ''}`\n          );\n\n          if (!wpeOAuthService) {\n            return {\n              success: false,\n              error: 'WP Engine OAuth service not available',\n              sites: [],\n              count: 0,\n            };\n          }\n\n          // Check if authenticated by trying to get access token\n          const accessToken = await wpeOAuthService.getAccessToken();\n          if (!accessToken) {\n            return {\n              success: false,\n              error: 'Not authenticated with WP Engine. Use wpe_authenticate first.',\n              sites: [],\n              count: 0,\n            };\n          }\n\n          if (!capiService) {\n            return {\n              success: false,\n              error: 'WP Engine CAPI service not available',\n              sites: [],\n              count: 0,\n            };\n          }\n\n          // Get installs from CAPI using getInstallList\n          const installs = await capiService.getInstallList();\n\n          if (!installs) {\n            return {\n              success: true,\n              error: null,\n              sites: [],\n              count: 0,\n            };\n          }\n\n          const sites = installs.map((install: any) => ({\n            id: install.id,\n            name: install.name,\n            environment: install.environment || 'production',\n            phpVersion: install.phpVersion || null,\n            primaryDomain: install.primaryDomain || install.cname || null,\n            accountId: install.accountId || accountId || null,\n            accountName: install.accountName || null,\n            sftpHost: `${install.name}.ssh.wpengine.net`,\n            sftpUser: install.name,\n          }));\n\n          return {\n            success: true,\n            error: null,\n            sites,\n            count: sites.length,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to list WPE sites:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n            sites: [],\n            count: 0,\n          };\n        }\n      },\n\n      // Phase 11b: Site Linking\n      getWpeLink: async (_parent: any, args: { siteId: string }) => {\n        const { siteId } = args;\n\n        try {\n          localLogger.info(`[${ADDON_NAME}] Getting WP Engine link for site ${siteId}`);\n\n          // Get site from siteData\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              linked: false,\n              siteName: null,\n              connections: [],\n              connectionCount: 0,\n              message: null,\n              error: `Site not found: ${siteId}`,\n            };\n          }\n\n          // Get hostConnections from site\n          const hostConnections = site.hostConnections || [];\n          const wpeConnections = hostConnections.filter((c: any) => c.hostId === 'wpe');\n\n          if (wpeConnections.length === 0) {\n            return {\n              linked: false,\n              siteName: site.name,\n              connections: [],\n              connectionCount: 0,\n              message:\n                'Site is not linked to any WP Engine environment. Use Connect in Local to pull a site from WPE.',\n              error: null,\n            };\n          }\n\n          // Transform connections for output, enriching with CAPI data if available\n          const connections = await Promise.all(\n            wpeConnections.map(async (c: any) => {\n              let installName = c.remoteSiteId; // Default to UUID\n              let portalUrl = null;\n              let primaryDomain = null;\n\n              // Try to get install details from CAPI to get the actual name\n              // remoteSiteId matches install.site.id (WPE Site ID), not install.id\n              if (capiService && typeof capiService.getInstallList === 'function') {\n                try {\n                  localLogger.info(\n                    `[${ADDON_NAME}] Looking for install with site.id=${c.remoteSiteId}, env=${c.remoteSiteEnv}`\n                  );\n                  const installs = await capiService.getInstallList();\n                  localLogger.info(\n                    `[${ADDON_NAME}] Got ${installs?.length || 0} installs from CAPI`\n                  );\n                  if (installs && installs.length > 0) {\n                    // Log first install structure for debugging\n                    localLogger.info(\n                      `[${ADDON_NAME}] Sample install structure: ${JSON.stringify(installs[0], null, 2)}`\n                    );\n\n                    // Match by site.id (remoteSiteId is the WPE Site ID, not Install ID)\n                    // Also filter by environment if available\n                    const matchingInstall = installs.find(\n                      (i: any) =>\n                        i.site?.id === c.remoteSiteId &&\n                        (!c.remoteSiteEnv || i.environment === c.remoteSiteEnv)\n                    );\n\n                    if (matchingInstall) {\n                      localLogger.info(`[${ADDON_NAME}] Found match: ${matchingInstall.name}`);\n                      installName = matchingInstall.name;\n                      portalUrl = `https://my.wpengine.com/installs/${matchingInstall.name}`;\n                      primaryDomain =\n                        matchingInstall.primary_domain || matchingInstall.cname || null;\n                    } else {\n                      localLogger.warn(\n                        `[${ADDON_NAME}] No matching install found for site.id=${c.remoteSiteId}`\n                      );\n                    }\n                  }\n                } catch (e: any) {\n                  localLogger.warn(\n                    `[${ADDON_NAME}] Could not look up install from CAPI: ${e.message}`\n                  );\n                }\n              } else {\n                localLogger.warn(`[${ADDON_NAME}] capiService or getInstallList not available`);\n              }\n\n              return {\n                remoteInstallId: c.remoteSiteId,\n                installName,\n                environment: c.remoteSiteEnv || null,\n                accountId: c.accountId || null,\n                portalUrl,\n                primaryDomain,\n              };\n            })\n          );\n\n          // Capabilities are always the same for WPE-connected sites\n          const capabilities = {\n            canPush: true,\n            canPull: true,\n            syncModes: ['all_files', 'select_files', 'database_only'],\n            magicSyncAvailable: true,\n            databaseSyncAvailable: true,\n          };\n\n          return {\n            linked: true,\n            siteName: site.name,\n            connections,\n            connectionCount: connections.length,\n            capabilities,\n            message: null,\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to get WPE link:`, error);\n          return {\n            linked: false,\n            siteName: null,\n            connections: [],\n            connectionCount: 0,\n            message: null,\n            error: error.message || 'Unknown error',\n          };\n        }\n      },\n\n      // Phase 10: Cloud Backups\n      backupStatus: async () => {\n        try {\n          localLogger.info(`[${ADDON_NAME}] Checking backup status`);\n\n          // Get providers from Cloud Backups addon via IPC\n          const providers = await getBackupProviders();\n          localLogger.info(`[${ADDON_NAME}] Got ${providers.length} backup providers`);\n\n          if (providers.length === 0) {\n            return {\n              available: false,\n              featureEnabled: false,\n              dropbox: null,\n              googleDrive: null,\n              message:\n                'No cloud storage providers configured. Connect Google Drive or Dropbox in Local Hub (hub.localwp.com/addons/cloud-backups).',\n              error: null,\n            };\n          }\n\n          // Map provider info to our response format\n          const dropboxProvider = providers.find(\n            (p: any) => p.id === 'dropbox' || p.name?.toLowerCase().includes('dropbox')\n          ) as any;\n          const googleProvider = providers.find(\n            (p: any) => p.id === 'google' || p.name?.toLowerCase().includes('google')\n          ) as any;\n\n          const dropboxStatus = dropboxProvider\n            ? {\n                authenticated: true,\n                accountId: dropboxProvider.id,\n                email: dropboxProvider.email || null,\n              }\n            : {\n                authenticated: false,\n                accountId: null as string | null,\n                email: null as string | null,\n              };\n\n          const googleDriveStatus = googleProvider\n            ? {\n                authenticated: true,\n                accountId: googleProvider.id,\n                email: googleProvider.email || null,\n              }\n            : {\n                authenticated: false,\n                accountId: null as string | null,\n                email: null as string | null,\n              };\n\n          const hasProvider = providers.length > 0;\n\n          return {\n            available: hasProvider,\n            featureEnabled: true,\n            dropbox: dropboxStatus,\n            googleDrive: googleDriveStatus,\n            message: hasProvider\n              ? null\n              : 'No cloud storage provider authenticated. Connect Dropbox or Google Drive in Local settings.',\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to check backup status:`, error);\n          return {\n            available: false,\n            featureEnabled: false,\n            dropbox: null,\n            googleDrive: null,\n            message: null,\n            error: error.message || 'Unknown error',\n          };\n        }\n      },\n\n      listBackups: async (_parent: any, args: { siteId: string; provider: string }) => {\n        const { siteId, provider } = args;\n\n        try {\n          localLogger.info(`[${ADDON_NAME}] Listing backups for site ${siteId} from ${provider}`);\n\n          // Get site\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              siteName: null,\n              provider,\n              backups: [],\n              count: 0,\n              error: `Site not found: ${siteId}`,\n            };\n          }\n\n          // Get providers from Cloud Backups addon\n          const providers = await getBackupProviders();\n          if (providers.length === 0) {\n            return {\n              success: false,\n              siteName: site.name,\n              provider,\n              backups: [],\n              count: 0,\n              error:\n                'No cloud storage providers configured. Connect Google Drive or Dropbox in Local Hub.',\n            };\n          }\n\n          // Find the matching provider (map 'googleDrive' to 'google' for the addon)\n          const providerMap: Record<string, string> = { googleDrive: 'google', dropbox: 'dropbox' };\n          const providerId = providerMap[provider] || provider;\n          const matchedProvider = providers.find((p: any) => p.id === providerId);\n\n          if (!matchedProvider) {\n            return {\n              success: false,\n              siteName: site.name,\n              provider,\n              backups: [],\n              count: 0,\n              error: `Provider '${provider}' not configured. Available: ${providers.map((p: any) => p.name).join(', ')}`,\n            };\n          }\n\n          // For listing snapshots, use the Hub provider ID directly (e.g., 'google')\n          // NOT the rclone backend name ('drive') - the Hub queries expect the OAuth provider name\n          // Also pass pageOffset parameter (0 for first page)\n          const result = await invokeBackupIPC(\n            'backups:provider-snapshots',\n            DEFAULT_IPC_TIMEOUT,\n            siteId,\n            matchedProvider.id,\n            0\n          );\n          localLogger.info(\n            `[${ADDON_NAME}] Provider snapshots raw result: ${JSON.stringify(result)}`\n          );\n\n          if (result.error) {\n            return {\n              success: false,\n              siteName: site.name,\n              provider,\n              backups: [],\n              count: 0,\n              error: result.error.message || 'Failed to list backups',\n            };\n          }\n\n          // Unwrap nested result structure (similar to providers)\n          let backupsData = result.result;\n          if (backupsData && typeof backupsData === 'object' && !Array.isArray(backupsData)) {\n            // Check for nested result or snapshots array\n            if (Array.isArray(backupsData.result)) {\n              backupsData = backupsData.result;\n            } else if (Array.isArray(backupsData.snapshots)) {\n              backupsData = backupsData.snapshots;\n            } else if (backupsData.result && Array.isArray(backupsData.result.snapshots)) {\n              backupsData = backupsData.result.snapshots;\n            }\n          }\n\n          const backups = Array.isArray(backupsData) ? backupsData : [];\n          localLogger.info(`[${ADDON_NAME}] Extracted ${backups.length} backups`);\n\n          return {\n            success: true,\n            siteName: site.name,\n            provider,\n            backups: backups.map((b: any) => ({\n              // Use hash for snapshotId as that's what restic uses for restore/delete operations\n              // The Hub ID (b.id) is just a database identifier\n              snapshotId: b.hash || b.snapshotId || b.short_id,\n              timestamp: b.updatedAt || b.createdAt || b.timestamp || b.time || b.created,\n              note:\n                b.configObject?.description || b.note || b.description || b.tags?.description || '',\n              siteDomain: b.configObject?.name\n                ? `${b.configObject.name}.local`\n                : b.siteDomain || site.domain,\n              services: JSON.stringify(b.configObject?.services || b.services || {}),\n            })),\n            count: backups.length,\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to list backups:`, error);\n          return {\n            success: false,\n            siteName: null,\n            provider,\n            backups: [],\n            count: 0,\n            error: error.message || 'Unknown error',\n          };\n        }\n      },\n\n      // Phase 11c: Sync History\n      getSyncHistory: async (_parent: any, args: { siteId: string; limit?: number }) => {\n        const { siteId, limit = 30 } = args;\n\n        try {\n          localLogger.info(`[${ADDON_NAME}] Getting sync history for site ${siteId}`);\n\n          // Get site to verify it exists\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              siteName: null,\n              events: [],\n              count: 0,\n              error: `Site not found: ${siteId}`,\n            };\n          }\n\n          // Check if connectHistory service is available\n          if (!connectHistoryService || typeof connectHistoryService.getEvents !== 'function') {\n            return {\n              success: false,\n              siteName: site.name,\n              events: [],\n              count: 0,\n              error: 'Sync history service not available',\n            };\n          }\n\n          const events = connectHistoryService.getEvents(siteId);\n          const limitedEvents = events.slice(0, limit);\n\n          return {\n            success: true,\n            siteName: site.name,\n            events: limitedEvents.map((e: any) => ({\n              remoteInstallName: e.remoteInstallName || null,\n              timestamp: e.timestamp,\n              environment: e.environment,\n              direction: e.direction,\n              status: e.status || null,\n            })),\n            count: limitedEvents.length,\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to get sync history:`, error);\n          return {\n            success: false,\n            siteName: null,\n            events: [],\n            count: 0,\n            error: error.message || 'Unknown error',\n          };\n        }\n      },\n\n      // Get file changes between local and WPE (dry-run comparison)\n      getSiteChanges: async (_parent: any, args: { siteId: string; direction?: string }) => {\n        const { siteId, direction = 'push' } = args;\n\n        try {\n          localLogger.info(\n            `[${ADDON_NAME}] Getting site changes for ${siteId}, direction=${direction}`\n          );\n\n          // Validate direction\n          if (direction !== 'push' && direction !== 'pull') {\n            return {\n              success: false,\n              siteName: null,\n              direction,\n              added: [],\n              modified: [],\n              deleted: [],\n              totalChanges: 0,\n              message: null,\n              error: 'Invalid direction. Must be \"push\" or \"pull\".',\n            };\n          }\n\n          // Get site\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              siteName: null,\n              direction,\n              added: [],\n              modified: [],\n              deleted: [],\n              totalChanges: 0,\n              message: null,\n              error: `Site not found: ${siteId}`,\n            };\n          }\n\n          // Check WPE connection\n          const wpeConnection = site.hostConnections?.find((c: any) => c.hostId === 'wpe');\n          if (!wpeConnection) {\n            return {\n              success: false,\n              siteName: site.name,\n              direction,\n              added: [],\n              modified: [],\n              deleted: [],\n              totalChanges: 0,\n              message: null,\n              error:\n                'Site is not linked to WP Engine. Use Connect in Local to link the site first.',\n            };\n          }\n\n          // Check service availability\n          if (\n            !wpeConnectBaseService ||\n            typeof wpeConnectBaseService.listModifications !== 'function'\n          ) {\n            return {\n              success: false,\n              siteName: site.name,\n              direction,\n              added: [],\n              modified: [],\n              deleted: [],\n              totalChanges: 0,\n              message: null,\n              error: 'WPE Connect service not available',\n            };\n          }\n\n          // Get install details from CAPI\n          let installName = wpeConnection.remoteSiteId;\n          let primaryDomain = '';\n          let installId = '';\n\n          if (capiService && typeof capiService.getInstallList === 'function') {\n            const installs = await capiService.getInstallList();\n            const matchingInstall = installs?.find(\n              (i: any) =>\n                i.site?.id === wpeConnection.remoteSiteId &&\n                (!wpeConnection.remoteSiteEnv || i.environment === wpeConnection.remoteSiteEnv)\n            );\n            if (matchingInstall) {\n              installName = matchingInstall.name;\n              primaryDomain =\n                matchingInstall.primary_domain ||\n                matchingInstall.cname ||\n                `${matchingInstall.name}.wpengine.com`;\n              installId = matchingInstall.id;\n            }\n          }\n\n          if (!primaryDomain) {\n            return {\n              success: false,\n              siteName: site.name,\n              direction,\n              added: [],\n              modified: [],\n              deleted: [],\n              totalChanges: 0,\n              message: null,\n              error:\n                'Could not determine WP Engine install details. Please ensure you are authenticated.',\n            };\n          }\n\n          // Call listModifications (dry-run rsync comparison)\n          localLogger.info(`[${ADDON_NAME}] Calling listModifications for ${installName}`);\n          const modifications = await wpeConnectBaseService.listModifications({\n            connectArgs: {\n              wpengineInstallName: installName,\n              wpengineInstallId: installId,\n              wpengineSiteId: wpeConnection.remoteSiteId,\n              wpenginePrimaryDomain: primaryDomain,\n              localSiteId: site.id,\n            },\n            direction: direction as 'push' | 'pull',\n            includeIgnored: false,\n          });\n\n          // Categorize changes\n          const added = modifications\n            .filter(\n              (f: any) =>\n                f.instruction === 'create' ||\n                f.instruction === 'upload' ||\n                f.instruction === 'download'\n            )\n            .map((f: any) => ({\n              path: f.path,\n              instruction: f.instruction,\n              size: f.size,\n              type: f.type,\n            }));\n\n          const modified = modifications\n            .filter((f: any) => f.instruction === 'modify')\n            .map((f: any) => ({\n              path: f.path,\n              instruction: f.instruction,\n              size: f.size,\n              type: f.type,\n            }));\n\n          const deleted = modifications\n            .filter((f: any) => f.instruction === 'delete')\n            .map((f: any) => ({\n              path: f.path,\n              instruction: f.instruction,\n              size: f.size,\n              type: f.type,\n            }));\n\n          const totalChanges = added.length + modified.length + deleted.length;\n          const directionLabel = direction === 'push' ? 'local → WPE' : 'WPE → local';\n\n          return {\n            success: true,\n            siteName: site.name,\n            direction,\n            added,\n            modified,\n            deleted,\n            totalChanges,\n            message:\n              totalChanges > 0\n                ? `${totalChanges} file(s) changed (${directionLabel}): ${added.length} added, ${modified.length} modified, ${deleted.length} deleted`\n                : `No changes detected (${directionLabel})`,\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to get site changes:`, error);\n          return {\n            success: false,\n            siteName: null,\n            direction,\n            added: [],\n            modified: [],\n            deleted: [],\n            totalChanges: 0,\n            message: null,\n            error: error.message || 'Unknown error',\n          };\n        }\n      },\n    },\n    Mutation: {\n      wpCli: executeWpCli,\n\n      createSite: async (\n        _parent: any,\n        args: {\n          input: {\n            name: string;\n            phpVersion?: string;\n            webServer?: string;\n            database?: string;\n            wpAdminUsername?: string;\n            wpAdminPassword?: string;\n            wpAdminEmail?: string;\n            blueprint?: string;\n          };\n        }\n      ) => {\n        // DEBUG: Log raw args received\n        localLogger.info(`[${ADDON_NAME}] createSite called with args: ${JSON.stringify(args)}`);\n\n        const {\n          name,\n          phpVersion,\n          webServer = 'nginx',\n          database = 'mysql',\n          wpAdminUsername = 'admin',\n          wpAdminPassword = 'password',\n          wpAdminEmail = 'admin@local.test',\n          blueprint,\n        } = args.input;\n\n        // DEBUG: Log destructured values\n        localLogger.info(\n          `[${ADDON_NAME}] Destructured - name: ${name}, blueprint: ${blueprint}, typeof blueprint: ${typeof blueprint}`\n        );\n\n        try {\n          localLogger.info(\n            `[${ADDON_NAME}] Creating site: ${name}${blueprint ? ` from blueprint: ${blueprint}` : ''}`\n          );\n\n          // Generate slug and domain from name\n          const siteSlug = name\n            .toLowerCase()\n            .replace(/[^a-z0-9]+/g, '-')\n            .replace(/^-|-$/g, '');\n          const siteDomain = `${siteSlug}.local`;\n\n          const os = require('os');\n          const path = require('path');\n          const fs = require('fs');\n          const sitePath = path.join(os.homedir(), 'Local Sites', siteSlug);\n\n          // If blueprint is provided, use importSiteService instead of addSiteService\n          if (blueprint) {\n            localLogger.info(`[${ADDON_NAME}] Blueprint parameter received: ${blueprint}`);\n\n            // Get the userDataPath from electron app\n            const { app } = require('electron');\n            const userDataPath = app.getPath('userData');\n            const blueprintZipPath = path.join(userDataPath, 'blueprints', `${blueprint}.zip`);\n\n            localLogger.info(`[${ADDON_NAME}] Looking for blueprint at: ${blueprintZipPath}`);\n\n            // Verify blueprint exists\n            if (!fs.existsSync(blueprintZipPath)) {\n              localLogger.error(`[${ADDON_NAME}] Blueprint not found at: ${blueprintZipPath}`);\n              return {\n                success: false,\n                error: `Blueprint not found: ${blueprint}. Use list_blueprints to see available blueprints.`,\n                siteId: null,\n                siteName: name,\n                siteDomain: null,\n              };\n            }\n\n            localLogger.info(`[${ADDON_NAME}] Found blueprint at: ${blueprintZipPath}`);\n\n            // Read the local-site.json from the blueprint zip to get manifest\n            let localSiteJSON: any;\n            try {\n              const StreamZip = require('node-stream-zip');\n              localLogger.info(`[${ADDON_NAME}] node-stream-zip loaded successfully`);\n\n              const zip = new StreamZip.async({ file: blueprintZipPath });\n              const entries = await zip.entries();\n              localLogger.info(\n                `[${ADDON_NAME}] Zip entries loaded, count: ${Object.keys(entries).length}`\n              );\n\n              const filename = entries['local-site.json']\n                ? 'local-site.json'\n                : 'pressmatic-site.json';\n              localLogger.info(`[${ADDON_NAME}] Reading manifest file: ${filename}`);\n\n              const data = await zip.entryData(filename);\n              localSiteJSON = JSON.parse(data.toString('utf8'));\n              await zip.close();\n              localLogger.info(\n                `[${ADDON_NAME}] Successfully read manifest:`,\n                JSON.stringify(localSiteJSON).substring(0, 200)\n              );\n            } catch (zipError: any) {\n              localLogger.error(\n                `[${ADDON_NAME}] Failed to read blueprint zip: ${zipError.message}`,\n                zipError\n              );\n              return {\n                success: false,\n                error: `Failed to read blueprint manifest: ${zipError.message}`,\n                siteId: null,\n                siteName: name,\n                siteDomain: null,\n              };\n            }\n\n            // Build import settings\n            const importSettings: any = {\n              siteName: name,\n              siteDomain: siteDomain,\n              sitePath: sitePath,\n              zip: blueprintZipPath,\n              importData: {\n                type: 'local-blueprint',\n                oldSite: localSiteJSON,\n              },\n              environment: localSiteJSON.environment || 'flywheel',\n              blueprint: blueprint,\n            };\n\n            // Copy service versions from blueprint if available\n            if (localSiteJSON.services) {\n              // Extract PHP version\n              const phpService = Object.values(localSiteJSON.services).find(\n                (s: any) => s.role === 'php'\n              ) as any;\n              if (phpService) {\n                importSettings.phpVersion = phpService.version;\n              }\n\n              // Extract database\n              const dbService = Object.values(localSiteJSON.services).find(\n                (s: any) => s.role === 'database' || s.role === 'db'\n              ) as any;\n              if (dbService) {\n                importSettings.database = `${dbService.name}-${dbService.version}`;\n              }\n\n              // Extract web server\n              const webService = Object.values(localSiteJSON.services).find(\n                (s: any) => s.role === 'http' || s.role === 'web'\n              ) as any;\n              if (webService) {\n                importSettings.webServer = `${webService.name}-${webService.version}`;\n              }\n            } else if (localSiteJSON.phpVersion) {\n              importSettings.phpVersion = localSiteJSON.phpVersion;\n            }\n\n            localLogger.info(\n              `[${ADDON_NAME}] Import settings prepared:`,\n              JSON.stringify(importSettings).substring(0, 500)\n            );\n\n            if (!importSiteService) {\n              localLogger.error(`[${ADDON_NAME}] importSiteService is not available!`);\n              return {\n                success: false,\n                error: 'Import service not available',\n                siteId: null,\n                siteName: name,\n                siteDomain: null,\n              };\n            }\n\n            localLogger.info(`[${ADDON_NAME}] Calling importSiteService.run()...`);\n\n            // Use the importSiteService to create from blueprint\n            const importResult = await importSiteService.run(importSettings);\n\n            localLogger.info(\n              `[${ADDON_NAME}] Import result:`,\n              JSON.stringify(importResult || 'null').substring(0, 500)\n            );\n\n            if (importResult && importResult.id) {\n              localLogger.info(\n                `[${ADDON_NAME}] Successfully created site from blueprint: ${name} (${importResult.id})`\n              );\n              return {\n                success: true,\n                error: null,\n                siteId: importResult.id,\n                siteName: name,\n                siteDomain: siteDomain,\n              };\n            } else {\n              localLogger.warn(`[${ADDON_NAME}] Import returned but no site ID found`);\n              return {\n                success: true,\n                error: null,\n                siteId: null,\n                siteName: name,\n                siteDomain: siteDomain,\n              };\n            }\n          }\n\n          // No blueprint - create a fresh site\n          const newSiteInfo: any = {\n            siteName: name,\n            siteDomain: siteDomain,\n            sitePath: sitePath,\n            webServer: webServer,\n            database: database,\n          };\n\n          if (phpVersion) {\n            newSiteInfo.phpVersion = phpVersion;\n          }\n\n          const wpCredentials = {\n            adminUsername: wpAdminUsername,\n            adminPassword: wpAdminPassword,\n            adminEmail: wpAdminEmail,\n          };\n\n          const site = await addSiteService.addSite({\n            newSiteInfo,\n            wpCredentials,\n            goToSite: false,\n          });\n\n          localLogger.info(`[${ADDON_NAME}] Successfully created site: ${name} (${site.id})`);\n\n          return {\n            success: true,\n            error: null,\n            siteId: site.id,\n            siteName: name,\n            siteDomain: siteDomain,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to create site:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n            siteId: null,\n            siteName: name,\n            siteDomain: null,\n          };\n        }\n      },\n\n      deleteSite: async (\n        _parent: any,\n        args: { input: { id: string; trashFiles?: boolean; updateHosts?: boolean } }\n      ) => {\n        const { id, trashFiles = true, updateHosts = true } = args.input;\n\n        try {\n          localLogger.info(`[${ADDON_NAME}] Deleting site: ${id}`);\n\n          const site = siteData.getSite(id);\n          if (!site) {\n            return {\n              success: false,\n              error: `Site not found: ${id}`,\n              siteId: id,\n            };\n          }\n\n          await deleteSiteService.deleteSite({\n            site,\n            trashFiles,\n            updateHosts,\n          });\n\n          localLogger.info(`[${ADDON_NAME}] Successfully deleted site: ${site.name}`);\n\n          return {\n            success: true,\n            error: null,\n            siteId: id,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to delete site:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n            siteId: id,\n          };\n        }\n      },\n\n      deleteSites: async (_parent: any, args: { ids: string[]; trashFiles?: boolean }) => {\n        const { ids, trashFiles = true } = args;\n\n        try {\n          localLogger.info(`[${ADDON_NAME}] Deleting ${ids.length} sites`);\n\n          await deleteSiteService.deleteSites({\n            siteIds: ids,\n            trashFiles,\n            updateHosts: true,\n          });\n\n          localLogger.info(`[${ADDON_NAME}] Successfully deleted ${ids.length} sites`);\n\n          return {\n            success: true,\n            error: null,\n            siteId: ids.join(','),\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to delete sites:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n            siteId: ids.join(','),\n          };\n        }\n      },\n\n      openSite: async (_parent: any, args: { input: { siteId: string; path?: string } }) => {\n        const { siteId, path = '/' } = args.input;\n\n        try {\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              error: `Site not found: ${siteId}`,\n              url: null,\n            };\n          }\n\n          // Check if site is running\n          const status = await siteProcessManager.getSiteStatus(site);\n          if (status !== 'running') {\n            return {\n              success: false,\n              error: `Site \"${site.name}\" must be running to open in browser. Start it first.`,\n              url: null,\n            };\n          }\n\n          const protocol = site.isStarred ? 'https' : 'http';\n          const url = `${protocol}://${site.domain}${path}`;\n\n          localLogger.info(`[${ADDON_NAME}] Opening site in browser: ${url}`);\n\n          if (browserManager) {\n            await browserManager.openInBrowser(url);\n          } else {\n            // Fallback to shell.openExternal\n            const { shell } = require('electron');\n            await shell.openExternal(url);\n          }\n\n          return {\n            success: true,\n            error: null,\n            url,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to open site:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n            url: null,\n          };\n        }\n      },\n\n      cloneSite: async (_parent: any, args: { input: { siteId: string; newName: string } }) => {\n        const { siteId, newName } = args.input;\n\n        try {\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              error: `Site not found: ${siteId}`,\n              newSiteId: null,\n              newSiteName: null,\n              newSiteDomain: null,\n            };\n          }\n\n          // Check if site is running - needed for database cloning\n          const status = await siteProcessManager.getSiteStatus(site);\n          if (status !== 'running') {\n            return {\n              success: false,\n              error: `Site \"${site.name}\" must be running to clone. Start it first.`,\n              newSiteId: null,\n              newSiteName: null,\n              newSiteDomain: null,\n            };\n          }\n\n          localLogger.info(`[${ADDON_NAME}] Cloning site ${site.name} to ${newName}`);\n\n          const newSite = await cloneSiteService.cloneSite({\n            site,\n            newSiteName: newName,\n          });\n\n          localLogger.info(\n            `[${ADDON_NAME}] Successfully cloned site: ${newSite.name} (${newSite.id})`\n          );\n\n          return {\n            success: true,\n            error: null,\n            newSiteId: newSite.id,\n            newSiteName: newSite.name,\n            newSiteDomain: newSite.domain,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to clone site:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n            newSiteId: null,\n            newSiteName: null,\n            newSiteDomain: null,\n          };\n        }\n      },\n\n      exportSite: async (\n        _parent: any,\n        args: { input: { siteId: string; outputPath?: string } }\n      ) => {\n        const { siteId, outputPath } = args.input;\n        const os = require('os');\n        const path = require('path');\n\n        try {\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              error: `Site not found: ${siteId}`,\n              exportPath: null,\n            };\n          }\n\n          // Check if site is running - needed for database export\n          const status = await siteProcessManager.getSiteStatus(site);\n          if (status !== 'running') {\n            return {\n              success: false,\n              error: `Site \"${site.name}\" must be running to export. Start it first.`,\n              exportPath: null,\n            };\n          }\n\n          // Default to Downloads folder\n          const outputDir = outputPath || path.join(os.homedir(), 'Downloads');\n          const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);\n          const fileName = `${site.name}-${timestamp}.zip`;\n          const fullPath = path.join(outputDir, fileName);\n\n          localLogger.info(`[${ADDON_NAME}] Exporting site ${site.name} to ${fullPath}`);\n\n          // Use default export filter (excludes archive files)\n          const defaultExportFilter = '*.zip, *.tar.gz, *.bz2, *.tgz';\n\n          await exportSiteService.exportSite({\n            site,\n            outputPath: fullPath,\n            filter: defaultExportFilter,\n          });\n\n          localLogger.info(`[${ADDON_NAME}] Successfully exported site to: ${fullPath}`);\n\n          return {\n            success: true,\n            error: null,\n            exportPath: fullPath,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to export site:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n            exportPath: null,\n          };\n        }\n      },\n\n      saveBlueprint: async (_parent: any, args: { input: { siteId: string; name: string } }) => {\n        const { siteId, name } = args.input;\n\n        try {\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              error: `Site not found: ${siteId}`,\n              blueprintName: null,\n            };\n          }\n\n          // Check if site is running - needed for database export\n          const status = await siteProcessManager.getSiteStatus(site);\n          if (status !== 'running') {\n            return {\n              success: false,\n              error: `Site \"${site.name}\" must be running to save as blueprint. Start it first.`,\n              blueprintName: null,\n            };\n          }\n\n          localLogger.info(`[${ADDON_NAME}] Saving site ${site.name} as blueprint: ${name}`);\n\n          // Use default export filter (excludes archive files)\n          const defaultFilter = '*.zip, *.tar.gz, *.bz2, *.tgz';\n\n          await blueprintsService.saveBlueprint({\n            name,\n            siteId,\n            filter: defaultFilter,\n          });\n\n          localLogger.info(`[${ADDON_NAME}] Successfully saved blueprint: ${name}`);\n\n          return {\n            success: true,\n            error: null,\n            blueprintName: name,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to save blueprint:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n            blueprintName: null,\n          };\n        }\n      },\n\n      // Phase 8: WordPress Development Tools\n      exportDatabase: async (\n        _parent: any,\n        args: { input: { siteId: string; outputPath?: string } }\n      ) => {\n        const { siteId, outputPath } = args.input;\n        const os = require('os');\n        const pathModule = require('path');\n\n        try {\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              error: `Site not found: ${siteId}`,\n              outputPath: null,\n            };\n          }\n\n          // Check if site is running - database must be accessible\n          const status = await siteProcessManager.getSiteStatus(site);\n          if (status !== 'running') {\n            return {\n              success: false,\n              error: `Site \"${site.name}\" must be running to export database. Start it first.`,\n              outputPath: null,\n            };\n          }\n\n          // Default to Downloads folder with site name\n          const defaultPath = pathModule.join(\n            os.homedir(),\n            'Downloads',\n            `${site.name.replace(/[^a-z0-9]/gi, '-')}.sql`\n          );\n          const finalPath = outputPath || defaultPath;\n\n          localLogger.info(`[${ADDON_NAME}] Exporting database for ${site.name} to ${finalPath}`);\n\n          // Use siteDatabase.dump() which properly sets up MySQL environment\n          if (!siteDatabase) {\n            return {\n              success: false,\n              error: 'Database service not available',\n              outputPath: null,\n            };\n          }\n\n          await siteDatabase.dump(site, finalPath);\n\n          localLogger.info(`[${ADDON_NAME}] Successfully exported database to: ${finalPath}`);\n\n          return {\n            success: true,\n            error: null,\n            outputPath: finalPath,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to export database:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n            outputPath: null,\n          };\n        }\n      },\n\n      importDatabase: async (\n        _parent: any,\n        args: { input: { siteId: string; sqlPath: string } }\n      ) => {\n        const { siteId, sqlPath } = args.input;\n        const fs = require('fs');\n\n        try {\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              error: `Site not found: ${siteId}`,\n            };\n          }\n\n          if (!fs.existsSync(sqlPath)) {\n            return {\n              success: false,\n              error: `SQL file not found: ${sqlPath}`,\n            };\n          }\n\n          // Check if site is running - database must be accessible\n          const status = await siteProcessManager.getSiteStatus(site);\n          if (status !== 'running') {\n            return {\n              success: false,\n              error: `Site \"${site.name}\" must be running to import database. Start it first.`,\n            };\n          }\n\n          localLogger.info(`[${ADDON_NAME}] Importing database for ${site.name} from ${sqlPath}`);\n\n          // Use importSQLFile service which properly sets up MySQL environment\n          if (!importSQLFileService) {\n            return {\n              success: false,\n              error: 'Import SQL file service not available',\n            };\n          }\n\n          await importSQLFileService(site, sqlPath);\n\n          localLogger.info(`[${ADDON_NAME}] Successfully imported database from: ${sqlPath}`);\n\n          return {\n            success: true,\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to import database:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n          };\n        }\n      },\n\n      openAdminer: async (_parent: any, args: { input: { siteId: string } }) => {\n        const { siteId } = args.input;\n\n        try {\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              error: `Site not found: ${siteId}`,\n            };\n          }\n\n          // Check if site is running - database must be accessible\n          const status = await siteProcessManager.getSiteStatus(site);\n          if (status !== 'running') {\n            return {\n              success: false,\n              error: `Site \"${site.name}\" must be running to open Adminer. Start it first.`,\n            };\n          }\n\n          localLogger.info(`[${ADDON_NAME}] Opening Adminer for ${site.name}`);\n\n          if (adminer) {\n            await adminer.open(site);\n          } else {\n            return {\n              success: false,\n              error: 'Adminer service not available',\n            };\n          }\n\n          return {\n            success: true,\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to open Adminer:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n          };\n        }\n      },\n\n      trustSsl: async (_parent: any, args: { input: { siteId: string } }) => {\n        const { siteId } = args.input;\n\n        try {\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              error: `Site not found: ${siteId}`,\n            };\n          }\n\n          localLogger.info(`[${ADDON_NAME}] Trusting SSL for ${site.name}`);\n\n          if (x509Cert) {\n            await x509Cert.trustCert(site);\n          } else {\n            return {\n              success: false,\n              error: 'X509 certificate service not available',\n            };\n          }\n\n          return {\n            success: true,\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to trust SSL:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n          };\n        }\n      },\n\n      mcpRenameSite: async (_parent: any, args: { input: { siteId: string; newName: string } }) => {\n        const { siteId, newName } = args.input;\n\n        try {\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              error: `Site not found: ${siteId}`,\n              newName: null,\n            };\n          }\n\n          localLogger.info(`[${ADDON_NAME}] Renaming ${site.name} to ${newName}`);\n\n          // Update site name via siteData\n          site.name = newName;\n          await siteData.updateSite(siteId, { name: newName });\n\n          localLogger.info(`[${ADDON_NAME}] Successfully renamed site to: ${newName}`);\n\n          return {\n            success: true,\n            error: null,\n            newName,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to rename site:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n            newName: null,\n          };\n        }\n      },\n\n      changePhpVersion: async (\n        _parent: any,\n        args: { input: { siteId: string; phpVersion: string } }\n      ) => {\n        const { siteId, phpVersion } = args.input;\n\n        try {\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              error: `Site not found: ${siteId}`,\n              phpVersion: null,\n            };\n          }\n\n          localLogger.info(\n            `[${ADDON_NAME}] Changing PHP version for ${site.name} to ${phpVersion}`\n          );\n\n          if (siteProvisioner) {\n            await siteProvisioner.swapService(site, 'php', phpVersion);\n          } else {\n            return {\n              success: false,\n              error: 'Site provisioner service not available',\n              phpVersion: null,\n            };\n          }\n\n          localLogger.info(`[${ADDON_NAME}] Successfully changed PHP version to: ${phpVersion}`);\n\n          return {\n            success: true,\n            error: null,\n            phpVersion,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to change PHP version:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n            phpVersion: null,\n          };\n        }\n      },\n\n      importSite: async (_parent: any, args: { input: { zipPath: string; siteName?: string } }) => {\n        const { zipPath, siteName } = args.input;\n        const fs = require('fs');\n\n        try {\n          if (!fs.existsSync(zipPath)) {\n            return {\n              success: false,\n              error: `Zip file not found: ${zipPath}`,\n              siteId: null,\n              siteName: null,\n            };\n          }\n\n          localLogger.info(`[${ADDON_NAME}] Importing site from ${zipPath}`);\n\n          if (!importSiteService) {\n            return {\n              success: false,\n              error: 'Import site service not available',\n              siteId: null,\n              siteName: null,\n            };\n          }\n\n          const result = await importSiteService.run({\n            zipPath,\n            siteName: siteName || undefined,\n          });\n\n          localLogger.info(`[${ADDON_NAME}] Successfully imported site: ${result.name}`);\n\n          return {\n            success: true,\n            error: null,\n            siteId: result.id,\n            siteName: result.name,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to import site:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n            siteId: null,\n            siteName: null,\n          };\n        }\n      },\n\n      // Phase 9: Site Configuration & Dev Tools\n      toggleXdebug: async (_parent: any, args: { input: { siteId: string; enabled: boolean } }) => {\n        const { siteId, enabled } = args.input;\n\n        try {\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              error: `Site not found: ${siteId}`,\n              enabled: null,\n            };\n          }\n\n          localLogger.info(\n            `[${ADDON_NAME}] ${enabled ? 'Enabling' : 'Disabling'} Xdebug for ${site.name}`\n          );\n\n          // Update the site's xdebugEnabled property\n          await siteData.updateSite(siteId, { xdebugEnabled: enabled });\n\n          // Restart the site if it's running to apply the change\n          const status = await siteProcessManager.getSiteStatus(site);\n          if (status === 'running') {\n            localLogger.info(`[${ADDON_NAME}] Restarting site to apply Xdebug change`);\n            await siteProcessManager.restart(site);\n          }\n\n          localLogger.info(\n            `[${ADDON_NAME}] Successfully ${enabled ? 'enabled' : 'disabled'} Xdebug`\n          );\n\n          return {\n            success: true,\n            error: null,\n            enabled,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to toggle Xdebug:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n            enabled: null,\n          };\n        }\n      },\n\n      getSiteLogs: async (\n        _parent: any,\n        args: { input: { siteId: string; logType?: string; lines?: number } }\n      ) => {\n        const { siteId, logType = 'php', lines = 100 } = args.input;\n        const fs = require('fs');\n        const fsPromises = fs.promises;\n        const pathModule = require('path');\n\n        // Helper for async file existence check\n        const fileExists = async (filePath: string): Promise<boolean> => {\n          try {\n            await fsPromises.access(filePath);\n            return true;\n          } catch {\n            return false;\n          }\n        };\n\n        // Helper to read last N lines of a file\n        const readLastLines = async (filePath: string, numLines: number): Promise<string> => {\n          try {\n            const content = await fsPromises.readFile(filePath, 'utf-8');\n            const logLines = content.split('\\n');\n            return logLines.slice(-numLines).join('\\n') || '(empty)';\n          } catch {\n            return '';\n          }\n        };\n\n        try {\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              error: `Site not found: ${siteId}`,\n              logs: [],\n            };\n          }\n\n          localLogger.info(`[${ADDON_NAME}] Getting ${logType} logs for ${site.name}`);\n\n          const logs: Array<{ type: string; content: string; path: string }> = [];\n          const logsDir = pathModule.join(site.path, 'logs');\n\n          const logFiles: Record<string, string[]> = {\n            php: ['php', 'php-fpm'],\n            nginx: ['nginx'],\n            mysql: ['mysql'],\n            all: ['php', 'php-fpm', 'nginx', 'mysql'],\n          };\n\n          const targetLogs = logFiles[logType] || logFiles.php;\n\n          for (const logName of targetLogs) {\n            // Check for error and access logs\n            for (const suffix of ['error.log', 'access.log', '.log']) {\n              const logPath = pathModule.join(\n                logsDir,\n                `${logName}${suffix === '.log' ? '' : '/'}${suffix}`\n              );\n              const altLogPath = pathModule.join(logsDir, `${logName}${suffix}`);\n\n              let finalPath: string | null = null;\n              if (await fileExists(logPath)) {\n                finalPath = logPath;\n              } else if (await fileExists(altLogPath)) {\n                finalPath = altLogPath;\n              }\n\n              if (finalPath) {\n                const content = await readLastLines(finalPath, lines);\n                if (content) {\n                  logs.push({\n                    type: logName,\n                    content,\n                    path: finalPath,\n                  });\n                }\n              }\n            }\n          }\n\n          if (logs.length === 0) {\n            // Try to find any log files\n            if (await fileExists(logsDir)) {\n              const entries = await fsPromises.readdir(logsDir, { withFileTypes: true });\n              for (const entry of entries) {\n                if (entry.isDirectory()) {\n                  const subDir = pathModule.join(logsDir, entry.name);\n                  const subEntries = await fsPromises.readdir(subDir);\n                  for (const subFile of subEntries) {\n                    if (subFile.endsWith('.log')) {\n                      const logPath = pathModule.join(subDir, subFile);\n                      const content = await readLastLines(logPath, lines);\n                      if (content) {\n                        logs.push({\n                          type: entry.name,\n                          content,\n                          path: logPath,\n                        });\n                      }\n                    }\n                  }\n                } else if (entry.name.endsWith('.log')) {\n                  const logPath = pathModule.join(logsDir, entry.name);\n                  const content = await readLastLines(logPath, lines);\n                  if (content) {\n                    logs.push({\n                      type: entry.name.replace('.log', ''),\n                      content,\n                      path: logPath,\n                    });\n                  }\n                }\n              }\n            }\n          }\n\n          return {\n            success: true,\n            error: null,\n            logs,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to get logs:`, error);\n          return {\n            success: false,\n            error: error.message || 'Unknown error',\n            logs: [],\n          };\n        }\n      },\n\n      // Phase 10: Cloud Backup Mutations\n      createBackup: async (\n        _parent: any,\n        args: { siteId: string; provider: string; note?: string }\n      ) => {\n        const { siteId, provider, note } = args;\n\n        try {\n          localLogger.info(`[${ADDON_NAME}] Creating backup for site ${siteId} to ${provider}`);\n\n          // Get site\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              snapshotId: null,\n              timestamp: null,\n              message: null,\n              error: `Site not found: ${siteId}`,\n            };\n          }\n\n          // Get providers from Cloud Backups addon\n          const providers = await getBackupProviders();\n          if (providers.length === 0) {\n            return {\n              success: false,\n              snapshotId: null,\n              timestamp: null,\n              message: null,\n              error:\n                'No cloud storage providers configured. Connect Google Drive or Dropbox in Local Hub.',\n            };\n          }\n\n          // Find the matching provider (map 'googleDrive' to 'google' for the addon)\n          const providerMap: Record<string, string> = { googleDrive: 'google', dropbox: 'dropbox' };\n          const providerId = providerMap[provider] || provider;\n          const matchedProvider = providers.find((p: any) => p.id === providerId);\n\n          if (!matchedProvider) {\n            return {\n              success: false,\n              snapshotId: null,\n              timestamp: null,\n              message: null,\n              error: `Provider '${provider}' not configured. Available: ${providers.map((p: any) => p.name).join(', ')}`,\n            };\n          }\n\n          // Map the Hub provider ID to rclone backend name\n          // The addon uses 'google' in enabled-providers but expects 'drive' for backup operations\n          const backupProviderMap: Record<string, string> = { google: 'drive', dropbox: 'dropbox' };\n          const backupProviderId = backupProviderMap[matchedProvider.id] || matchedProvider.id;\n          localLogger.info(\n            `[${ADDON_NAME}] Using backup provider ID: ${backupProviderId} (from ${matchedProvider.id})`\n          );\n\n          // Create backup via IPC (use long timeout for backup operations)\n          const description = note || 'Backup created via MCP';\n          const result = await invokeBackupIPC(\n            'backups:backup-site',\n            BACKUP_IPC_TIMEOUT,\n            siteId,\n            backupProviderId,\n            description\n          );\n          localLogger.info(`[${ADDON_NAME}] Backup IPC result: ${JSON.stringify(result)}`);\n\n          // Check for top-level IPC error\n          if (result.error) {\n            return {\n              success: false,\n              snapshotId: null,\n              timestamp: null,\n              message: null,\n              error: result.error.message || 'Backup creation failed',\n            };\n          }\n\n          // Unwrap nested result structure - the actual result is at result.result\n          const backupResult = result.result;\n\n          // Check if the backup result contains an error (nested at result.result.error)\n          if (backupResult?.error) {\n            const errorMsg =\n              backupResult.error.message || backupResult.error.original?.message || 'Backup failed';\n            return {\n              success: false,\n              snapshotId: null,\n              timestamp: null,\n              message: null,\n              error: errorMsg,\n            };\n          }\n\n          // Try to extract snapshot ID (may be nested in result.result.result)\n          let snapshotId = backupResult?.snapshotId || backupResult?.id;\n          if (!snapshotId && backupResult?.result) {\n            snapshotId = backupResult.result.snapshotId || backupResult.result.id;\n          }\n\n          // If no error was returned, the backup succeeded even if no snapshot ID is provided\n          // The addon doesn't always return the snapshot ID in its IPC response\n          return {\n            success: true,\n            snapshotId: snapshotId || null,\n            timestamp: new Date().toISOString(),\n            message: `Backup created successfully to ${matchedProvider.name}`,\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to create backup:`, error);\n          return {\n            success: false,\n            snapshotId: null,\n            timestamp: null,\n            message: null,\n            error: error.message || 'Unknown error',\n          };\n        }\n      },\n\n      restoreBackup: async (\n        _parent: any,\n        args: { siteId: string; provider: string; snapshotId: string; confirm?: boolean }\n      ) => {\n        const { siteId, provider, snapshotId, confirm = false } = args;\n\n        try {\n          localLogger.info(`[${ADDON_NAME}] Restoring backup ${snapshotId} for site ${siteId}`);\n\n          // Check confirmation\n          if (!confirm) {\n            return {\n              success: false,\n              message: null,\n              error:\n                'Restore requires confirm=true to prevent accidental data loss. Current site files and database will be overwritten.',\n            };\n          }\n\n          // Get site\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              message: null,\n              error: `Site not found: ${siteId}`,\n            };\n          }\n\n          // Get providers from Cloud Backups addon\n          const providers = await getBackupProviders();\n          if (providers.length === 0) {\n            return {\n              success: false,\n              message: null,\n              error:\n                'No cloud storage providers configured. Connect Google Drive or Dropbox in Local Hub.',\n            };\n          }\n\n          // Find the matching provider (map 'googleDrive' to 'google' for the addon)\n          const providerMap: Record<string, string> = { googleDrive: 'google', dropbox: 'dropbox' };\n          const providerId = providerMap[provider] || provider;\n          const matchedProvider = providers.find((p: any) => p.id === providerId);\n\n          if (!matchedProvider) {\n            return {\n              success: false,\n              message: null,\n              error: `Provider '${provider}' not configured. Available: ${providers.map((p: any) => p.name).join(', ')}`,\n            };\n          }\n\n          // Map the Hub provider ID to rclone backend name\n          const backupProviderMap: Record<string, string> = { google: 'drive', dropbox: 'dropbox' };\n          const backupProviderId = backupProviderMap[matchedProvider.id] || matchedProvider.id;\n\n          // Restore backup via IPC (use long timeout for restore operations)\n          const result = await invokeBackupIPC(\n            'backups:restore-backup',\n            BACKUP_IPC_TIMEOUT,\n            siteId,\n            backupProviderId,\n            snapshotId\n          );\n          localLogger.info(`[${ADDON_NAME}] Restore result: ${JSON.stringify(result)}`);\n\n          // Check for errors - can be at result.error or result.result.error (IPC async pattern)\n          const ipcError = result.error || result.result?.error;\n          if (ipcError) {\n            const errorMessage =\n              typeof ipcError === 'string' ? ipcError : ipcError.message || 'Restore failed';\n            return {\n              success: false,\n              message: null,\n              error: errorMessage,\n            };\n          }\n\n          return {\n            success: true,\n            message: `Site restored from backup ${snapshotId}`,\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to restore backup:`, error);\n          return {\n            success: false,\n            message: null,\n            error: error.message || 'Unknown error',\n          };\n        }\n      },\n\n      deleteBackup: async (\n        _parent: any,\n        args: { siteId: string; provider: string; snapshotId: string; confirm?: boolean }\n      ) => {\n        const { siteId, provider, snapshotId, confirm = false } = args;\n\n        try {\n          localLogger.info(`[${ADDON_NAME}] Deleting backup ${snapshotId} for site ${siteId}`);\n\n          // Check confirmation\n          if (!confirm) {\n            return {\n              success: false,\n              deletedSnapshotId: null,\n              message: null,\n              error: 'Delete requires confirm=true to prevent accidental deletion.',\n            };\n          }\n\n          // Get site\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              deletedSnapshotId: null,\n              message: null,\n              error: `Site not found: ${siteId}`,\n            };\n          }\n\n          // Get providers from Cloud Backups addon\n          const providers = await getBackupProviders();\n          if (providers.length === 0) {\n            return {\n              success: false,\n              deletedSnapshotId: null,\n              message: null,\n              error:\n                'No cloud storage providers configured. Connect Google Drive or Dropbox in Local Hub.',\n            };\n          }\n\n          // Find the matching provider (map 'googleDrive' to 'google' for the addon)\n          const providerMap: Record<string, string> = { googleDrive: 'google', dropbox: 'dropbox' };\n          const providerId = providerMap[provider] || provider;\n          const matchedProvider = providers.find((p: any) => p.id === providerId);\n\n          if (!matchedProvider) {\n            return {\n              success: false,\n              deletedSnapshotId: null,\n              message: null,\n              error: `Provider '${provider}' not configured. Available: ${providers.map((p: any) => p.name).join(', ')}`,\n            };\n          }\n\n          // Map the Hub provider ID to rclone backend name\n          const backupProviderMap: Record<string, string> = { google: 'drive', dropbox: 'dropbox' };\n          const backupProviderId = backupProviderMap[matchedProvider.id] || matchedProvider.id;\n\n          // Try to delete backup via IPC (may not be supported by the addon)\n          const result = await invokeBackupIPC(\n            'backups:delete-backup',\n            DEFAULT_IPC_TIMEOUT,\n            siteId,\n            backupProviderId,\n            snapshotId\n          );\n\n          if (result.error) {\n            // If the IPC channel doesn't exist or isn't supported, provide helpful message\n            if (result.error.message?.includes('timed out')) {\n              return {\n                success: false,\n                deletedSnapshotId: null,\n                message: null,\n                error:\n                  'Delete backup operation is not available via MCP. Please delete backups through the Local UI.',\n              };\n            }\n            return {\n              success: false,\n              deletedSnapshotId: null,\n              message: null,\n              error: result.error.message || 'Delete failed',\n            };\n          }\n\n          return {\n            success: true,\n            deletedSnapshotId: snapshotId,\n            message: 'Backup deleted',\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to delete backup:`, error);\n          return {\n            success: false,\n            deletedSnapshotId: null,\n            message: null,\n            error: error.message || 'Unknown error',\n          };\n        }\n      },\n\n      downloadBackup: async (\n        _parent: any,\n        args: { siteId: string; provider: string; snapshotId: string }\n      ) => {\n        const { siteId, provider, snapshotId } = args;\n\n        try {\n          localLogger.info(`[${ADDON_NAME}] Downloading backup ${snapshotId} for site ${siteId}`);\n\n          // Get site\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              filePath: null,\n              message: null,\n              error: `Site not found: ${siteId}`,\n            };\n          }\n\n          // Get providers from Cloud Backups addon\n          const providers = await getBackupProviders();\n          if (providers.length === 0) {\n            return {\n              success: false,\n              filePath: null,\n              message: null,\n              error:\n                'No cloud storage providers configured. Connect Google Drive or Dropbox in Local Hub.',\n            };\n          }\n\n          // Find the matching provider (map 'googleDrive' to 'google' for the addon)\n          const providerMap: Record<string, string> = { googleDrive: 'google', dropbox: 'dropbox' };\n          const providerId = providerMap[provider] || provider;\n          const matchedProvider = providers.find((p: any) => p.id === providerId);\n\n          if (!matchedProvider) {\n            return {\n              success: false,\n              filePath: null,\n              message: null,\n              error: `Provider '${provider}' not configured. Available: ${providers.map((p: any) => p.name).join(', ')}`,\n            };\n          }\n\n          // Map the Hub provider ID to rclone backend name\n          const backupProviderMap: Record<string, string> = { google: 'drive', dropbox: 'dropbox' };\n          const backupProviderId = backupProviderMap[matchedProvider.id] || matchedProvider.id;\n\n          // Try to download backup via IPC (use long timeout for downloads)\n          const result = await invokeBackupIPC(\n            'backups:download-backup',\n            BACKUP_IPC_TIMEOUT,\n            siteId,\n            backupProviderId,\n            snapshotId\n          );\n\n          if (result.error) {\n            // If the IPC channel doesn't exist or isn't supported, provide helpful message\n            if (result.error.message?.includes('timed out')) {\n              return {\n                success: false,\n                filePath: null,\n                message: null,\n                error:\n                  'Download backup operation is not available via MCP. Please download backups through the Local UI.',\n              };\n            }\n            return {\n              success: false,\n              filePath: null,\n              message: null,\n              error: result.error.message || 'Download failed',\n            };\n          }\n\n          return {\n            success: true,\n            filePath: result.result?.filePath || null,\n            message: 'Backup downloaded to Downloads folder',\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to download backup:`, error);\n          return {\n            success: false,\n            filePath: null,\n            message: null,\n            error: error.message || 'Unknown error',\n          };\n        }\n      },\n\n      editBackupNote: async (\n        _parent: any,\n        args: { siteId: string; provider: string; snapshotId: string; note: string }\n      ) => {\n        const { siteId, provider, snapshotId, note } = args;\n\n        try {\n          localLogger.info(`[${ADDON_NAME}] Editing backup note for ${snapshotId}`);\n\n          // Get site\n          const site = siteData.getSite(siteId);\n          if (!site) {\n            return {\n              success: false,\n              snapshotId: null,\n              note: null,\n              error: `Site not found: ${siteId}`,\n            };\n          }\n\n          // Get providers from Cloud Backups addon\n          const providers = await getBackupProviders();\n          if (providers.length === 0) {\n            return {\n              success: false,\n              snapshotId: null,\n              note: null,\n              error:\n                'No cloud storage providers configured. Connect Google Drive or Dropbox in Local Hub.',\n            };\n          }\n\n          // Find the matching provider (map 'googleDrive' to 'google' for the addon)\n          const providerMap: Record<string, string> = { googleDrive: 'google', dropbox: 'dropbox' };\n          const providerId = providerMap[provider] || provider;\n          const matchedProvider = providers.find((p: any) => p.id === providerId);\n\n          if (!matchedProvider) {\n            return {\n              success: false,\n              snapshotId: null,\n              note: null,\n              error: `Provider '${provider}' not configured. Available: ${providers.map((p: any) => p.name).join(', ')}`,\n            };\n          }\n\n          // Map the Hub provider ID to rclone backend name\n          const backupProviderMap: Record<string, string> = { google: 'drive', dropbox: 'dropbox' };\n          const backupProviderId = backupProviderMap[matchedProvider.id] || matchedProvider.id;\n\n          // Try to edit backup note via IPC (quick metadata operation)\n          const result = await invokeBackupIPC(\n            'backups:edit-note',\n            DEFAULT_IPC_TIMEOUT,\n            siteId,\n            backupProviderId,\n            snapshotId,\n            note\n          );\n\n          if (result.error) {\n            // If the IPC channel doesn't exist or isn't supported, provide helpful message\n            if (result.error.message?.includes('timed out')) {\n              return {\n                success: false,\n                snapshotId: null,\n                note: null,\n                error:\n                  'Edit backup note operation is not available via MCP. Please edit backup notes through the Local UI.',\n              };\n            }\n            return {\n              success: false,\n              snapshotId: null,\n              note: null,\n              error: result.error.message || 'Edit note failed',\n            };\n          }\n\n          return {\n            success: true,\n            snapshotId,\n            note,\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to edit backup note:`, error);\n          return {\n            success: false,\n            snapshotId: null,\n            note: null,\n            error: error.message || 'Unknown error',\n          };\n        }\n      },\n\n      // Phase 11: WP Engine Connect\n      wpeAuthenticate: async () => {\n        try {\n          localLogger.info(`[${ADDON_NAME}] Initiating WP Engine authentication`);\n\n          if (!wpeOAuthService) {\n            return {\n              success: false,\n              email: null,\n              message: null,\n              error: 'WP Engine OAuth service not available',\n            };\n          }\n\n          // Trigger OAuth flow - this will open browser for user consent\n          // authenticate() returns OAuthTokens on success\n          const tokens = await wpeOAuthService.authenticate();\n\n          if (tokens && tokens.accessToken) {\n            // Try to get user email from CAPI\n            let email = null;\n            if (capiService) {\n              try {\n                const currentUser = await capiService.getCurrentUser();\n                email = currentUser?.email || null;\n              } catch {\n                // User info not available\n              }\n            }\n\n            localLogger.info(\n              `[${ADDON_NAME}] Successfully authenticated with WPE${email ? ` as ${email}` : ''}`\n            );\n            return {\n              success: true,\n              email,\n              message: 'Successfully authenticated with WP Engine',\n              error: null,\n            };\n          }\n\n          return {\n            success: true,\n            email: null,\n            message: 'Authentication initiated. Please complete the login in your browser.',\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] WPE authentication failed:`, error);\n          return {\n            success: false,\n            email: null,\n            message: null,\n            error: error.message || 'Authentication failed',\n          };\n        }\n      },\n\n      wpeLogout: async () => {\n        try {\n          localLogger.info(`[${ADDON_NAME}] Logging out from WP Engine`);\n\n          if (!wpeOAuthService) {\n            return {\n              success: false,\n              message: null,\n              error: 'WP Engine OAuth service not available',\n            };\n          }\n\n          // clearTokens() is the logout method\n          await wpeOAuthService.clearTokens();\n\n          localLogger.info(`[${ADDON_NAME}] Successfully logged out from WPE`);\n          return {\n            success: true,\n            message: 'Logged out from WP Engine',\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] WPE logout failed:`, error);\n          return {\n            success: false,\n            message: null,\n            error: error.message || 'Logout failed',\n          };\n        }\n      },\n\n      // Phase 11c: Push to WP Engine\n      pushToWpe: async (\n        _parent: any,\n        args: {\n          localSiteId: string;\n          remoteInstallId: string;\n          includeSql?: boolean;\n          confirm?: boolean;\n        }\n      ) => {\n        const { localSiteId, remoteInstallId, includeSql = false, confirm = false } = args;\n\n        try {\n          localLogger.info(\n            `[${ADDON_NAME}] Push to WPE: site=${localSiteId}, remote=${remoteInstallId}, includeSql=${includeSql}`\n          );\n\n          // Require confirmation for push operations\n          if (!confirm) {\n            return {\n              success: false,\n              message: null,\n              error:\n                'Push requires confirm=true to prevent accidental overwrites. Set confirm=true to proceed.',\n            };\n          }\n\n          // Verify site exists\n          const site = siteData.getSite(localSiteId);\n          if (!site) {\n            return {\n              success: false,\n              message: null,\n              error: `Site not found: ${localSiteId}`,\n            };\n          }\n\n          // Check WPE connection exists\n          const wpeConnection = site.hostConnections?.find((c: any) => c.hostId === 'wpe');\n          if (!wpeConnection) {\n            return {\n              success: false,\n              message: null,\n              error:\n                'Site is not linked to WP Engine. Use Connect in Local to link the site first.',\n            };\n          }\n\n          // Check push service availability\n          if (!wpePushService || typeof wpePushService.push !== 'function') {\n            return {\n              success: false,\n              message: null,\n              error: 'WPE Push service not available',\n            };\n          }\n\n          // Get install details from CAPI to get required parameters\n          let installName = remoteInstallId;\n          let primaryDomain = '';\n          let installId = '';\n\n          if (capiService && typeof capiService.getInstallList === 'function') {\n            const installs = await capiService.getInstallList();\n            const matchingInstall = installs?.find(\n              (i: any) =>\n                i.site?.id === wpeConnection.remoteSiteId &&\n                (!wpeConnection.remoteSiteEnv || i.environment === wpeConnection.remoteSiteEnv)\n            );\n            if (matchingInstall) {\n              installName = matchingInstall.name;\n              primaryDomain =\n                matchingInstall.primary_domain ||\n                matchingInstall.cname ||\n                `${matchingInstall.name}.wpengine.com`;\n              installId = matchingInstall.id;\n            }\n          }\n\n          if (!primaryDomain) {\n            return {\n              success: false,\n              message: null,\n              error:\n                'Could not determine WP Engine install details. Please ensure you are authenticated.',\n            };\n          }\n\n          // Start the push operation (async - returns immediately)\n          wpePushService\n            .push({\n              includeSql,\n              wpengineInstallName: installName,\n              wpengineInstallId: installId,\n              wpengineSiteId: wpeConnection.remoteSiteId,\n              wpenginePrimaryDomain: primaryDomain,\n              localSiteId: site.id,\n              environment: wpeConnection.remoteSiteEnv,\n              isMagicSync: false,\n            })\n            .catch((err: any) => {\n              localLogger.error(`[${ADDON_NAME}] Push failed:`, err);\n            });\n\n          return {\n            success: true,\n            message: `Push started to ${installName}. Check Local UI for progress.`,\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to start push:`, error);\n          return {\n            success: false,\n            message: null,\n            error: error.message || 'Failed to start push',\n          };\n        }\n      },\n\n      // Phase 11c: Pull from WP Engine\n      pullFromWpe: async (\n        _parent: any,\n        args: {\n          localSiteId: string;\n          remoteInstallId: string;\n          includeSql?: boolean;\n        }\n      ) => {\n        const { localSiteId, remoteInstallId, includeSql = false } = args;\n\n        try {\n          localLogger.info(\n            `[${ADDON_NAME}] Pull from WPE: site=${localSiteId}, remote=${remoteInstallId}, includeSql=${includeSql}`\n          );\n\n          // Verify site exists\n          const site = siteData.getSite(localSiteId);\n          if (!site) {\n            return {\n              success: false,\n              message: null,\n              error: `Site not found: ${localSiteId}`,\n            };\n          }\n\n          // Check WPE connection exists\n          const wpeConnection = site.hostConnections?.find((c: any) => c.hostId === 'wpe');\n          if (!wpeConnection) {\n            return {\n              success: false,\n              message: null,\n              error:\n                'Site is not linked to WP Engine. Use Connect in Local to link the site first.',\n            };\n          }\n\n          // Check pull service availability\n          if (!wpePullService || typeof wpePullService.pull !== 'function') {\n            return {\n              success: false,\n              message: null,\n              error: 'WPE Pull service not available',\n            };\n          }\n\n          // Get install details from CAPI\n          let installName = remoteInstallId;\n          let primaryDomain = '';\n          let installId = '';\n\n          if (capiService && typeof capiService.getInstallList === 'function') {\n            const installs = await capiService.getInstallList();\n            const matchingInstall = installs?.find(\n              (i: any) =>\n                i.site?.id === wpeConnection.remoteSiteId &&\n                (!wpeConnection.remoteSiteEnv || i.environment === wpeConnection.remoteSiteEnv)\n            );\n            if (matchingInstall) {\n              installName = matchingInstall.name;\n              primaryDomain =\n                matchingInstall.primary_domain ||\n                matchingInstall.cname ||\n                `${matchingInstall.name}.wpengine.com`;\n              installId = matchingInstall.id;\n            }\n          }\n\n          if (!primaryDomain) {\n            return {\n              success: false,\n              message: null,\n              error:\n                'Could not determine WP Engine install details. Please ensure you are authenticated.',\n            };\n          }\n\n          // Start the pull operation (async - returns immediately)\n          wpePullService\n            .pull({\n              includeSql,\n              wpengineInstallName: installName,\n              wpengineInstallId: installId,\n              wpengineSiteId: wpeConnection.remoteSiteId,\n              wpenginePrimaryDomain: primaryDomain,\n              localSiteId: site.id,\n              environment: wpeConnection.remoteSiteEnv,\n              isMagicSync: false,\n            })\n            .catch((err: any) => {\n              localLogger.error(`[${ADDON_NAME}] Pull failed:`, err);\n            });\n\n          return {\n            success: true,\n            message: `Pull started from ${installName}. Check Local UI for progress.`,\n            error: null,\n          };\n        } catch (error: any) {\n          localLogger.error(`[${ADDON_NAME}] Failed to start pull:`, error);\n          return {\n            success: false,\n            message: null,\n            error: error.message || 'Failed to start pull',\n          };\n        }\n      },\n    },\n  };\n}\n\n/**\n * Start the MCP server\n */\nasync function startMcpServer(services: LocalServices, logger: any): Promise<void> {\n  if (mcpServer) {\n    logger.warn(`[${ADDON_NAME}] MCP server already running`);\n    return;\n  }\n\n  try {\n    mcpServer = new McpServer({ port: MCP_SERVER.DEFAULT_PORT }, services, logger);\n\n    await mcpServer.start();\n\n    const info = mcpServer.getConnectionInfo();\n    logger.info(`[${ADDON_NAME}] MCP server started on port ${info.port}`);\n    logger.info(\n      `[${ADDON_NAME}] MCP connection info saved to: ~/Library/Application Support/Local/mcp-connection-info.json`\n    );\n    logger.info(`[${ADDON_NAME}] Available tools: ${info.tools.join(', ')}`);\n  } catch (error: any) {\n    logger.error(`[${ADDON_NAME}] Failed to start MCP server:`, error);\n  }\n}\n\n/**\n * Stop the MCP server\n */\nasync function stopMcpServer(logger: any): Promise<void> {\n  if (mcpServer) {\n    await mcpServer.stop();\n    mcpServer = null;\n    logger.info(`[${ADDON_NAME}] MCP server stopped`);\n  }\n}\n\n/**\n * Register IPC handlers for renderer communication\n */\nfunction registerIpcHandlers(services: LocalServices, logger: any): void {\n  // Get MCP server status\n  ipcMain.handle('mcp:getStatus', async () => {\n    if (!mcpServer) {\n      return { running: false, port: 0, uptime: 0 };\n    }\n    return mcpServer.getStatus();\n  });\n\n  // Get connection info\n  ipcMain.handle('mcp:getConnectionInfo', async () => {\n    if (!mcpServer) {\n      return null;\n    }\n    return mcpServer.getConnectionInfo();\n  });\n\n  // Start MCP server\n  ipcMain.handle('mcp:start', async () => {\n    try {\n      await startMcpServer(services, logger);\n      return { success: true };\n    } catch (error: any) {\n      return { success: false, error: error.message };\n    }\n  });\n\n  // Stop MCP server\n  ipcMain.handle('mcp:stop', async () => {\n    try {\n      await stopMcpServer(logger);\n      return { success: true };\n    } catch (error: any) {\n      return { success: false, error: error.message };\n    }\n  });\n\n  // Restart MCP server\n  ipcMain.handle('mcp:restart', async () => {\n    try {\n      await stopMcpServer(logger);\n      await startMcpServer(services, logger);\n      return { success: true };\n    } catch (error: any) {\n      return { success: false, error: error.message };\n    }\n  });\n\n  // Regenerate auth token\n  ipcMain.handle('mcp:regenerateToken', async () => {\n    if (!mcpServer) {\n      return { success: false, error: 'MCP server not running' };\n    }\n    try {\n      const newToken = await mcpServer.regenerateToken();\n      return { success: true, token: newToken };\n    } catch (error: any) {\n      return { success: false, error: error.message };\n    }\n  });\n\n  logger.info(\n    `[${ADDON_NAME}] Registered IPC handlers: mcp:getStatus, mcp:getConnectionInfo, mcp:start, mcp:stop, mcp:restart, mcp:regenerateToken`\n  );\n}\n\n/**\n * Main addon initialization function\n */\nexport default function (_context: LocalMain.AddonMainContext): void {\n  const services = LocalMain.getServiceContainer().cradle as any;\n  const { localLogger, graphql } = services;\n\n  try {\n    localLogger.info(`[${ADDON_NAME}] Initializing...`);\n\n    // Register GraphQL extensions (for local-cli and MCP)\n    const resolvers = createResolvers(services);\n    graphql.registerGraphQLService('mcp-server', typeDefs, resolvers);\n    localLogger.info(`[${ADDON_NAME}] Registered GraphQL: 29 tools (Phase 1-11b)`);\n\n    // Start MCP server (for AI tools)\n    const localServices: LocalServices = {\n      siteData: services.siteData,\n      siteProcessManager: services.siteProcessManager,\n      wpCli: services.wpCli,\n      deleteSite: services.deleteSite,\n      addSite: services.addSite,\n      localLogger: services.localLogger,\n      adminer: services.adminer,\n      x509Cert: services.x509Cert,\n      siteProvisioner: services.siteProvisioner,\n      importSite: services.importSite,\n      lightningServices: services.lightningServices,\n      // Phase 11: WP Engine Connect\n      wpeOAuth: services.wpeOAuth,\n      capi: services.capi,\n    };\n\n    // MCP server disabled - CLI-only mode\n    // To enable MCP server for AI tool integration, uncomment the following:\n    // startMcpServer(localServices, localLogger);\n    // registerIpcHandlers(localServices, localLogger);\n\n    localLogger.info(`[${ADDON_NAME}] Successfully initialized (CLI-only mode)`);\n  } catch (error: any) {\n    localLogger.error(`[${ADDON_NAME}] Failed to initialize:`, error);\n  }\n}\n"]}