@local-labs-jpollock/local-cli 0.0.1

package/addon-dist/lib/common/constants.d.ts

@@ -0,0 +1,22 @@
+/**
+ * MCP Server Constants
+ */
+export declare const MCP_SERVER: {
+    readonly NAME: "Local MCP Server";
+    readonly VERSION: "1.0.0";
+    readonly DEFAULT_PORT: 10789;
+    readonly PORT_RANGE: {
+        readonly MIN: 10789;
+        readonly MAX: 10889;
+    };
+};
+export declare const MCP_ENDPOINTS: {
+    readonly SSE: "/mcp/sse";
+    readonly MESSAGES: "/mcp/messages";
+    readonly HEALTH: "/health";
+    readonly GRAPHQL: "/graphql";
+};
+export declare const CONNECTION_INFO_FILENAME = "mcp-connection-info.json";
+export declare const TRUSTED_IPS: readonly ["127.0.0.1", "::1", "::ffff:127.0.0.1"];
+export declare const AUTH_TOKEN_LENGTH = 128;
+export declare const REQUEST_TIMEOUT_MS = 30000;

package/addon-dist/lib/common/constants.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * MCP Server Constants
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUEST_TIMEOUT_MS = exports.AUTH_TOKEN_LENGTH = exports.TRUSTED_IPS = exports.CONNECTION_INFO_FILENAME = exports.MCP_ENDPOINTS = exports.MCP_SERVER = void 0;
+exports.MCP_SERVER = {
+    NAME: 'Local MCP Server',
+    VERSION: '1.0.0',
+    DEFAULT_PORT: 10789,
+    PORT_RANGE: {
+        MIN: 10789,
+        MAX: 10889,
+    },
+};
+exports.MCP_ENDPOINTS = {
+    SSE: '/mcp/sse',
+    MESSAGES: '/mcp/messages',
+    HEALTH: '/health',
+    GRAPHQL: '/graphql',
+};
+exports.CONNECTION_INFO_FILENAME = 'mcp-connection-info.json';
+exports.TRUSTED_IPS = ['127.0.0.1', '::1', '::ffff:127.0.0.1'];
+exports.AUTH_TOKEN_LENGTH = 128;
+exports.REQUEST_TIMEOUT_MS = 30000;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbW1vbi9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHOzs7QUFFVSxRQUFBLFVBQVUsR0FBRztJQUN4QixJQUFJLEVBQUUsa0JBQWtCO0lBQ3hCLE9BQU8sRUFBRSxPQUFPO0lBQ2hCLFlBQVksRUFBRSxLQUFLO0lBQ25CLFVBQVUsRUFBRTtRQUNWLEdBQUcsRUFBRSxLQUFLO1FBQ1YsR0FBRyxFQUFFLEtBQUs7S0FDWDtDQUNPLENBQUM7QUFFRSxRQUFBLGFBQWEsR0FBRztJQUMzQixHQUFHLEVBQUUsVUFBVTtJQUNmLFFBQVEsRUFBRSxlQUFlO0lBQ3pCLE1BQU0sRUFBRSxTQUFTO0lBQ2pCLE9BQU8sRUFBRSxVQUFVO0NBQ1gsQ0FBQztBQUVFLFFBQUEsd0JBQXdCLEdBQUcsMEJBQTBCLENBQUM7QUFFdEQsUUFBQSxXQUFXLEdBQUcsQ0FBQyxXQUFXLEVBQUUsS0FBSyxFQUFFLGtCQUFrQixDQUFVLENBQUM7QUFFaEUsUUFBQSxpQkFBaUIsR0FBRyxHQUFHLENBQUM7QUFFeEIsUUFBQSxrQkFBa0IsR0FBRyxLQUFLLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIE1DUCBTZXJ2ZXIgQ29uc3RhbnRzXG4gKi9cblxuZXhwb3J0IGNvbnN0IE1DUF9TRVJWRVIgPSB7XG4gIE5BTUU6ICdMb2NhbCBNQ1AgU2VydmVyJyxcbiAgVkVSU0lPTjogJzEuMC4wJyxcbiAgREVGQVVMVF9QT1JUOiAxMDc4OSxcbiAgUE9SVF9SQU5HRToge1xuICAgIE1JTjogMTA3ODksXG4gICAgTUFYOiAxMDg4OSxcbiAgfSxcbn0gYXMgY29uc3Q7XG5cbmV4cG9ydCBjb25zdCBNQ1BfRU5EUE9JTlRTID0ge1xuICBTU0U6ICcvbWNwL3NzZScsXG4gIE1FU1NBR0VTOiAnL21jcC9tZXNzYWdlcycsXG4gIEhFQUxUSDogJy9oZWFsdGgnLFxuICBHUkFQSFFMOiAnL2dyYXBocWwnLFxufSBhcyBjb25zdDtcblxuZXhwb3J0IGNvbnN0IENPTk5FQ1RJT05fSU5GT19GSUxFTkFNRSA9ICdtY3AtY29ubmVjdGlvbi1pbmZvLmpzb24nO1xuXG5leHBvcnQgY29uc3QgVFJVU1RFRF9JUFMgPSBbJzEyNy4wLjAuMScsICc6OjEnLCAnOjpmZmZmOjEyNy4wLjAuMSddIGFzIGNvbnN0O1xuXG5leHBvcnQgY29uc3QgQVVUSF9UT0tFTl9MRU5HVEggPSAxMjg7XG5cbmV4cG9ydCBjb25zdCBSRVFVRVNUX1RJTUVPVVRfTVMgPSAzMDAwMDtcbiJdfQ==

package/addon-dist/lib/common/theme.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Theme Utilities for MCP Server Addon
+ *
+ * Provides theme detection and color management to match Local's theme preference.
+ * Local uses CSS classes on document.documentElement: .Theme__Dark or .Theme__Light
+ */
+/**
+ * Theme color palette for consistent styling across components.
+ */
+export interface ThemeColors {
+    panelBg: string;
+    panelBgSecondary: string;
+    panelBgCode: string;
+    textPrimary: string;
+    textSecondary: string;
+    textMuted: string;
+    border: string;
+    borderLight: string;
+    successBg: string;
+    successText: string;
+    errorBg: string;
+    errorText: string;
+    infoBg: string;
+    infoBorder: string;
+    infoText: string;
+    inputBg: string;
+    inputBorder: string;
+    primary: string;
+    primaryHover: string;
+}
+/**
+ * Light theme color palette.
+ */
+declare const LIGHT_COLORS: ThemeColors;
+/**
+ * Dark theme color palette.
+ */
+declare const DARK_COLORS: ThemeColors;
+/**
+ * Check if Local is currently in dark mode.
+ *
+ * Local sets CSS classes on document.documentElement:
+ * - .Theme__Dark for dark mode
+ * - .Theme__Light for light mode
+ *
+ * @returns true if dark mode is active, false otherwise
+ */
+export declare function isDarkMode(): boolean;
+/**
+ * Get theme-appropriate colors based on current Local theme.
+ *
+ * @returns ThemeColors object with colors for the current theme
+ */
+export declare function getThemeColors(): ThemeColors;
+/**
+ * Subscribe to theme changes via MutationObserver.
+ *
+ * Local toggles CSS classes on document.documentElement when theme changes.
+ * This function watches for those changes and calls the callback.
+ *
+ * @param callback Function called when theme changes
+ * @returns Cleanup function to stop observing
+ */
+export declare function onThemeChange(callback: () => void): () => void;
+/**
+ * Export color constants for direct access if needed.
+ */
+export { LIGHT_COLORS, DARK_COLORS };

package/addon-dist/lib/common/theme.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * Theme Utilities for MCP Server Addon
+ *
+ * Provides theme detection and color management to match Local's theme preference.
+ * Local uses CSS classes on document.documentElement: .Theme__Dark or .Theme__Light
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DARK_COLORS = exports.LIGHT_COLORS = void 0;
+exports.isDarkMode = isDarkMode;
+exports.getThemeColors = getThemeColors;
+exports.onThemeChange = onThemeChange;
+/**
+ * Light theme color palette.
+ */
+const LIGHT_COLORS = {
+    // Backgrounds
+    panelBg: '#ffffff',
+    panelBgSecondary: '#f5f5f5',
+    panelBgCode: '#2d2d2d',
+    // Text
+    textPrimary: '#1a1a1a',
+    textSecondary: '#666666',
+    textMuted: '#999999',
+    // Borders
+    border: '#dddddd',
+    borderLight: '#eeeeee',
+    // Status colors
+    successBg: '#d4edda',
+    successText: '#28a745',
+    errorBg: '#f8d7da',
+    errorText: '#dc3545',
+    infoBg: '#e7f3ff',
+    infoBorder: '#b3d9ff',
+    infoText: '#333333',
+    // Interactive elements
+    inputBg: '#ffffff',
+    inputBorder: '#cccccc',
+    // Brand/accent colors
+    primary: '#007bff',
+    primaryHover: '#0056b3',
+};
+exports.LIGHT_COLORS = LIGHT_COLORS;
+/**
+ * Dark theme color palette.
+ */
+const DARK_COLORS = {
+    // Backgrounds
+    panelBg: '#2d2d2d',
+    panelBgSecondary: '#3d3d3d',
+    panelBgCode: '#1a1a1a',
+    // Text
+    textPrimary: '#e0e0e0',
+    textSecondary: '#a0a0a0',
+    textMuted: '#808080',
+    // Borders
+    border: '#4a4a4a',
+    borderLight: '#3d3d3d',
+    // Status colors
+    successBg: '#1a4d2e',
+    successText: '#68d391',
+    errorBg: '#4d1a1a',
+    errorText: '#fc8181',
+    infoBg: '#1a3a4d',
+    infoBorder: '#2d5a7b',
+    infoText: '#e0e0e0',
+    // Interactive elements
+    inputBg: '#3d3d3d',
+    inputBorder: '#5a5a5a',
+    // Brand/accent colors
+    primary: '#4da3ff',
+    primaryHover: '#2d8aff',
+};
+exports.DARK_COLORS = DARK_COLORS;
+/**
+ * Check if Local is currently in dark mode.
+ *
+ * Local sets CSS classes on document.documentElement:
+ * - .Theme__Dark for dark mode
+ * - .Theme__Light for light mode
+ *
+ * @returns true if dark mode is active, false otherwise
+ */
+function isDarkMode() {
+    // Guard for SSR/Node environment
+    if (typeof document === 'undefined') {
+        return false;
+    }
+    return document.documentElement.classList.contains('Theme__Dark');
+}
+/**
+ * Get theme-appropriate colors based on current Local theme.
+ *
+ * @returns ThemeColors object with colors for the current theme
+ */
+function getThemeColors() {
+    return isDarkMode() ? DARK_COLORS : LIGHT_COLORS;
+}
+/**
+ * Subscribe to theme changes via MutationObserver.
+ *
+ * Local toggles CSS classes on document.documentElement when theme changes.
+ * This function watches for those changes and calls the callback.
+ *
+ * @param callback Function called when theme changes
+ * @returns Cleanup function to stop observing
+ */
+function onThemeChange(callback) {
+    // Guard for SSR/Node environment
+    if (typeof document === 'undefined') {
+        return () => { };
+    }
+    const observer = new MutationObserver((mutations) => {
+        for (const mutation of mutations) {
+            if (mutation.attributeName === 'class') {
+                callback();
+            }
+        }
+    });
+    observer.observe(document.documentElement, {
+        attributes: true,
+        attributeFilter: ['class'],
+    });
+    return () => observer.disconnect();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"theme.js","sourceRoot":"","sources":["../../src/common/theme.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAuHH,gCAOC;AAOD,wCAEC;AAWD,sCAoBC;AAhID;;GAEG;AACH,MAAM,YAAY,GAAgB;IAChC,cAAc;IACd,OAAO,EAAE,SAAS;IAClB,gBAAgB,EAAE,SAAS;IAC3B,WAAW,EAAE,SAAS;IAEtB,OAAO;IACP,WAAW,EAAE,SAAS;IACtB,aAAa,EAAE,SAAS;IACxB,SAAS,EAAE,SAAS;IAEpB,UAAU;IACV,MAAM,EAAE,SAAS;IACjB,WAAW,EAAE,SAAS;IAEtB,gBAAgB;IAChB,SAAS,EAAE,SAAS;IACpB,WAAW,EAAE,SAAS;IACtB,OAAO,EAAE,SAAS;IAClB,SAAS,EAAE,SAAS;IACpB,MAAM,EAAE,SAAS;IACjB,UAAU,EAAE,SAAS;IACrB,QAAQ,EAAE,SAAS;IAEnB,uBAAuB;IACvB,OAAO,EAAE,SAAS;IAClB,WAAW,EAAE,SAAS;IAEtB,sBAAsB;IACtB,OAAO,EAAE,SAAS;IAClB,YAAY,EAAE,SAAS;CACxB,CAAC;AAmGO,oCAAY;AAjGrB;;GAEG;AACH,MAAM,WAAW,GAAgB;IAC/B,cAAc;IACd,OAAO,EAAE,SAAS;IAClB,gBAAgB,EAAE,SAAS;IAC3B,WAAW,EAAE,SAAS;IAEtB,OAAO;IACP,WAAW,EAAE,SAAS;IACtB,aAAa,EAAE,SAAS;IACxB,SAAS,EAAE,SAAS;IAEpB,UAAU;IACV,MAAM,EAAE,SAAS;IACjB,WAAW,EAAE,SAAS;IAEtB,gBAAgB;IAChB,SAAS,EAAE,SAAS;IACpB,WAAW,EAAE,SAAS;IACtB,OAAO,EAAE,SAAS;IAClB,SAAS,EAAE,SAAS;IACpB,MAAM,EAAE,SAAS;IACjB,UAAU,EAAE,SAAS;IACrB,QAAQ,EAAE,SAAS;IAEnB,uBAAuB;IACvB,OAAO,EAAE,SAAS;IAClB,WAAW,EAAE,SAAS;IAEtB,sBAAsB;IACtB,OAAO,EAAE,SAAS;IAClB,YAAY,EAAE,SAAS;CACxB,CAAC;AA+DqB,kCAAW;AA7DlC;;;;;;;;GAQG;AACH,SAAgB,UAAU;IACxB,iCAAiC;IACjC,IAAI,OAAO,QAAQ,KAAK,WAAW,EAAE,CAAC;QACpC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,QAAQ,CAAC,eAAe,CAAC,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;AACpE,CAAC;AAED;;;;GAIG;AACH,SAAgB,cAAc;IAC5B,OAAO,UAAU,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,YAAY,CAAC;AACnD,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,aAAa,CAAC,QAAoB;IAChD,iCAAiC;IACjC,IAAI,OAAO,QAAQ,KAAK,WAAW,EAAE,CAAC;QACpC,OAAO,GAAG,EAAE,GAAE,CAAC,CAAC;IAClB,CAAC;IAED,MAAM,QAAQ,GAAG,IAAI,gBAAgB,CAAC,CAAC,SAAS,EAAE,EAAE;QAClD,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YACjC,IAAI,QAAQ,CAAC,aAAa,KAAK,OAAO,EAAE,CAAC;gBACvC,QAAQ,EAAE,CAAC;YACb,CAAC;QACH,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,eAAe,EAAE;QACzC,UAAU,EAAE,IAAI;QAChB,eAAe,EAAE,CAAC,OAAO,CAAC;KAC3B,CAAC,CAAC;IAEH,OAAO,GAAG,EAAE,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC;AACrC,CAAC","sourcesContent":["/**\n * Theme Utilities for MCP Server Addon\n *\n * Provides theme detection and color management to match Local's theme preference.\n * Local uses CSS classes on document.documentElement: .Theme__Dark or .Theme__Light\n */\n\n/**\n * Theme color palette for consistent styling across components.\n */\nexport interface ThemeColors {\n  // Backgrounds\n  panelBg: string;\n  panelBgSecondary: string;\n  panelBgCode: string;\n\n  // Text\n  textPrimary: string;\n  textSecondary: string;\n  textMuted: string;\n\n  // Borders\n  border: string;\n  borderLight: string;\n\n  // Status colors\n  successBg: string;\n  successText: string;\n  errorBg: string;\n  errorText: string;\n  infoBg: string;\n  infoBorder: string;\n  infoText: string;\n\n  // Interactive elements\n  inputBg: string;\n  inputBorder: string;\n\n  // Brand/accent colors\n  primary: string;\n  primaryHover: string;\n}\n\n/**\n * Light theme color palette.\n */\nconst LIGHT_COLORS: ThemeColors = {\n  // Backgrounds\n  panelBg: '#ffffff',\n  panelBgSecondary: '#f5f5f5',\n  panelBgCode: '#2d2d2d',\n\n  // Text\n  textPrimary: '#1a1a1a',\n  textSecondary: '#666666',\n  textMuted: '#999999',\n\n  // Borders\n  border: '#dddddd',\n  borderLight: '#eeeeee',\n\n  // Status colors\n  successBg: '#d4edda',\n  successText: '#28a745',\n  errorBg: '#f8d7da',\n  errorText: '#dc3545',\n  infoBg: '#e7f3ff',\n  infoBorder: '#b3d9ff',\n  infoText: '#333333',\n\n  // Interactive elements\n  inputBg: '#ffffff',\n  inputBorder: '#cccccc',\n\n  // Brand/accent colors\n  primary: '#007bff',\n  primaryHover: '#0056b3',\n};\n\n/**\n * Dark theme color palette.\n */\nconst DARK_COLORS: ThemeColors = {\n  // Backgrounds\n  panelBg: '#2d2d2d',\n  panelBgSecondary: '#3d3d3d',\n  panelBgCode: '#1a1a1a',\n\n  // Text\n  textPrimary: '#e0e0e0',\n  textSecondary: '#a0a0a0',\n  textMuted: '#808080',\n\n  // Borders\n  border: '#4a4a4a',\n  borderLight: '#3d3d3d',\n\n  // Status colors\n  successBg: '#1a4d2e',\n  successText: '#68d391',\n  errorBg: '#4d1a1a',\n  errorText: '#fc8181',\n  infoBg: '#1a3a4d',\n  infoBorder: '#2d5a7b',\n  infoText: '#e0e0e0',\n\n  // Interactive elements\n  inputBg: '#3d3d3d',\n  inputBorder: '#5a5a5a',\n\n  // Brand/accent colors\n  primary: '#4da3ff',\n  primaryHover: '#2d8aff',\n};\n\n/**\n * Check if Local is currently in dark mode.\n *\n * Local sets CSS classes on document.documentElement:\n * - .Theme__Dark for dark mode\n * - .Theme__Light for light mode\n *\n * @returns true if dark mode is active, false otherwise\n */\nexport function isDarkMode(): boolean {\n  // Guard for SSR/Node environment\n  if (typeof document === 'undefined') {\n    return false;\n  }\n\n  return document.documentElement.classList.contains('Theme__Dark');\n}\n\n/**\n * Get theme-appropriate colors based on current Local theme.\n *\n * @returns ThemeColors object with colors for the current theme\n */\nexport function getThemeColors(): ThemeColors {\n  return isDarkMode() ? DARK_COLORS : LIGHT_COLORS;\n}\n\n/**\n * Subscribe to theme changes via MutationObserver.\n *\n * Local toggles CSS classes on document.documentElement when theme changes.\n * This function watches for those changes and calls the callback.\n *\n * @param callback Function called when theme changes\n * @returns Cleanup function to stop observing\n */\nexport function onThemeChange(callback: () => void): () => void {\n  // Guard for SSR/Node environment\n  if (typeof document === 'undefined') {\n    return () => {};\n  }\n\n  const observer = new MutationObserver((mutations) => {\n    for (const mutation of mutations) {\n      if (mutation.attributeName === 'class') {\n        callback();\n      }\n    }\n  });\n\n  observer.observe(document.documentElement, {\n    attributes: true,\n    attributeFilter: ['class'],\n  });\n\n  return () => observer.disconnect();\n}\n\n/**\n * Export color constants for direct access if needed.\n */\nexport { LIGHT_COLORS, DARK_COLORS };\n"]}

package/addon-dist/lib/common/types.d.ts

@@ -0,0 +1,298 @@
+/**
+ * MCP Server Types
+ */
+export interface McpConnectionInfo {
+    url: string;
+    authToken: string;
+    port: number;
+    version: string;
+    tools: string[];
+}
+export interface McpServerConfig {
+    port: number;
+    authToken?: string;
+}
+export interface McpServerStatus {
+    running: boolean;
+    port: number;
+    uptime: number;
+    error?: string;
+}
+export interface McpToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+export interface McpToolResult {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}
+export interface McpRequest {
+    jsonrpc: '2.0';
+    id: number | string;
+    method: string;
+    params?: {
+        name?: string;
+        arguments?: Record<string, unknown>;
+    };
+}
+export interface McpResponse {
+    jsonrpc: '2.0';
+    id: number | string;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export interface LocalServices {
+    siteData: {
+        getSites(): any[];
+        getSite(id: string): any | undefined;
+        updateSite?(siteID: string, site: Partial<{
+            name: string;
+            xdebugEnabled: boolean;
+        }>): void;
+    };
+    siteProcessManager: {
+        start(site: any): Promise<void>;
+        stop(site: any): Promise<void>;
+        restart(site: any): Promise<void>;
+        getSiteStatus(site: any): Promise<string>;
+    };
+    wpCli: {
+        run(site: any, args: string[], opts?: any): Promise<string | null>;
+    };
+    deleteSite: {
+        deleteSite(opts: {
+            site: any;
+            trashFiles: boolean;
+            updateHosts: boolean;
+        }): Promise<void>;
+    };
+    addSite: {
+        addSite(opts: {
+            newSiteInfo: {
+                siteName: string;
+                siteDomain: string;
+                sitePath?: string;
+                multiSite?: 'no' | 'ms-subdir' | 'ms-subdomain';
+                phpVersion?: string;
+                webServer?: 'nginx' | 'apache';
+                database?: 'mysql' | 'mariadb';
+            };
+            wpCredentials?: {
+                adminUsername?: string;
+                adminPassword?: string;
+                adminEmail?: string;
+            };
+            goToSite?: boolean;
+        }): Promise<any>;
+    };
+    localLogger: {
+        info(message: string, ...args: any[]): void;
+        warn(message: string, ...args: any[]): void;
+        error(message: string, ...args: any[]): void;
+        debug(message: string, ...args: any[]): void;
+    };
+    browserManager?: {
+        openURL(url: string): Promise<void>;
+    };
+    cloneSite?: (site: any, newName: string) => Promise<any>;
+    exportSite?: (site: any, outputPath: string) => Promise<void>;
+    blueprints?: {
+        getBlueprints(): Promise<any[]>;
+        saveBlueprint(site: any, options: {
+            name: string;
+            description?: string;
+        }): Promise<any>;
+    };
+    adminer?: {
+        open(site: any): Promise<void>;
+    };
+    x509Cert?: {
+        trustCert(site: any): Promise<void>;
+    };
+    siteProvisioner?: {
+        swapService(site: any, role: string, serviceName: string, serviceBinVersion: string, restartRouter?: boolean): Promise<void>;
+    };
+    importSite?: {
+        run(settings: {
+            importType?: string;
+            zipPath: string;
+            siteName: string;
+        }): Promise<any>;
+    };
+    lightningServices?: {
+        getRegisteredServices(role?: string): Record<string, Record<string, any>>;
+        getServices(role?: string): Promise<Record<string, Record<string, any>>>;
+    };
+    wpeOAuth?: {
+        getAccessToken(): Promise<string | undefined>;
+        authenticate(): Promise<{
+            accessToken: string;
+            refreshToken: string;
+            idToken: string;
+        }>;
+        clearTokens(): Promise<void>;
+    };
+    capi?: {
+        getInstallList(): Promise<any[] | undefined>;
+        getAccountList(): Promise<any[] | undefined>;
+        getCurrentUser(): Promise<{
+            id?: string;
+            email?: string;
+        } | undefined>;
+        getInstall(installId: string): Promise<{
+            id: string;
+            name: string;
+            environment?: string;
+            cname?: string;
+        } | undefined>;
+    };
+    wpePush?: {
+        push(args: {
+            includeSql?: boolean;
+            wpengineInstallName: string;
+            wpengineInstallId: string;
+            wpengineSiteId: string;
+            wpenginePrimaryDomain: string;
+            localSiteId: string;
+            environment?: string;
+            files?: string[];
+            isMagicSync?: boolean;
+        }): Promise<void>;
+        pushDatabase(args: {
+            wpengineInstallName: string;
+            localSiteId: string;
+            wpenginePrimaryDomain: string;
+        }): Promise<void>;
+    };
+    wpePull?: {
+        pull(args: {
+            includeSql?: boolean;
+            wpengineInstallName: string;
+            wpengineInstallId: string;
+            wpengineSiteId: string;
+            wpenginePrimaryDomain: string;
+            localSiteId: string;
+            environment?: string;
+            files?: string[];
+            isMagicSync?: boolean;
+        }): Promise<void>;
+        pullDatabase(args: {
+            wpengineInstallName: string;
+            localSiteId: string;
+            wpenginePrimaryDomain: string;
+        }): Promise<void>;
+    };
+    connectHistory?: {
+        getEvents(siteId: string): Array<{
+            remoteInstallName?: string;
+            timestamp: number;
+            environment: string;
+            direction: 'push' | 'pull';
+            status?: 'started' | 'failed' | 'completed';
+        }>;
+    };
+    wpeConnectBase?: {
+        listModifications(args: {
+            connectArgs: {
+                wpengineInstallName: string;
+                wpengineInstallId: string;
+                wpengineSiteId: string;
+                wpenginePrimaryDomain: string;
+                localSiteId: string;
+            };
+            direction: 'push' | 'pull';
+            includeIgnored?: boolean;
+        }): Promise<Array<{
+            path: string;
+            type: string;
+            size: number;
+            mtime: number;
+            instruction: string;
+        }>>;
+    };
+    backup?: {
+        createBackup(args: {
+            site: any;
+            provider: 'dropbox' | 'googleDrive';
+            accountId: string;
+            note?: string;
+        }): Promise<{
+            snapshotId: string;
+            timestamp: string;
+        }>;
+        listBackups(args: {
+            site: any;
+            provider: 'dropbox' | 'googleDrive';
+            accountId: string;
+        }): Promise<Array<{
+            snapshotId: string;
+            timestamp: string;
+            note?: string;
+            siteDomain: string;
+            services: Record<string, string>;
+        }>>;
+        restoreBackup(args: {
+            site: any;
+            provider: 'dropbox' | 'googleDrive';
+            accountId: string;
+            snapshotId: string;
+        }): Promise<void>;
+        deleteBackup(args: {
+            site: any;
+            provider: 'dropbox' | 'googleDrive';
+            accountId: string;
+            snapshotId: string;
+        }): Promise<void>;
+        downloadZip(args: {
+            site: any;
+            provider: 'dropbox' | 'googleDrive';
+            accountId: string;
+            snapshotId: string;
+        }): Promise<string>;
+        editBackupDescription(args: {
+            site: any;
+            provider: 'dropbox' | 'googleDrive';
+            accountId: string;
+            snapshotId: string;
+            newDescription: string;
+        }): Promise<void>;
+    };
+    dropbox?: {
+        isAuthenticated(accountId: string): Promise<boolean>;
+        getAccount(accountId: string): Promise<{
+            id: string;
+            email: string;
+        } | undefined>;
+    };
+    googleDrive?: {
+        isAuthenticated(accountId: string): Promise<boolean>;
+        getAccount(accountId: string): Promise<{
+            id: string;
+            email: string;
+        } | undefined>;
+    };
+    featureFlags?: {
+        isFeatureEnabled(flag: string): boolean;
+    };
+    userData?: {
+        get(opts: {
+            name: string;
+            defaults: any;
+            includeCreatedTime?: boolean;
+            persistDefaults?: boolean;
+            persistDefaultsEncrypted?: boolean;
+        }): any;
+    };
+}

package/addon-dist/lib/common/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * MCP Server Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/common/types.ts"],"names":[],"mappings":";AAAA;;GAEG","sourcesContent":["/**\n * MCP Server Types\n */\n\nexport interface McpConnectionInfo {\n  url: string;\n  authToken: string;\n  port: number;\n  version: string;\n  tools: string[];\n}\n\nexport interface McpServerConfig {\n  port: number;\n  authToken?: string;\n}\n\nexport interface McpServerStatus {\n  running: boolean;\n  port: number;\n  uptime: number;\n  error?: string;\n}\n\nexport interface McpToolDefinition {\n  name: string;\n  description: string;\n  inputSchema: {\n    type: 'object';\n    properties: Record<string, unknown>;\n    required?: string[];\n  };\n}\n\nexport interface McpToolResult {\n  content: Array<{\n    type: 'text';\n    text: string;\n  }>;\n  isError?: boolean;\n}\n\nexport interface McpRequest {\n  jsonrpc: '2.0';\n  id: number | string;\n  method: string;\n  params?: {\n    name?: string;\n    arguments?: Record<string, unknown>;\n  };\n}\n\nexport interface McpResponse {\n  jsonrpc: '2.0';\n  id: number | string;\n  result?: unknown;\n  error?: {\n    code: number;\n    message: string;\n    data?: unknown;\n  };\n}\n\nexport interface LocalServices {\n  siteData: {\n    getSites(): any[];\n    getSite(id: string): any | undefined;\n    updateSite?(siteID: string, site: Partial<{ name: string; xdebugEnabled: boolean }>): void;\n  };\n  siteProcessManager: {\n    start(site: any): Promise<void>;\n    stop(site: any): Promise<void>;\n    restart(site: any): Promise<void>;\n    getSiteStatus(site: any): Promise<string>;\n  };\n  wpCli: {\n    run(site: any, args: string[], opts?: any): Promise<string | null>;\n  };\n  deleteSite: {\n    deleteSite(opts: { site: any; trashFiles: boolean; updateHosts: boolean }): Promise<void>;\n  };\n  addSite: {\n    addSite(opts: {\n      newSiteInfo: {\n        siteName: string;\n        siteDomain: string;\n        sitePath?: string;\n        multiSite?: 'no' | 'ms-subdir' | 'ms-subdomain';\n        phpVersion?: string;\n        webServer?: 'nginx' | 'apache';\n        database?: 'mysql' | 'mariadb';\n      };\n      wpCredentials?: {\n        adminUsername?: string;\n        adminPassword?: string;\n        adminEmail?: string;\n      };\n      goToSite?: boolean;\n    }): Promise<any>;\n  };\n  localLogger: {\n    info(message: string, ...args: any[]): void;\n    warn(message: string, ...args: any[]): void;\n    error(message: string, ...args: any[]): void;\n    debug(message: string, ...args: any[]): void;\n  };\n  // Optional services for extended functionality\n  browserManager?: {\n    openURL(url: string): Promise<void>;\n  };\n  cloneSite?: (site: any, newName: string) => Promise<any>;\n  exportSite?: (site: any, outputPath: string) => Promise<void>;\n  blueprints?: {\n    getBlueprints(): Promise<any[]>;\n    saveBlueprint(site: any, options: { name: string; description?: string }): Promise<any>;\n  };\n  // Phase 8 services\n  adminer?: {\n    open(site: any): Promise<void>;\n  };\n  x509Cert?: {\n    trustCert(site: any): Promise<void>;\n  };\n  siteProvisioner?: {\n    swapService(\n      site: any,\n      role: string,\n      serviceName: string,\n      serviceBinVersion: string,\n      restartRouter?: boolean\n    ): Promise<void>;\n  };\n  importSite?: {\n    run(settings: { importType?: string; zipPath: string; siteName: string }): Promise<any>;\n  };\n  // Phase 9 services\n  lightningServices?: {\n    getRegisteredServices(role?: string): Record<string, Record<string, any>>;\n    getServices(role?: string): Promise<Record<string, Record<string, any>>>;\n  };\n  // Phase 11: WP Engine Connect services\n  wpeOAuth?: {\n    getAccessToken(): Promise<string | undefined>;\n    authenticate(): Promise<{ accessToken: string; refreshToken: string; idToken: string }>;\n    clearTokens(): Promise<void>;\n  };\n  capi?: {\n    getInstallList(): Promise<any[] | undefined>;\n    getAccountList(): Promise<any[] | undefined>;\n    getCurrentUser(): Promise<{ id?: string; email?: string } | undefined>;\n    getInstall(\n      installId: string\n    ): Promise<{ id: string; name: string; environment?: string; cname?: string } | undefined>;\n  };\n  // Phase 11c: Sync services\n  wpePush?: {\n    push(args: {\n      includeSql?: boolean;\n      wpengineInstallName: string;\n      wpengineInstallId: string;\n      wpengineSiteId: string;\n      wpenginePrimaryDomain: string;\n      localSiteId: string;\n      environment?: string;\n      files?: string[];\n      isMagicSync?: boolean;\n    }): Promise<void>;\n    pushDatabase(args: {\n      wpengineInstallName: string;\n      localSiteId: string;\n      wpenginePrimaryDomain: string;\n    }): Promise<void>;\n  };\n  wpePull?: {\n    pull(args: {\n      includeSql?: boolean;\n      wpengineInstallName: string;\n      wpengineInstallId: string;\n      wpengineSiteId: string;\n      wpenginePrimaryDomain: string;\n      localSiteId: string;\n      environment?: string;\n      files?: string[];\n      isMagicSync?: boolean;\n    }): Promise<void>;\n    pullDatabase(args: {\n      wpengineInstallName: string;\n      localSiteId: string;\n      wpenginePrimaryDomain: string;\n    }): Promise<void>;\n  };\n  connectHistory?: {\n    getEvents(siteId: string): Array<{\n      remoteInstallName?: string;\n      timestamp: number;\n      environment: string;\n      direction: 'push' | 'pull';\n      status?: 'started' | 'failed' | 'completed';\n    }>;\n  };\n  // Magic Sync change detection\n  wpeConnectBase?: {\n    listModifications(args: {\n      connectArgs: {\n        wpengineInstallName: string;\n        wpengineInstallId: string;\n        wpengineSiteId: string;\n        wpenginePrimaryDomain: string;\n        localSiteId: string;\n      };\n      direction: 'push' | 'pull';\n      includeIgnored?: boolean;\n    }): Promise<\n      Array<{\n        path: string;\n        type: string;\n        size: number;\n        mtime: number;\n        instruction: string;\n      }>\n    >;\n  };\n  // Phase 10: Cloud Backup services\n  backup?: {\n    createBackup(args: {\n      site: any;\n      provider: 'dropbox' | 'googleDrive';\n      accountId: string;\n      note?: string;\n    }): Promise<{ snapshotId: string; timestamp: string }>;\n    listBackups(args: {\n      site: any;\n      provider: 'dropbox' | 'googleDrive';\n      accountId: string;\n    }): Promise<\n      Array<{\n        snapshotId: string;\n        timestamp: string;\n        note?: string;\n        siteDomain: string;\n        services: Record<string, string>;\n      }>\n    >;\n    restoreBackup(args: {\n      site: any;\n      provider: 'dropbox' | 'googleDrive';\n      accountId: string;\n      snapshotId: string;\n    }): Promise<void>;\n    deleteBackup(args: {\n      site: any;\n      provider: 'dropbox' | 'googleDrive';\n      accountId: string;\n      snapshotId: string;\n    }): Promise<void>;\n    downloadZip(args: {\n      site: any;\n      provider: 'dropbox' | 'googleDrive';\n      accountId: string;\n      snapshotId: string;\n    }): Promise<string>; // Returns file path\n    editBackupDescription(args: {\n      site: any;\n      provider: 'dropbox' | 'googleDrive';\n      accountId: string;\n      snapshotId: string;\n      newDescription: string;\n    }): Promise<void>;\n  };\n  dropbox?: {\n    isAuthenticated(accountId: string): Promise<boolean>;\n    getAccount(accountId: string): Promise<{ id: string; email: string } | undefined>;\n  };\n  googleDrive?: {\n    isAuthenticated(accountId: string): Promise<boolean>;\n    getAccount(accountId: string): Promise<{ id: string; email: string } | undefined>;\n  };\n  featureFlags?: {\n    isFeatureEnabled(flag: string): boolean;\n  };\n  // UserData for reading cloud storage accounts\n  userData?: {\n    get(opts: {\n      name: string;\n      defaults: any;\n      includeCreatedTime?: boolean;\n      persistDefaults?: boolean;\n      persistDefaultsEncrypted?: boolean;\n    }): any;\n  };\n}\n"]}

package/addon-dist/lib/main/config/ConnectionInfo.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Connection Info Manager
+ * Handles saving/loading MCP connection info for external tools
+ */
+import { McpConnectionInfo } from '../../common/types';
+export declare class ConnectionInfoManager {
+    private logger;
+    constructor(logger: any);
+    /**
+     * Get platform-specific path for connection info file
+     */
+    getFilePath(): string;
+    /**
+     * Save connection info to file
+     */
+    save(info: McpConnectionInfo): Promise<void>;
+    /**
+     * Load connection info from file
+     */
+    load(): Promise<McpConnectionInfo | null>;
+    /**
+     * Delete connection info file
+     */
+    delete(): Promise<void>;
+}