@local-labs-jpollock/local-cli 0.0.1

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

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * import_database Tool
+ * Import SQL file into site database using WP-CLI
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importDatabaseDefinition = void 0;
+exports.importDatabase = importDatabase;
+const helpers_1 = require("./helpers");
+const fs = __importStar(require("fs"));
+exports.importDatabaseDefinition = {
+    name: 'import_database',
+    description: 'Import a SQL file into a site database',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID',
+            },
+            sqlPath: {
+                type: 'string',
+                description: 'Path to the SQL file to import',
+            },
+        },
+        required: ['site', 'sqlPath'],
+    },
+};
+async function importDatabase(args, services) {
+    const { site: siteQuery, sqlPath } = args;
+    // Validate required parameters
+    const siteError = (0, helpers_1.validateRequiredParam)(siteQuery, 'site');
+    if (siteError)
+        return siteError;
+    const pathError = (0, helpers_1.validateRequiredParam)(sqlPath, 'sqlPath');
+    if (pathError)
+        return pathError;
+    // Security: Validate path is safe (no path traversal attacks)
+    if (!(0, helpers_1.isValidSqlPath)(sqlPath)) {
+        return (0, helpers_1.createErrorResult)('Error: Invalid SQL file path. Path must end in .sql and be within allowed directories (home, tmp).');
+    }
+    // Verify file exists
+    if (!fs.existsSync(sqlPath)) {
+        return (0, helpers_1.createErrorResult)(`SQL file not found: ${sqlPath}`);
+    }
+    // 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 {
+        // Run WP-CLI db import
+        const result = await services.wpCli.run(site, ['db', 'import', sqlPath]);
+        if (result === null) {
+            return {
+                content: [{ type: 'text', text: `Failed to import database for "${site.name}"` }],
+                isError: true,
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Successfully imported "${sqlPath}" into database for "${site.name}"`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to import database: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+/**
+ * import_site Tool
+ * Import a site from a zip file
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const importSiteDefinition: McpToolDefinition;
+export declare function importSite(args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;

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

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * import_site Tool
+ * Import a site from a zip file
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importSiteDefinition = void 0;
+exports.importSite = importSite;
+const helpers_1 = require("./helpers");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+exports.importSiteDefinition = {
+    name: 'import_site',
+    description: 'Import a WordPress site from a zip file (Local export, generic archive, or backup)',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            zipPath: {
+                type: 'string',
+                description: 'Path to the zip file to import',
+            },
+            siteName: {
+                type: 'string',
+                description: 'Name for the imported site (optional, derived from zip if not provided)',
+            },
+        },
+        required: ['zipPath'],
+    },
+};
+async function importSite(args, services) {
+    const { zipPath, siteName } = args;
+    if (!zipPath) {
+        return {
+            content: [{ type: 'text', text: 'Error: zipPath parameter is required' }],
+            isError: true,
+        };
+    }
+    // Security: Validate path is safe (no path traversal attacks)
+    if (!(0, helpers_1.isValidFilePath)(zipPath)) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: 'Error: Invalid zip file path. Path must be within allowed directories (home, tmp).',
+                },
+            ],
+            isError: true,
+        };
+    }
+    try {
+        // Verify file exists
+        if (!fs.existsSync(zipPath)) {
+            return {
+                content: [{ type: 'text', text: `Zip file not found: ${zipPath}` }],
+                isError: true,
+            };
+        }
+        // Verify it's a zip file
+        if (!zipPath.toLowerCase().endsWith('.zip')) {
+            return {
+                content: [{ type: 'text', text: 'Error: File must be a .zip archive' }],
+                isError: true,
+            };
+        }
+        // Check if importSite service exists
+        if (!services.importSite) {
+            return {
+                content: [{ type: 'text', text: 'Import site service not available' }],
+                isError: true,
+            };
+        }
+        // Derive site name from zip filename if not provided
+        const derivedName = siteName || path.basename(zipPath, '.zip').replace(/[^a-zA-Z0-9-_]/g, '-');
+        // Import the site
+        // The import service expects settings object
+        const importSettings = {
+            importType: 'localExport', // Default to Local export format
+            zipPath: zipPath,
+            siteName: derivedName,
+        };
+        const result = await services.importSite.run(importSettings);
+        if (!result) {
+            return {
+                content: [{ type: 'text', text: 'Import completed but no result returned' }],
+                isError: true,
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Successfully imported site "${derivedName}" from ${path.basename(zipPath)}. Site ID: ${result.id || 'unknown'}`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        // Provide helpful error messages
+        if (error.message?.includes('not a valid')) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `The zip file does not appear to be a valid Local export or WordPress backup. Error: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: 'text', text: `Failed to import site: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"importSite.js","sourceRoot":"","sources":["../../../../src/main/mcp/tools/importSite.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * import_site Tool\n * Import a site from a zip file\n */\n\nimport { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';\nimport { isValidFilePath } from './helpers';\nimport * as fs from 'fs';\nimport * as path from 'path';\n\nexport const importSiteDefinition: McpToolDefinition = {\n  name: 'import_site',\n  description: 'Import a WordPress site from a zip file (Local export, generic archive, or backup)',\n  inputSchema: {\n    type: 'object',\n    properties: {\n      zipPath: {\n        type: 'string',\n        description: 'Path to the zip file to import',\n      },\n      siteName: {\n        type: 'string',\n        description: 'Name for the imported site (optional, derived from zip if not provided)',\n      },\n    },\n    required: ['zipPath'],\n  },\n};\n\ninterface ImportSiteArgs {\n  zipPath: string;\n  siteName?: string;\n}\n\nexport async function importSite(\n  args: Record<string, unknown>,\n  services: LocalServices\n): Promise<McpToolResult> {\n  const { zipPath, siteName } = args as unknown as ImportSiteArgs;\n\n  if (!zipPath) {\n    return {\n      content: [{ type: 'text', text: 'Error: zipPath parameter is required' }],\n      isError: true,\n    };\n  }\n\n  // Security: Validate path is safe (no path traversal attacks)\n  if (!isValidFilePath(zipPath)) {\n    return {\n      content: [\n        {\n          type: 'text',\n          text: 'Error: Invalid zip file path. Path must be within allowed directories (home, tmp).',\n        },\n      ],\n      isError: true,\n    };\n  }\n\n  try {\n    // Verify file exists\n    if (!fs.existsSync(zipPath)) {\n      return {\n        content: [{ type: 'text', text: `Zip file not found: ${zipPath}` }],\n        isError: true,\n      };\n    }\n\n    // Verify it's a zip file\n    if (!zipPath.toLowerCase().endsWith('.zip')) {\n      return {\n        content: [{ type: 'text', text: 'Error: File must be a .zip archive' }],\n        isError: true,\n      };\n    }\n\n    // Check if importSite service exists\n    if (!services.importSite) {\n      return {\n        content: [{ type: 'text', text: 'Import site service not available' }],\n        isError: true,\n      };\n    }\n\n    // Derive site name from zip filename if not provided\n    const derivedName = siteName || path.basename(zipPath, '.zip').replace(/[^a-zA-Z0-9-_]/g, '-');\n\n    // Import the site\n    // The import service expects settings object\n    const importSettings = {\n      importType: 'localExport', // Default to Local export format\n      zipPath: zipPath,\n      siteName: derivedName,\n    };\n\n    const result = await services.importSite.run(importSettings);\n\n    if (!result) {\n      return {\n        content: [{ type: 'text', text: 'Import completed but no result returned' }],\n        isError: true,\n      };\n    }\n\n    return {\n      content: [\n        {\n          type: 'text',\n          text: `Successfully imported site \"${derivedName}\" from ${path.basename(zipPath)}. Site ID: ${result.id || 'unknown'}`,\n        },\n      ],\n    };\n  } catch (error: any) {\n    // Provide helpful error messages\n    if (error.message?.includes('not a valid')) {\n      return {\n        content: [\n          {\n            type: 'text',\n            text: `The zip file does not appear to be a valid Local export or WordPress backup. Error: ${error.message}`,\n          },\n        ],\n        isError: true,\n      };\n    }\n    return {\n      content: [{ type: 'text', text: `Failed to import site: ${error.message}` }],\n      isError: true,\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,26 @@
+/**
+ * MCP Tools Registry
+ * Central registry for all available MCP tools
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export type ToolHandler = (args: Record<string, unknown>, services: LocalServices) => Promise<McpToolResult>;
+/**
+ * Register all available tools
+ */
+export declare function registerTools(): void;
+/**
+ * Get all tool definitions (for MCP tools/list response)
+ */
+export declare function getToolDefinitions(): McpToolDefinition[];
+/**
+ * Get tool names
+ */
+export declare function getToolNames(): string[];
+/**
+ * Execute a tool by name
+ */
+export declare function executeTool(name: string, args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;
+/**
+ * Check if a tool exists
+ */
+export declare function hasTool(name: string): boolean;

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

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * MCP Tools Registry
+ * Central registry for all available MCP tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTools = registerTools;
+exports.getToolDefinitions = getToolDefinitions;
+exports.getToolNames = getToolNames;
+exports.executeTool = executeTool;
+exports.hasTool = hasTool;
+const listSites_1 = require("./listSites");
+const startSite_1 = require("./startSite");
+const stopSite_1 = require("./stopSite");
+const restartSite_1 = require("./restartSite");
+const wpCli_1 = require("./wpCli");
+const getSite_1 = require("./getSite");
+const createSite_1 = require("./createSite");
+const deleteSite_1 = require("./deleteSite");
+const getLocalInfo_1 = require("./getLocalInfo");
+const openSite_1 = require("./openSite");
+const cloneSite_1 = require("./cloneSite");
+const exportSite_1 = require("./exportSite");
+const listBlueprints_1 = require("./listBlueprints");
+const saveBlueprint_1 = require("./saveBlueprint");
+// Phase 8: WordPress Development Tools
+const exportDatabase_1 = require("./exportDatabase");
+const importDatabase_1 = require("./importDatabase");
+const openAdminer_1 = require("./openAdminer");
+const trustSsl_1 = require("./trustSsl");
+const renameSite_1 = require("./renameSite");
+const changePhpVersion_1 = require("./changePhpVersion");
+const importSite_1 = require("./importSite");
+// Phase 9: Site Configuration & Dev Tools
+const toggleXdebug_1 = require("./toggleXdebug");
+const getSiteLogs_1 = require("./getSiteLogs");
+const listServices_1 = require("./listServices");
+const tools = new Map();
+/**
+ * Register all available tools
+ */
+function registerTools() {
+    // Core site management
+    tools.set('list_sites', { definition: listSites_1.listSitesDefinition, handler: listSites_1.listSites });
+    tools.set('get_site', { definition: getSite_1.getSiteDefinition, handler: getSite_1.getSite });
+    tools.set('start_site', { definition: startSite_1.startSiteDefinition, handler: startSite_1.startSite });
+    tools.set('stop_site', { definition: stopSite_1.stopSiteDefinition, handler: stopSite_1.stopSite });
+    tools.set('restart_site', { definition: restartSite_1.restartSiteDefinition, handler: restartSite_1.restartSite });
+    // Site operations
+    tools.set('create_site', { definition: createSite_1.createSiteDefinition, handler: createSite_1.createSite });
+    tools.set('delete_site', { definition: deleteSite_1.deleteSiteDefinition, handler: deleteSite_1.deleteSite });
+    tools.set('clone_site', { definition: cloneSite_1.cloneSiteDefinition, handler: cloneSite_1.cloneSite });
+    tools.set('export_site', { definition: exportSite_1.exportSiteDefinition, handler: exportSite_1.exportSite });
+    tools.set('open_site', { definition: openSite_1.openSiteDefinition, handler: openSite_1.openSite });
+    // WordPress CLI
+    tools.set('wp_cli', { definition: wpCli_1.wpCliDefinition, handler: wpCli_1.wpCli });
+    // Blueprints
+    tools.set('list_blueprints', { definition: listBlueprints_1.listBlueprintsDefinition, handler: listBlueprints_1.listBlueprints });
+    tools.set('save_blueprint', { definition: saveBlueprint_1.saveBlueprintDefinition, handler: saveBlueprint_1.saveBlueprint });
+    // System info
+    tools.set('get_local_info', { definition: getLocalInfo_1.getLocalInfoDefinition, handler: getLocalInfo_1.getLocalInfo });
+    // Phase 8: WordPress Development Tools
+    tools.set('export_database', { definition: exportDatabase_1.exportDatabaseDefinition, handler: exportDatabase_1.exportDatabase });
+    tools.set('import_database', { definition: importDatabase_1.importDatabaseDefinition, handler: importDatabase_1.importDatabase });
+    tools.set('open_adminer', { definition: openAdminer_1.openAdminerDefinition, handler: openAdminer_1.openAdminer });
+    tools.set('trust_ssl', { definition: trustSsl_1.trustSslDefinition, handler: trustSsl_1.trustSsl });
+    tools.set('rename_site', { definition: renameSite_1.renameSiteDefinition, handler: renameSite_1.renameSite });
+    tools.set('change_php_version', {
+        definition: changePhpVersion_1.changePhpVersionDefinition,
+        handler: changePhpVersion_1.changePhpVersion,
+    });
+    tools.set('import_site', { definition: importSite_1.importSiteDefinition, handler: importSite_1.importSite });
+    // Phase 9: Site Configuration & Dev Tools
+    tools.set('toggle_xdebug', { definition: toggleXdebug_1.toggleXdebugDefinition, handler: toggleXdebug_1.toggleXdebug });
+    tools.set('get_site_logs', { definition: getSiteLogs_1.getSiteLogsDefinition, handler: getSiteLogs_1.getSiteLogs });
+    tools.set('list_services', { definition: listServices_1.listServicesDefinition, handler: listServices_1.listServices });
+}
+/**
+ * Get all tool definitions (for MCP tools/list response)
+ */
+function getToolDefinitions() {
+    return Array.from(tools.values()).map((t) => t.definition);
+}
+/**
+ * Get tool names
+ */
+function getToolNames() {
+    return Array.from(tools.keys());
+}
+/**
+ * Execute a tool by name
+ */
+async function executeTool(name, args, services) {
+    const tool = tools.get(name);
+    if (!tool) {
+        return {
+            content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+            isError: true,
+        };
+    }
+    try {
+        return await tool.handler(args, services);
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Tool error: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Check if a tool exists
+ */
+function hasTool(name) {
+    return tools.has(name);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/main/mcp/tools/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * MCP Tools Registry\n * Central registry for all available MCP tools\n */\n\nimport { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';\nimport { listSites, listSitesDefinition } from './listSites';\nimport { startSite, startSiteDefinition } from './startSite';\nimport { stopSite, stopSiteDefinition } from './stopSite';\nimport { restartSite, restartSiteDefinition } from './restartSite';\nimport { wpCli, wpCliDefinition } from './wpCli';\nimport { getSite, getSiteDefinition } from './getSite';\nimport { createSite, createSiteDefinition } from './createSite';\nimport { deleteSite, deleteSiteDefinition } from './deleteSite';\nimport { getLocalInfo, getLocalInfoDefinition } from './getLocalInfo';\nimport { openSite, openSiteDefinition } from './openSite';\nimport { cloneSite, cloneSiteDefinition } from './cloneSite';\nimport { exportSite, exportSiteDefinition } from './exportSite';\nimport { listBlueprints, listBlueprintsDefinition } from './listBlueprints';\nimport { saveBlueprint, saveBlueprintDefinition } from './saveBlueprint';\n// Phase 8: WordPress Development Tools\nimport { exportDatabase, exportDatabaseDefinition } from './exportDatabase';\nimport { importDatabase, importDatabaseDefinition } from './importDatabase';\nimport { openAdminer, openAdminerDefinition } from './openAdminer';\nimport { trustSsl, trustSslDefinition } from './trustSsl';\nimport { renameSite, renameSiteDefinition } from './renameSite';\nimport { changePhpVersion, changePhpVersionDefinition } from './changePhpVersion';\nimport { importSite, importSiteDefinition } from './importSite';\n// Phase 9: Site Configuration & Dev Tools\nimport { toggleXdebug, toggleXdebugDefinition } from './toggleXdebug';\nimport { getSiteLogs, getSiteLogsDefinition } from './getSiteLogs';\nimport { listServices, listServicesDefinition } from './listServices';\n\nexport type ToolHandler = (\n  args: Record<string, unknown>,\n  services: LocalServices\n) => Promise<McpToolResult>;\n\ninterface ToolRegistration {\n  definition: McpToolDefinition;\n  handler: ToolHandler;\n}\n\nconst tools: Map<string, ToolRegistration> = new Map();\n\n/**\n * Register all available tools\n */\nexport function registerTools(): void {\n  // Core site management\n  tools.set('list_sites', { definition: listSitesDefinition, handler: listSites });\n  tools.set('get_site', { definition: getSiteDefinition, handler: getSite });\n  tools.set('start_site', { definition: startSiteDefinition, handler: startSite });\n  tools.set('stop_site', { definition: stopSiteDefinition, handler: stopSite });\n  tools.set('restart_site', { definition: restartSiteDefinition, handler: restartSite });\n\n  // Site operations\n  tools.set('create_site', { definition: createSiteDefinition, handler: createSite });\n  tools.set('delete_site', { definition: deleteSiteDefinition, handler: deleteSite });\n  tools.set('clone_site', { definition: cloneSiteDefinition, handler: cloneSite });\n  tools.set('export_site', { definition: exportSiteDefinition, handler: exportSite });\n  tools.set('open_site', { definition: openSiteDefinition, handler: openSite });\n\n  // WordPress CLI\n  tools.set('wp_cli', { definition: wpCliDefinition, handler: wpCli });\n\n  // Blueprints\n  tools.set('list_blueprints', { definition: listBlueprintsDefinition, handler: listBlueprints });\n  tools.set('save_blueprint', { definition: saveBlueprintDefinition, handler: saveBlueprint });\n\n  // System info\n  tools.set('get_local_info', { definition: getLocalInfoDefinition, handler: getLocalInfo });\n\n  // Phase 8: WordPress Development Tools\n  tools.set('export_database', { definition: exportDatabaseDefinition, handler: exportDatabase });\n  tools.set('import_database', { definition: importDatabaseDefinition, handler: importDatabase });\n  tools.set('open_adminer', { definition: openAdminerDefinition, handler: openAdminer });\n  tools.set('trust_ssl', { definition: trustSslDefinition, handler: trustSsl });\n  tools.set('rename_site', { definition: renameSiteDefinition, handler: renameSite });\n  tools.set('change_php_version', {\n    definition: changePhpVersionDefinition,\n    handler: changePhpVersion,\n  });\n  tools.set('import_site', { definition: importSiteDefinition, handler: importSite });\n\n  // Phase 9: Site Configuration & Dev Tools\n  tools.set('toggle_xdebug', { definition: toggleXdebugDefinition, handler: toggleXdebug });\n  tools.set('get_site_logs', { definition: getSiteLogsDefinition, handler: getSiteLogs });\n  tools.set('list_services', { definition: listServicesDefinition, handler: listServices });\n}\n\n/**\n * Get all tool definitions (for MCP tools/list response)\n */\nexport function getToolDefinitions(): McpToolDefinition[] {\n  return Array.from(tools.values()).map((t) => t.definition);\n}\n\n/**\n * Get tool names\n */\nexport function getToolNames(): string[] {\n  return Array.from(tools.keys());\n}\n\n/**\n * Execute a tool by name\n */\nexport async function executeTool(\n  name: string,\n  args: Record<string, unknown>,\n  services: LocalServices\n): Promise<McpToolResult> {\n  const tool = tools.get(name);\n\n  if (!tool) {\n    return {\n      content: [{ type: 'text', text: `Unknown tool: ${name}` }],\n      isError: true,\n    };\n  }\n\n  try {\n    return await tool.handler(args, services);\n  } catch (error: any) {\n    return {\n      content: [{ type: 'text', text: `Tool error: ${error.message}` }],\n      isError: true,\n    };\n  }\n}\n\n/**\n * Check if a tool exists\n */\nexport function hasTool(name: string): boolean {\n  return tools.has(name);\n}\n"]}

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

@@ -0,0 +1,7 @@
+/**
+ * list_blueprints Tool
+ * List all available site blueprints
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const listBlueprintsDefinition: McpToolDefinition;
+export declare function listBlueprints(_args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;

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

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * list_blueprints Tool
+ * List all available site blueprints
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listBlueprintsDefinition = void 0;
+exports.listBlueprints = listBlueprints;
+exports.listBlueprintsDefinition = {
+    name: 'list_blueprints',
+    description: 'List all available site blueprints (templates)',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+    },
+};
+async function listBlueprints(_args, services) {
+    try {
+        // Check if blueprints service exists
+        if (!services.blueprints) {
+            return {
+                content: [{ type: 'text', text: 'Blueprints service not available' }],
+                isError: true,
+            };
+        }
+        const blueprints = await services.blueprints.getBlueprints();
+        if (!blueprints || blueprints.length === 0) {
+            return {
+                content: [{ type: 'text', text: 'No blueprints found. Create one using save_blueprint.' }],
+            };
+        }
+        const blueprintList = blueprints.map((bp) => ({
+            id: bp.id,
+            name: bp.name,
+            description: bp.description || '',
+            createdAt: bp.createdAt,
+        }));
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(blueprintList, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to list blueprints: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+/**
+ * list_services Tool
+ * List available Lightning Services (PHP, MySQL, Nginx versions)
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const listServicesDefinition: McpToolDefinition;
+export declare function listServices(args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;