@local-labs-jpollock/local-cli 0.0.1

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

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * list_services Tool
+ * List available Lightning Services (PHP, MySQL, Nginx versions)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listServicesDefinition = void 0;
+exports.listServices = listServices;
+exports.listServicesDefinition = {
+    name: 'list_services',
+    description: 'List available service versions (PHP, MySQL, Nginx) that can be used with sites',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            type: {
+                type: 'string',
+                enum: ['php', 'database', 'webserver', 'all'],
+                description: 'Type of services to list (default: all)',
+            },
+        },
+    },
+};
+async function listServices(args, services) {
+    const { type = 'all' } = args;
+    try {
+        // Check if lightningServices is available
+        if (!services.lightningServices) {
+            return {
+                content: [{ type: 'text', text: 'Lightning Services not available' }],
+                isError: true,
+            };
+        }
+        const registeredServices = services.lightningServices.getRegisteredServices();
+        if (!registeredServices) {
+            return {
+                content: [{ type: 'text', text: 'No services registered' }],
+                isError: true,
+            };
+        }
+        const results = [];
+        // Helper to format service list
+        const formatServices = (serviceName, serviceData) => {
+            const versions = [];
+            if (serviceData && typeof serviceData === 'object') {
+                for (const version of Object.keys(serviceData)) {
+                    const info = serviceData[version];
+                    const label = info?.label || serviceName;
+                    versions.push(`  - ${version}${label !== serviceName ? ` (${label})` : ''}`);
+                }
+            }
+            return versions;
+        };
+        // PHP versions
+        if (type === 'all' || type === 'php') {
+            results.push('PHP Versions:');
+            const phpVersions = formatServices('php', registeredServices.php);
+            if (phpVersions.length > 0) {
+                results.push(...phpVersions);
+            }
+            else {
+                results.push('  [No PHP versions installed]');
+            }
+        }
+        // Database versions (MySQL and MariaDB)
+        if (type === 'all' || type === 'database') {
+            results.push('\nDatabase Versions:');
+            if (registeredServices.mysql) {
+                results.push('  MySQL:');
+                const mysqlVersions = formatServices('mysql', registeredServices.mysql);
+                if (mysqlVersions.length > 0) {
+                    results.push(...mysqlVersions.map((v) => '  ' + v));
+                }
+            }
+            if (registeredServices.mariadb) {
+                results.push('  MariaDB:');
+                const mariadbVersions = formatServices('mariadb', registeredServices.mariadb);
+                if (mariadbVersions.length > 0) {
+                    results.push(...mariadbVersions.map((v) => '  ' + v));
+                }
+            }
+            if (!registeredServices.mysql && !registeredServices.mariadb) {
+                results.push('  [No database versions installed]');
+            }
+        }
+        // Web server versions (Nginx)
+        if (type === 'all' || type === 'webserver') {
+            results.push('\nWeb Server Versions:');
+            const nginxVersions = formatServices('nginx', registeredServices.nginx);
+            if (nginxVersions.length > 0) {
+                results.push(...nginxVersions);
+            }
+            else {
+                results.push('  [No web server versions installed]');
+            }
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: results.join('\n'),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to list services: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"listServices.js","sourceRoot":"","sources":["../../../../src/main/mcp/tools/listServices.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * list_services Tool\n * List available Lightning Services (PHP, MySQL, Nginx versions)\n */\n\nimport { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';\n\nexport const listServicesDefinition: McpToolDefinition = {\n  name: 'list_services',\n  description: 'List available service versions (PHP, MySQL, Nginx) that can be used with sites',\n  inputSchema: {\n    type: 'object',\n    properties: {\n      type: {\n        type: 'string',\n        enum: ['php', 'database', 'webserver', 'all'],\n        description: 'Type of services to list (default: all)',\n      },\n    },\n  },\n};\n\ninterface ListServicesArgs {\n  type?: 'php' | 'database' | 'webserver' | 'all';\n}\n\nexport async function listServices(\n  args: Record<string, unknown>,\n  services: LocalServices\n): Promise<McpToolResult> {\n  const { type = 'all' } = args as unknown as ListServicesArgs;\n\n  try {\n    // Check if lightningServices is available\n    if (!services.lightningServices) {\n      return {\n        content: [{ type: 'text', text: 'Lightning Services not available' }],\n        isError: true,\n      };\n    }\n\n    const registeredServices = services.lightningServices.getRegisteredServices();\n\n    if (!registeredServices) {\n      return {\n        content: [{ type: 'text', text: 'No services registered' }],\n        isError: true,\n      };\n    }\n\n    const results: string[] = [];\n\n    // Helper to format service list\n    const formatServices = (serviceName: string, serviceData: any): string[] => {\n      const versions: string[] = [];\n      if (serviceData && typeof serviceData === 'object') {\n        for (const version of Object.keys(serviceData)) {\n          const info = serviceData[version];\n          const label = info?.label || serviceName;\n          versions.push(`  - ${version}${label !== serviceName ? ` (${label})` : ''}`);\n        }\n      }\n      return versions;\n    };\n\n    // PHP versions\n    if (type === 'all' || type === 'php') {\n      results.push('PHP Versions:');\n      const phpVersions = formatServices('php', registeredServices.php);\n      if (phpVersions.length > 0) {\n        results.push(...phpVersions);\n      } else {\n        results.push('  [No PHP versions installed]');\n      }\n    }\n\n    // Database versions (MySQL and MariaDB)\n    if (type === 'all' || type === 'database') {\n      results.push('\\nDatabase Versions:');\n\n      if (registeredServices.mysql) {\n        results.push('  MySQL:');\n        const mysqlVersions = formatServices('mysql', registeredServices.mysql);\n        if (mysqlVersions.length > 0) {\n          results.push(...mysqlVersions.map((v) => '  ' + v));\n        }\n      }\n\n      if (registeredServices.mariadb) {\n        results.push('  MariaDB:');\n        const mariadbVersions = formatServices('mariadb', registeredServices.mariadb);\n        if (mariadbVersions.length > 0) {\n          results.push(...mariadbVersions.map((v) => '  ' + v));\n        }\n      }\n\n      if (!registeredServices.mysql && !registeredServices.mariadb) {\n        results.push('  [No database versions installed]');\n      }\n    }\n\n    // Web server versions (Nginx)\n    if (type === 'all' || type === 'webserver') {\n      results.push('\\nWeb Server Versions:');\n      const nginxVersions = formatServices('nginx', registeredServices.nginx);\n      if (nginxVersions.length > 0) {\n        results.push(...nginxVersions);\n      } else {\n        results.push('  [No web server versions installed]');\n      }\n    }\n\n    return {\n      content: [\n        {\n          type: 'text',\n          text: results.join('\\n'),\n        },\n      ],\n    };\n  } catch (error: any) {\n    return {\n      content: [{ type: 'text', text: `Failed to list services: ${error.message}` }],\n      isError: true,\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,7 @@
+/**
+ * list_sites Tool
+ * List all WordPress sites in Local
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const listSitesDefinition: McpToolDefinition;
+export declare function listSites(args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;

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

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * list_sites Tool
+ * List all WordPress sites in Local
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSitesDefinition = void 0;
+exports.listSites = listSites;
+exports.listSitesDefinition = {
+    name: 'list_sites',
+    description: 'List all WordPress sites in Local with their name, ID, status, and domain',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            status: {
+                type: 'string',
+                enum: ['all', 'running', 'stopped'],
+                description: 'Filter sites by status (default: all)',
+            },
+        },
+    },
+};
+async function listSites(args, services) {
+    const { status = 'all' } = args;
+    try {
+        const sitesMap = services.siteData.getSites();
+        const allSites = Object.values(sitesMap);
+        // Get status for each site
+        const sitesWithStatus = await Promise.all(allSites.map(async (site) => {
+            const siteStatus = await services.siteProcessManager.getSiteStatus(site);
+            return {
+                id: site.id,
+                name: site.name,
+                status: siteStatus,
+                domain: site.domain,
+                path: site.path,
+            };
+        }));
+        // Filter by status if requested
+        let filteredSites = sitesWithStatus;
+        if (status === 'running') {
+            filteredSites = sitesWithStatus.filter((s) => s.status === 'running');
+        }
+        else if (status === 'stopped') {
+            filteredSites = sitesWithStatus.filter((s) => s.status !== 'running');
+        }
+        const result = {
+            count: filteredSites.length,
+            sites: filteredSites,
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to list sites: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+/**
+ * open_adminer Tool
+ * Open Adminer database management UI for a site
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const openAdminerDefinition: McpToolDefinition;
+export declare function openAdminer(args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;

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

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * open_adminer Tool
+ * Open Adminer database management UI for a site
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openAdminerDefinition = void 0;
+exports.openAdminer = openAdminer;
+const helpers_1 = require("./helpers");
+exports.openAdminerDefinition = {
+    name: 'open_adminer',
+    description: 'Open Adminer database management UI for a site',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID',
+            },
+        },
+        required: ['site'],
+    },
+};
+async function openAdminer(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 adminer service exists
+        if (!services.adminer) {
+            return {
+                content: [{ type: 'text', text: 'Adminer service not available' }],
+                isError: true,
+            };
+        }
+        // Open Adminer
+        await services.adminer.open(site);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Opened Adminer for "${site.name}". Database admin UI should open in your browser.`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to open Adminer: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+/**
+ * open_site Tool
+ * Open a WordPress site in the default browser
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const openSiteDefinition: McpToolDefinition;
+export declare function openSite(args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;

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

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * open_site Tool
+ * Open a WordPress site in the default browser
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openSiteDefinition = void 0;
+exports.openSite = openSite;
+const helpers_1 = require("./helpers");
+exports.openSiteDefinition = {
+    name: 'open_site',
+    description: 'Open a WordPress site in the default browser',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID',
+            },
+            path: {
+                type: 'string',
+                description: 'Path to open (default: /, use /wp-admin for admin panel)',
+            },
+        },
+        required: ['site'],
+    },
+};
+async function openSite(args, services) {
+    const { site: siteQuery, path = '/' } = 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 {
+        // Get the site URL
+        const domain = site.domain || `${site.name}.local`;
+        const protocol = site.services?.nginx?.https === 'on' ? 'https' : 'http';
+        const url = `${protocol}://${domain}${path}`;
+        // Use the browser manager to open the URL
+        if (services.browserManager) {
+            await services.browserManager.openURL(url);
+        }
+        else {
+            // Fallback to shell open
+            const { shell } = require('electron');
+            await shell.openExternal(url);
+        }
+        return {
+            content: [{ type: 'text', text: `Opened ${url} in browser` }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to open site: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * rename_site Tool
+ * Rename a WordPress site
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renameSiteDefinition = void 0;
+exports.renameSite = renameSite;
+const helpers_1 = require("./helpers");
+exports.renameSiteDefinition = {
+    name: 'rename_site',
+    description: 'Rename a WordPress site',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Current site name or ID',
+            },
+            newName: {
+                type: 'string',
+                description: 'New name for the site',
+            },
+        },
+        required: ['site', 'newName'],
+    },
+};
+async function renameSite(args, services) {
+    const { site: siteQuery, newName } = args;
+    const siteError = (0, helpers_1.validateRequiredParam)(siteQuery, 'site');
+    if (siteError)
+        return siteError;
+    const nameError = (0, helpers_1.validateRequiredParam)(newName, 'newName');
+    if (nameError)
+        return nameError;
+    if (!newName.trim()) {
+        return (0, helpers_1.createErrorResult)('Error: newName cannot be empty');
+    }
+    const siteResult = (0, helpers_1.findSiteOrError)(siteQuery, services.siteData);
+    if ('error' in siteResult)
+        return siteResult.error;
+    const { site } = siteResult;
+    const oldName = site.name;
+    try {
+        // Check if updateSite method exists on siteData
+        if (!services.siteData.updateSite) {
+            return {
+                content: [{ type: 'text', text: 'Site update service not available' }],
+                isError: true,
+            };
+        }
+        // Update the site name
+        services.siteData.updateSite(site.id, { name: newName.trim() });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Successfully renamed site from "${oldName}" to "${newName.trim()}"`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to rename site: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * restart_site Tool
+ * Restart a WordPress site
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restartSiteDefinition = void 0;
+exports.restartSite = restartSite;
+const helpers_1 = require("./helpers");
+exports.restartSiteDefinition = {
+    name: 'restart_site',
+    description: 'Restart a WordPress site by name or ID. If stopped, it will be started.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID (partial names work)',
+            },
+        },
+        required: ['site'],
+    },
+};
+async function restartSite(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 {
+        const currentStatus = await services.siteProcessManager.getSiteStatus(site);
+        if (currentStatus === 'running') {
+            await services.siteProcessManager.restart(site);
+            return {
+                content: [{ type: 'text', text: `Site "${site.name}" restarted successfully` }],
+            };
+        }
+        else {
+            // If not running, just start it
+            await services.siteProcessManager.start(site);
+            return {
+                content: [{ type: 'text', text: `Site "${site.name}" was stopped, now started` }],
+            };
+        }
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to restart site: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+/**
+ * save_blueprint Tool
+ * Save a site as a blueprint
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const saveBlueprintDefinition: McpToolDefinition;
+export declare function saveBlueprint(args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;

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

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * save_blueprint Tool
+ * Save a site as a blueprint
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveBlueprintDefinition = void 0;
+exports.saveBlueprint = saveBlueprint;
+const helpers_1 = require("./helpers");
+exports.saveBlueprintDefinition = {
+    name: 'save_blueprint',
+    description: 'Save a site as a blueprint (template) for creating new sites',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID to save as blueprint',
+            },
+            name: {
+                type: 'string',
+                description: 'Name for the blueprint',
+            },
+            description: {
+                type: 'string',
+                description: 'Optional description for the blueprint',
+            },
+        },
+        required: ['site', 'name'],
+    },
+};
+async function saveBlueprint(args, services) {
+    const { site: siteQuery, name, description } = args;
+    if (!siteQuery) {
+        return {
+            content: [{ type: 'text', text: 'Error: site parameter is required' }],
+            isError: true,
+        };
+    }
+    if (!name) {
+        return {
+            content: [{ type: 'text', text: 'Error: name parameter is required' }],
+            isError: true,
+        };
+    }
+    try {
+        const site = (0, helpers_1.findSite)(siteQuery, services.siteData);
+        if (!site) {
+            const allSites = services.siteData.getSites();
+            const siteNames = allSites.map((s) => s.name).join(', ');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Site not found: "${siteQuery}". Available sites: ${siteNames || 'none'}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Check if blueprints service exists
+        if (!services.blueprints) {
+            return {
+                content: [{ type: 'text', text: 'Blueprints service not available' }],
+                isError: true,
+            };
+        }
+        // Save the blueprint
+        const blueprint = await services.blueprints.saveBlueprint(site, {
+            name,
+            description: description || '',
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Successfully saved blueprint "${name}" from site "${site.name}" (ID: ${blueprint.id})`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to save blueprint: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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