@local-labs-jpollock/local-cli 0.0.1

package/addon-dist/lib/main/mcp/tools/startSite.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * start_site Tool
+ * Start a WordPress site
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startSiteDefinition = void 0;
+exports.startSite = startSite;
+const helpers_1 = require("./helpers");
+exports.startSiteDefinition = {
+    name: 'start_site',
+    description: 'Start a WordPress site by name or ID',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID (partial names work)',
+            },
+        },
+        required: ['site'],
+    },
+};
+async function startSite(args, services) {
+    const { site: siteQuery } = args;
+    // Validate required parameter
+    const paramError = (0, helpers_1.validateRequiredParam)(siteQuery, 'site');
+    if (paramError)
+        return paramError;
+    // Find site or return error
+    const siteResult = (0, helpers_1.findSiteOrError)(siteQuery, services.siteData);
+    if ('error' in siteResult)
+        return siteResult.error;
+    const { site } = siteResult;
+    try {
+        const currentStatus = await services.siteProcessManager.getSiteStatus(site);
+        if (currentStatus === 'running') {
+            return {
+                content: [{ type: 'text', text: `Site "${site.name}" is already running` }],
+            };
+        }
+        await services.siteProcessManager.start(site);
+        return {
+            content: [{ type: 'text', text: `Site "${site.name}" started successfully` }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to start site: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/addon-dist/lib/main/mcp/tools/stopSite.d.ts

@@ -0,0 +1,7 @@
+/**
+ * stop_site Tool
+ * Stop a WordPress site
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const stopSiteDefinition: McpToolDefinition;
+export declare function stopSite(args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;

package/addon-dist/lib/main/mcp/tools/stopSite.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * stop_site Tool
+ * Stop a WordPress site
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopSiteDefinition = void 0;
+exports.stopSite = stopSite;
+const helpers_1 = require("./helpers");
+exports.stopSiteDefinition = {
+    name: 'stop_site',
+    description: 'Stop a running WordPress site by name or ID',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID (partial names work)',
+            },
+        },
+        required: ['site'],
+    },
+};
+async function stopSite(args, services) {
+    const { site: siteQuery } = args;
+    // Validate required parameter
+    const paramError = (0, helpers_1.validateRequiredParam)(siteQuery, 'site');
+    if (paramError)
+        return paramError;
+    // Find site or return error
+    const siteResult = (0, helpers_1.findSiteOrError)(siteQuery, services.siteData);
+    if ('error' in siteResult)
+        return siteResult.error;
+    const { site } = siteResult;
+    try {
+        const currentStatus = await services.siteProcessManager.getSiteStatus(site);
+        if (currentStatus !== 'running') {
+            return {
+                content: [{ type: 'text', text: `Site "${site.name}" is already stopped` }],
+            };
+        }
+        await services.siteProcessManager.stop(site);
+        return {
+            content: [{ type: 'text', text: `Site "${site.name}" stopped successfully` }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to stop site: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/addon-dist/lib/main/mcp/tools/toggleXdebug.d.ts

@@ -0,0 +1,7 @@
+/**
+ * toggle_xdebug Tool
+ * Enable or disable Xdebug for a site
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const toggleXdebugDefinition: McpToolDefinition;
+export declare function toggleXdebug(args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;

package/addon-dist/lib/main/mcp/tools/toggleXdebug.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * toggle_xdebug Tool
+ * Enable or disable Xdebug for a site
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toggleXdebugDefinition = void 0;
+exports.toggleXdebug = toggleXdebug;
+const helpers_1 = require("./helpers");
+exports.toggleXdebugDefinition = {
+    name: 'toggle_xdebug',
+    description: 'Enable or disable Xdebug for a site (requires site restart to take effect)',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID',
+            },
+            enabled: {
+                type: 'boolean',
+                description: 'True to enable Xdebug, false to disable',
+            },
+        },
+        required: ['site', 'enabled'],
+    },
+};
+async function toggleXdebug(args, services) {
+    const { site: siteQuery, enabled } = args;
+    const paramError = (0, helpers_1.validateRequiredParam)(siteQuery, 'site');
+    if (paramError)
+        return paramError;
+    if (typeof enabled !== 'boolean') {
+        return (0, helpers_1.createErrorResult)('Error: enabled parameter must be true or false');
+    }
+    const siteResult = (0, helpers_1.findSiteOrError)(siteQuery, services.siteData);
+    if ('error' in siteResult)
+        return siteResult.error;
+    const { site } = siteResult;
+    try {
+        // Check if updateSite method exists
+        if (!services.siteData.updateSite) {
+            return {
+                content: [{ type: 'text', text: 'Site update service not available' }],
+                isError: true,
+            };
+        }
+        const previousState = site.xdebugEnabled ?? false;
+        // Update the xdebugEnabled property
+        services.siteData.updateSite(site.id, { xdebugEnabled: enabled });
+        const action = enabled ? 'enabled' : 'disabled';
+        const restartNote = previousState !== enabled ? ' Restart the site for changes to take effect.' : '';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Xdebug ${action} for "${site.name}".${restartNote}`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to toggle Xdebug: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/addon-dist/lib/main/mcp/tools/trustSsl.d.ts

@@ -0,0 +1,7 @@
+/**
+ * trust_ssl Tool
+ * Trust SSL certificate for a site
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const trustSslDefinition: McpToolDefinition;
+export declare function trustSsl(args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;

package/addon-dist/lib/main/mcp/tools/trustSsl.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * trust_ssl Tool
+ * Trust SSL certificate for a site
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trustSslDefinition = void 0;
+exports.trustSsl = trustSsl;
+const helpers_1 = require("./helpers");
+exports.trustSslDefinition = {
+    name: 'trust_ssl',
+    description: 'Trust the SSL certificate for a site (may require admin password)',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID',
+            },
+        },
+        required: ['site'],
+    },
+};
+async function trustSsl(args, services) {
+    const { site: siteQuery } = args;
+    const paramError = (0, helpers_1.validateRequiredParam)(siteQuery, 'site');
+    if (paramError)
+        return paramError;
+    const siteResult = (0, helpers_1.findSiteOrError)(siteQuery, services.siteData);
+    if ('error' in siteResult)
+        return siteResult.error;
+    const { site } = siteResult;
+    try {
+        // Check if x509Cert service exists
+        if (!services.x509Cert) {
+            return {
+                content: [{ type: 'text', text: 'SSL certificate service not available' }],
+                isError: true,
+            };
+        }
+        // Trust the certificate
+        await services.x509Cert.trustCert(site);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Successfully trusted SSL certificate for "${site.name}". You may need to restart your browser.`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to trust SSL certificate: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/addon-dist/lib/main/mcp/tools/wpCli.d.ts

@@ -0,0 +1,7 @@
+/**
+ * wp_cli Tool
+ * Run WP-CLI commands against a site
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const wpCliDefinition: McpToolDefinition;
+export declare function wpCli(args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;

package/addon-dist/lib/main/mcp/tools/wpCli.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * wp_cli Tool
+ * Run WP-CLI commands against a site
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wpCliDefinition = void 0;
+exports.wpCli = wpCli;
+const helpers_1 = require("./helpers");
+exports.wpCliDefinition = {
+    name: 'wp_cli',
+    description: 'Run a WP-CLI command against a WordPress site. The site must be running.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID (partial names work)',
+            },
+            command: {
+                oneOf: [
+                    {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'WP-CLI command as array, e.g. ["plugin", "list", "--format=json"]',
+                    },
+                    {
+                        type: 'string',
+                        description: 'WP-CLI command as string, e.g. "plugin list --format=json"',
+                    },
+                ],
+                description: 'WP-CLI command - either as array ["plugin", "list"] or string "plugin list"',
+            },
+        },
+        required: ['site', 'command'],
+    },
+};
+async function wpCli(args, services) {
+    const { site: siteQuery, command: rawCommand } = args;
+    // Validate required parameters
+    const siteError = (0, helpers_1.validateRequiredParam)(siteQuery, 'site');
+    if (siteError)
+        return siteError;
+    const commandError = (0, helpers_1.validateRequiredParam)(rawCommand, 'command');
+    if (commandError)
+        return commandError;
+    // Normalize command to array - accept both string and array formats
+    let command;
+    if (typeof rawCommand === 'string') {
+        // Split string on whitespace, preserving quoted strings would be complex
+        // For simple cases, split on spaces
+        command = rawCommand.trim().split(/\s+/).filter(Boolean);
+    }
+    else if (Array.isArray(rawCommand)) {
+        command = rawCommand;
+    }
+    else {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: 'Error: command must be a string or array of strings',
+                },
+            ],
+            isError: true,
+        };
+    }
+    if (command.length === 0) {
+        return (0, helpers_1.createErrorResult)('Error: command cannot be empty');
+    }
+    // Security: Check for blocked commands
+    const blockedCommand = (0, helpers_1.isBlockedWpCommand)(command);
+    if (blockedCommand) {
+        return (0, helpers_1.createErrorResult)(`Error: Command "${blockedCommand}" is blocked for security reasons. This command could allow arbitrary code execution.`);
+    }
+    // Find site or return error
+    const siteResult = (0, helpers_1.findSiteOrError)(siteQuery, services.siteData);
+    if ('error' in siteResult)
+        return siteResult.error;
+    const { site } = siteResult;
+    try {
+        const currentStatus = await services.siteProcessManager.getSiteStatus(site);
+        if (currentStatus !== 'running') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Site "${site.name}" is not running. Start it first with the start_site tool.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const output = await services.wpCli.run(site, command, {
+            skipPlugins: true,
+            skipThemes: true,
+            ignoreErrors: false,
+        });
+        return {
+            content: [{ type: 'text', text: output?.trim() || '(no output)' }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `WP-CLI error: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wpCli.js","sourceRoot":"","sources":["../../../../src/main/mcp/tools/wpCli.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * wp_cli Tool\n * Run WP-CLI commands against a site\n */\n\nimport { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';\nimport { validateRequiredParam, findSiteOrError, isBlockedWpCommand, createErrorResult } from './helpers';\n\nexport const wpCliDefinition: McpToolDefinition = {\n  name: 'wp_cli',\n  description: 'Run a WP-CLI command against a WordPress site. The site must be running.',\n  inputSchema: {\n    type: 'object',\n    properties: {\n      site: {\n        type: 'string',\n        description: 'Site name or ID (partial names work)',\n      },\n      command: {\n        oneOf: [\n          {\n            type: 'array',\n            items: { type: 'string' },\n            description: 'WP-CLI command as array, e.g. [\"plugin\", \"list\", \"--format=json\"]',\n          },\n          {\n            type: 'string',\n            description: 'WP-CLI command as string, e.g. \"plugin list --format=json\"',\n          },\n        ],\n        description: 'WP-CLI command - either as array [\"plugin\", \"list\"] or string \"plugin list\"',\n      },\n    },\n    required: ['site', 'command'],\n  },\n};\n\ninterface WpCliArgs {\n  site: string;\n  command: string[] | string;\n}\n\nexport async function wpCli(\n  args: Record<string, unknown>,\n  services: LocalServices\n): Promise<McpToolResult> {\n  const { site: siteQuery, command: rawCommand } = args as unknown as WpCliArgs;\n\n  // Validate required parameters\n  const siteError = validateRequiredParam(siteQuery, 'site');\n  if (siteError) return siteError;\n\n  const commandError = validateRequiredParam(rawCommand, 'command');\n  if (commandError) return commandError;\n\n  // Normalize command to array - accept both string and array formats\n  let command: string[];\n  if (typeof rawCommand === 'string') {\n    // Split string on whitespace, preserving quoted strings would be complex\n    // For simple cases, split on spaces\n    command = rawCommand.trim().split(/\\s+/).filter(Boolean);\n  } else if (Array.isArray(rawCommand)) {\n    command = rawCommand;\n  } else {\n    return {\n      content: [\n        {\n          type: 'text',\n          text: 'Error: command must be a string or array of strings',\n        },\n      ],\n      isError: true,\n    };\n  }\n\n  if (command.length === 0) {\n    return createErrorResult('Error: command cannot be empty');\n  }\n\n  // Security: Check for blocked commands\n  const blockedCommand = isBlockedWpCommand(command);\n  if (blockedCommand) {\n    return createErrorResult(\n      `Error: Command \"${blockedCommand}\" is blocked for security reasons. This command could allow arbitrary code execution.`\n    );\n  }\n\n  // Find site or return error\n  const siteResult = findSiteOrError(siteQuery, services.siteData);\n  if ('error' in siteResult) return siteResult.error;\n  const { site } = siteResult;\n\n  try {\n    const currentStatus = await services.siteProcessManager.getSiteStatus(site);\n\n    if (currentStatus !== 'running') {\n      return {\n        content: [\n          {\n            type: 'text',\n            text: `Site \"${site.name}\" is not running. Start it first with the start_site tool.`,\n          },\n        ],\n        isError: true,\n      };\n    }\n\n    const output = await services.wpCli.run(site, command, {\n      skipPlugins: true,\n      skipThemes: true,\n      ignoreErrors: false,\n    });\n\n    return {\n      content: [{ type: 'text', text: output?.trim() || '(no output)' }],\n    };\n  } catch (error: any) {\n    return {\n      content: [{ type: 'text', text: `WP-CLI error: ${error.message}` }],\n      isError: true,\n    };\n  }\n}\n"]}

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

@@ -0,0 +1 @@
+export { default } from './main/index';

package/addon-dist/lib/main.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+// Re-export default from main/index
+var index_1 = require("./main/index");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(index_1).default; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFpbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9tYWluLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLG9DQUFvQztBQUNwQyxzQ0FBdUM7QUFBOUIsaUhBQUEsT0FBTyxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gUmUtZXhwb3J0IGRlZmF1bHQgZnJvbSBtYWluL2luZGV4XG5leHBvcnQgeyBkZWZhdWx0IH0gZnJvbSAnLi9tYWluL2luZGV4JztcbiJdfQ==

package/addon-dist/lib/renderer/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * MCP Server Addon - Renderer Entry Point
+ * Adds MCP Server preferences panel to Local
+ *
+ * Uses class components for compatibility with Local's Electron environment.
+ */
+export {};