@local-labs-jpollock/local-cli 0.0.1

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

@@ -0,0 +1,7 @@
+/**
+ * get_local_info Tool
+ * Get information about the Local application
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const getLocalInfoDefinition: McpToolDefinition;
+export declare function getLocalInfo(_args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;

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

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * get_local_info Tool
+ * Get information about the Local application
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalInfoDefinition = void 0;
+exports.getLocalInfo = getLocalInfo;
+const os_1 = __importDefault(require("os"));
+const constants_1 = require("../../../common/constants");
+const index_1 = require("./index");
+exports.getLocalInfoDefinition = {
+    name: 'get_local_info',
+    description: 'Get information about the Local application including version, platform, MCP server status, and available tools',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+    },
+};
+async function getLocalInfo(_args, services) {
+    try {
+        const sitesMap = services.siteData.getSites();
+        const allSites = Object.values(sitesMap);
+        // Count sites by status
+        let runningSites = 0;
+        let stoppedSites = 0;
+        for (const site of allSites) {
+            const status = await services.siteProcessManager.getSiteStatus(site);
+            if (status === 'running') {
+                runningSites++;
+            }
+            else {
+                stoppedSites++;
+            }
+        }
+        const info = {
+            local: {
+                version: process.env.LOCAL_VERSION || 'unknown',
+                platform: os_1.default.platform(),
+                arch: os_1.default.arch(),
+            },
+            mcp: {
+                version: constants_1.MCP_SERVER.VERSION,
+                name: constants_1.MCP_SERVER.NAME,
+                tools: (0, index_1.getToolNames)(),
+            },
+            sites: {
+                total: allSites.length,
+                running: runningSites,
+                stopped: stoppedSites,
+            },
+            system: {
+                nodeVersion: process.version,
+                hostname: os_1.default.hostname(),
+                homeDir: os_1.default.homedir(),
+            },
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(info, null, 2) }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to get Local info: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0TG9jYWxJbmZvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21haW4vbWNwL3Rvb2xzL2dldExvY2FsSW5mby50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7OztHQUdHOzs7Ozs7QUFpQkgsb0NBb0RDO0FBbkVELDRDQUFvQjtBQUVwQix5REFBdUQ7QUFDdkQsbUNBQXVDO0FBRTFCLFFBQUEsc0JBQXNCLEdBQXNCO0lBQ3ZELElBQUksRUFBRSxnQkFBZ0I7SUFDdEIsV0FBVyxFQUNULGlIQUFpSDtJQUNuSCxXQUFXLEVBQUU7UUFDWCxJQUFJLEVBQUUsUUFBUTtRQUNkLFVBQVUsRUFBRSxFQUFFO0tBQ2Y7Q0FDRixDQUFDO0FBRUssS0FBSyxVQUFVLFlBQVksQ0FDaEMsS0FBOEIsRUFDOUIsUUFBdUI7SUFFdkIsSUFBSSxDQUFDO1FBQ0gsTUFBTSxRQUFRLEdBQUcsUUFBUSxDQUFDLFFBQVEsQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUM5QyxNQUFNLFFBQVEsR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBVSxDQUFDO1FBRWxELHdCQUF3QjtRQUN4QixJQUFJLFlBQVksR0FBRyxDQUFDLENBQUM7UUFDckIsSUFBSSxZQUFZLEdBQUcsQ0FBQyxDQUFDO1FBQ3JCLEtBQUssTUFBTSxJQUFJLElBQUksUUFBUSxFQUFFLENBQUM7WUFDNUIsTUFBTSxNQUFNLEdBQUcsTUFBTSxRQUFRLENBQUMsa0JBQWtCLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQ3JFLElBQUksTUFBTSxLQUFLLFNBQVMsRUFBRSxDQUFDO2dCQUN6QixZQUFZLEVBQUUsQ0FBQztZQUNqQixDQUFDO2lCQUFNLENBQUM7Z0JBQ04sWUFBWSxFQUFFLENBQUM7WUFDakIsQ0FBQztRQUNILENBQUM7UUFFRCxNQUFNLElBQUksR0FBRztZQUNYLEtBQUssRUFBRTtnQkFDTCxPQUFPLEVBQUUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxhQUFhLElBQUksU0FBUztnQkFDL0MsUUFBUSxFQUFFLFlBQUUsQ0FBQyxRQUFRLEVBQUU7Z0JBQ3ZCLElBQUksRUFBRSxZQUFFLENBQUMsSUFBSSxFQUFFO2FBQ2hCO1lBQ0QsR0FBRyxFQUFFO2dCQUNILE9BQU8sRUFBRSxzQkFBVSxDQUFDLE9BQU87Z0JBQzNCLElBQUksRUFBRSxzQkFBVSxDQUFDLElBQUk7Z0JBQ3JCLEtBQUssRUFBRSxJQUFBLG9CQUFZLEdBQUU7YUFDdEI7WUFDRCxLQUFLLEVBQUU7Z0JBQ0wsS0FBSyxFQUFFLFFBQVEsQ0FBQyxNQUFNO2dCQUN0QixPQUFPLEVBQUUsWUFBWTtnQkFDckIsT0FBTyxFQUFFLFlBQVk7YUFDdEI7WUFDRCxNQUFNLEVBQUU7Z0JBQ04sV0FBVyxFQUFFLE9BQU8sQ0FBQyxPQUFPO2dCQUM1QixRQUFRLEVBQUUsWUFBRSxDQUFDLFFBQVEsRUFBRTtnQkFDdkIsT0FBTyxFQUFFLFlBQUUsQ0FBQyxPQUFPLEVBQUU7YUFDdEI7U0FDRixDQUFDO1FBRUYsT0FBTztZQUNMLE9BQU8sRUFBRSxDQUFDLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUM7U0FDakUsQ0FBQztJQUNKLENBQUM7SUFBQyxPQUFPLEtBQVUsRUFBRSxDQUFDO1FBQ3BCLE9BQU87WUFDTCxPQUFPLEVBQUUsQ0FBQyxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLDZCQUE2QixLQUFLLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQztZQUMvRSxPQUFPLEVBQUUsSUFBSTtTQUNkLENBQUM7SUFDSixDQUFDO0FBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogZ2V0X2xvY2FsX2luZm8gVG9vbFxuICogR2V0IGluZm9ybWF0aW9uIGFib3V0IHRoZSBMb2NhbCBhcHBsaWNhdGlvblxuICovXG5cbmltcG9ydCBvcyBmcm9tICdvcyc7XG5pbXBvcnQgeyBNY3BUb29sRGVmaW5pdGlvbiwgTWNwVG9vbFJlc3VsdCwgTG9jYWxTZXJ2aWNlcyB9IGZyb20gJy4uLy4uLy4uL2NvbW1vbi90eXBlcyc7XG5pbXBvcnQgeyBNQ1BfU0VSVkVSIH0gZnJvbSAnLi4vLi4vLi4vY29tbW9uL2NvbnN0YW50cyc7XG5pbXBvcnQgeyBnZXRUb29sTmFtZXMgfSBmcm9tICcuL2luZGV4JztcblxuZXhwb3J0IGNvbnN0IGdldExvY2FsSW5mb0RlZmluaXRpb246IE1jcFRvb2xEZWZpbml0aW9uID0ge1xuICBuYW1lOiAnZ2V0X2xvY2FsX2luZm8nLFxuICBkZXNjcmlwdGlvbjpcbiAgICAnR2V0IGluZm9ybWF0aW9uIGFib3V0IHRoZSBMb2NhbCBhcHBsaWNhdGlvbiBpbmNsdWRpbmcgdmVyc2lvbiwgcGxhdGZvcm0sIE1DUCBzZXJ2ZXIgc3RhdHVzLCBhbmQgYXZhaWxhYmxlIHRvb2xzJyxcbiAgaW5wdXRTY2hlbWE6IHtcbiAgICB0eXBlOiAnb2JqZWN0JyxcbiAgICBwcm9wZXJ0aWVzOiB7fSxcbiAgfSxcbn07XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBnZXRMb2NhbEluZm8oXG4gIF9hcmdzOiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPixcbiAgc2VydmljZXM6IExvY2FsU2VydmljZXNcbik6IFByb21pc2U8TWNwVG9vbFJlc3VsdD4ge1xuICB0cnkge1xuICAgIGNvbnN0IHNpdGVzTWFwID0gc2VydmljZXMuc2l0ZURhdGEuZ2V0U2l0ZXMoKTtcbiAgICBjb25zdCBhbGxTaXRlcyA9IE9iamVjdC52YWx1ZXMoc2l0ZXNNYXApIGFzIGFueVtdO1xuXG4gICAgLy8gQ291bnQgc2l0ZXMgYnkgc3RhdHVzXG4gICAgbGV0IHJ1bm5pbmdTaXRlcyA9IDA7XG4gICAgbGV0IHN0b3BwZWRTaXRlcyA9IDA7XG4gICAgZm9yIChjb25zdCBzaXRlIG9mIGFsbFNpdGVzKSB7XG4gICAgICBjb25zdCBzdGF0dXMgPSBhd2FpdCBzZXJ2aWNlcy5zaXRlUHJvY2Vzc01hbmFnZXIuZ2V0U2l0ZVN0YXR1cyhzaXRlKTtcbiAgICAgIGlmIChzdGF0dXMgPT09ICdydW5uaW5nJykge1xuICAgICAgICBydW5uaW5nU2l0ZXMrKztcbiAgICAgIH0gZWxzZSB7XG4gICAgICAgIHN0b3BwZWRTaXRlcysrO1xuICAgICAgfVxuICAgIH1cblxuICAgIGNvbnN0IGluZm8gPSB7XG4gICAgICBsb2NhbDoge1xuICAgICAgICB2ZXJzaW9uOiBwcm9jZXNzLmVudi5MT0NBTF9WRVJTSU9OIHx8ICd1bmtub3duJyxcbiAgICAgICAgcGxhdGZvcm06IG9zLnBsYXRmb3JtKCksXG4gICAgICAgIGFyY2g6IG9zLmFyY2goKSxcbiAgICAgIH0sXG4gICAgICBtY3A6IHtcbiAgICAgICAgdmVyc2lvbjogTUNQX1NFUlZFUi5WRVJTSU9OLFxuICAgICAgICBuYW1lOiBNQ1BfU0VSVkVSLk5BTUUsXG4gICAgICAgIHRvb2xzOiBnZXRUb29sTmFtZXMoKSxcbiAgICAgIH0sXG4gICAgICBzaXRlczoge1xuICAgICAgICB0b3RhbDogYWxsU2l0ZXMubGVuZ3RoLFxuICAgICAgICBydW5uaW5nOiBydW5uaW5nU2l0ZXMsXG4gICAgICAgIHN0b3BwZWQ6IHN0b3BwZWRTaXRlcyxcbiAgICAgIH0sXG4gICAgICBzeXN0ZW06IHtcbiAgICAgICAgbm9kZVZlcnNpb246IHByb2Nlc3MudmVyc2lvbixcbiAgICAgICAgaG9zdG5hbWU6IG9zLmhvc3RuYW1lKCksXG4gICAgICAgIGhvbWVEaXI6IG9zLmhvbWVkaXIoKSxcbiAgICAgIH0sXG4gICAgfTtcblxuICAgIHJldHVybiB7XG4gICAgICBjb250ZW50OiBbeyB0eXBlOiAndGV4dCcsIHRleHQ6IEpTT04uc3RyaW5naWZ5KGluZm8sIG51bGwsIDIpIH1dLFxuICAgIH07XG4gIH0gY2F0Y2ggKGVycm9yOiBhbnkpIHtcbiAgICByZXR1cm4ge1xuICAgICAgY29udGVudDogW3sgdHlwZTogJ3RleHQnLCB0ZXh0OiBgRmFpbGVkIHRvIGdldCBMb2NhbCBpbmZvOiAke2Vycm9yLm1lc3NhZ2V9YCB9XSxcbiAgICAgIGlzRXJyb3I6IHRydWUsXG4gICAgfTtcbiAgfVxufVxuIl19

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

@@ -0,0 +1,7 @@
+/**
+ * get_site Tool
+ * Get detailed information about a specific site
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const getSiteDefinition: McpToolDefinition;
+export declare function getSite(args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;

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

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * get_site Tool
+ * Get detailed information about a specific site
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSiteDefinition = void 0;
+exports.getSite = getSite;
+const helpers_1 = require("./helpers");
+exports.getSiteDefinition = {
+    name: 'get_site',
+    description: 'Get detailed information about a WordPress site including PHP version, web server, database, and WordPress version',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID (partial names work)',
+            },
+        },
+        required: ['site'],
+    },
+};
+async function getSite(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);
+        const siteInfo = {
+            id: site.id,
+            name: site.name,
+            status: currentStatus,
+            domain: site.domain,
+            path: site.path,
+            url: `https://${site.domain}`,
+            adminUrl: `https://${site.domain}/wp-admin`,
+            environment: site.environment,
+            services: {
+                php: site.phpVersion || site.services?.php?.version,
+                webServer: site.webServer || site.services?.nginx?.version || site.services?.apache?.version,
+                database: site.mysql || site.services?.mysql?.version,
+            },
+            wordpress: {
+                version: site.wordPressVersion,
+                multisite: site.multisite || false,
+            },
+            hostConnections: site.hostConnections || [],
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(siteInfo, null, 2) }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to get site info: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+/**
+ * get_site_logs Tool
+ * Retrieve log files for a site
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const getSiteLogsDefinition: McpToolDefinition;
+export declare function getSiteLogs(args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;

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

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * get_site_logs Tool
+ * Retrieve log files for a site
+ */
+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.getSiteLogsDefinition = void 0;
+exports.getSiteLogs = getSiteLogs;
+const helpers_1 = require("./helpers");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+exports.getSiteLogsDefinition = {
+    name: 'get_site_logs',
+    description: 'Get log file contents for a site (PHP errors, access logs, etc.)',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID',
+            },
+            logType: {
+                type: 'string',
+                enum: ['php', 'nginx', 'mysql', 'all'],
+                description: 'Type of logs to retrieve (default: php)',
+            },
+            lines: {
+                type: 'number',
+                description: 'Number of lines to return from end of log (default: 100)',
+            },
+        },
+        required: ['site'],
+    },
+};
+function readLastLines(filePath, numLines) {
+    try {
+        if (!fs.existsSync(filePath)) {
+            return `[Log file not found: ${path.basename(filePath)}]`;
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const lastLines = lines.slice(-numLines).join('\n');
+        return lastLines || '[Log file is empty]';
+    }
+    catch (error) {
+        return `[Error reading log: ${error.message}]`;
+    }
+}
+function findLogFiles(logsDir, serviceType) {
+    const servicePath = path.join(logsDir, serviceType);
+    const logFiles = [];
+    try {
+        if (fs.existsSync(servicePath) && fs.statSync(servicePath).isDirectory()) {
+            const files = fs.readdirSync(servicePath);
+            for (const file of files) {
+                if (file.endsWith('.log')) {
+                    logFiles.push(path.join(servicePath, file));
+                }
+            }
+        }
+    }
+    catch {
+        // Directory doesn't exist or can't be read
+    }
+    return logFiles;
+}
+async function getSiteLogs(args, services) {
+    const { site: siteQuery, logType = 'php', lines = 100 } = 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 logs directory from site paths
+        const logsDir = site.paths?.logs || path.join(site.path, 'logs');
+        if (!fs.existsSync(logsDir)) {
+            return {
+                content: [{ type: 'text', text: `Logs directory not found: ${logsDir}` }],
+                isError: true,
+            };
+        }
+        const results = [];
+        const numLines = Math.min(Math.max(lines, 10), 1000); // Clamp between 10 and 1000
+        const serviceTypes = logType === 'all' ? ['php', 'nginx', 'mysql'] : [logType];
+        for (const serviceType of serviceTypes) {
+            const logFiles = findLogFiles(logsDir, serviceType);
+            if (logFiles.length === 0) {
+                results.push(`=== ${serviceType.toUpperCase()} ===\n[No log files found]`);
+                continue;
+            }
+            for (const logFile of logFiles) {
+                const fileName = path.basename(logFile);
+                const content = readLastLines(logFile, numLines);
+                results.push(`=== ${serviceType.toUpperCase()}: ${fileName} ===\n${content}`);
+            }
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Logs for "${site.name}" (last ${numLines} lines):\n\n${results.join('\n\n')}`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to get site logs: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"getSiteLogs.js","sourceRoot":"","sources":["../../../../src/main/mcp/tools/getSiteLogs.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * get_site_logs Tool\n * Retrieve log files for a site\n */\n\nimport { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';\nimport { validateRequiredParam, findSiteOrError } from './helpers';\nimport * as fs from 'fs';\nimport * as path from 'path';\n\nexport const getSiteLogsDefinition: McpToolDefinition = {\n  name: 'get_site_logs',\n  description: 'Get log file contents for a site (PHP errors, access logs, etc.)',\n  inputSchema: {\n    type: 'object',\n    properties: {\n      site: {\n        type: 'string',\n        description: 'Site name or ID',\n      },\n      logType: {\n        type: 'string',\n        enum: ['php', 'nginx', 'mysql', 'all'],\n        description: 'Type of logs to retrieve (default: php)',\n      },\n      lines: {\n        type: 'number',\n        description: 'Number of lines to return from end of log (default: 100)',\n      },\n    },\n    required: ['site'],\n  },\n};\n\ninterface GetSiteLogsArgs {\n  site: string;\n  logType?: 'php' | 'nginx' | 'mysql' | 'all';\n  lines?: number;\n}\n\nfunction readLastLines(filePath: string, numLines: number): string {\n  try {\n    if (!fs.existsSync(filePath)) {\n      return `[Log file not found: ${path.basename(filePath)}]`;\n    }\n\n    const content = fs.readFileSync(filePath, 'utf-8');\n    const lines = content.split('\\n');\n    const lastLines = lines.slice(-numLines).join('\\n');\n    return lastLines || '[Log file is empty]';\n  } catch (error: any) {\n    return `[Error reading log: ${error.message}]`;\n  }\n}\n\nfunction findLogFiles(logsDir: string, serviceType: string): string[] {\n  const servicePath = path.join(logsDir, serviceType);\n  const logFiles: string[] = [];\n\n  try {\n    if (fs.existsSync(servicePath) && fs.statSync(servicePath).isDirectory()) {\n      const files = fs.readdirSync(servicePath);\n      for (const file of files) {\n        if (file.endsWith('.log')) {\n          logFiles.push(path.join(servicePath, file));\n        }\n      }\n    }\n  } catch {\n    // Directory doesn't exist or can't be read\n  }\n\n  return logFiles;\n}\n\nexport async function getSiteLogs(\n  args: Record<string, unknown>,\n  services: LocalServices\n): Promise<McpToolResult> {\n  const { site: siteQuery, logType = 'php', lines = 100 } = args as unknown as GetSiteLogsArgs;\n\n  const paramError = validateRequiredParam(siteQuery, 'site');\n  if (paramError) return paramError;\n\n  const siteResult = findSiteOrError(siteQuery, services.siteData);\n  if ('error' in siteResult) return siteResult.error;\n  const { site } = siteResult;\n\n  try {\n    // Get logs directory from site paths\n    const logsDir = site.paths?.logs || path.join(site.path, 'logs');\n\n    if (!fs.existsSync(logsDir)) {\n      return {\n        content: [{ type: 'text', text: `Logs directory not found: ${logsDir}` }],\n        isError: true,\n      };\n    }\n\n    const results: string[] = [];\n    const numLines = Math.min(Math.max(lines, 10), 1000); // Clamp between 10 and 1000\n\n    const serviceTypes = logType === 'all' ? ['php', 'nginx', 'mysql'] : [logType];\n\n    for (const serviceType of serviceTypes) {\n      const logFiles = findLogFiles(logsDir, serviceType);\n\n      if (logFiles.length === 0) {\n        results.push(`=== ${serviceType.toUpperCase()} ===\\n[No log files found]`);\n        continue;\n      }\n\n      for (const logFile of logFiles) {\n        const fileName = path.basename(logFile);\n        const content = readLastLines(logFile, numLines);\n        results.push(`=== ${serviceType.toUpperCase()}: ${fileName} ===\\n${content}`);\n      }\n    }\n\n    return {\n      content: [\n        {\n          type: 'text',\n          text: `Logs for \"${site.name}\" (last ${numLines} lines):\\n\\n${results.join('\\n\\n')}`,\n        },\n      ],\n    };\n  } catch (error: any) {\n    return {\n      content: [{ type: 'text', text: `Failed to get site logs: ${error.message}` }],\n      isError: true,\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,59 @@
+/**
+ * Tool Helper Functions
+ */
+/**
+ * Blocked WP-CLI commands that could allow arbitrary code execution
+ */
+export declare const BLOCKED_WP_COMMANDS: string[];
+/**
+ * Check if a WP-CLI command is blocked for security reasons
+ * Returns the blocked command name if blocked, null if safe
+ */
+export declare function isBlockedWpCommand(command: string[]): string | null;
+/**
+ * Validate that a file path is safe (no path traversal)
+ * Returns true if the path is within allowed directories
+ */
+export declare function isValidFilePath(filePath: string, allowedDirs?: string[]): boolean;
+/**
+ * Validate that a SQL file path is safe
+ * Must end in .sql and be in an allowed directory
+ */
+export declare function isValidSqlPath(sqlPath: unknown): boolean;
+/**
+ * MCP Tool Result type for error responses
+ */
+export interface McpErrorResult {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError: true;
+}
+/**
+ * Create a standardized error result for MCP tools
+ */
+export declare function createErrorResult(message: string): McpErrorResult;
+/**
+ * Validate that a required parameter is present
+ * Returns an error result if missing, null if valid
+ */
+export declare function validateRequiredParam(value: unknown, paramName: string): McpErrorResult | null;
+/**
+ * Find a site by name or ID
+ * Supports partial name matching (case-insensitive)
+ */
+export declare function findSite(query: string, siteData: any): any | undefined;
+/**
+ * Get all site names as a comma-separated string
+ */
+export declare function getAllSiteNames(siteData: any): string;
+/**
+ * Find a site or return an error result
+ * Combines site lookup with standardized error handling
+ */
+export declare function findSiteOrError(query: string, siteData: any): {
+    site: any;
+} | {
+    error: McpErrorResult;
+};

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

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * Tool Helper Functions
+ */
+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.BLOCKED_WP_COMMANDS = void 0;
+exports.isBlockedWpCommand = isBlockedWpCommand;
+exports.isValidFilePath = isValidFilePath;
+exports.isValidSqlPath = isValidSqlPath;
+exports.createErrorResult = createErrorResult;
+exports.validateRequiredParam = validateRequiredParam;
+exports.findSite = findSite;
+exports.getAllSiteNames = getAllSiteNames;
+exports.findSiteOrError = findSiteOrError;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+/**
+ * Blocked WP-CLI commands that could allow arbitrary code execution
+ */
+exports.BLOCKED_WP_COMMANDS = [
+    'eval', // Execute arbitrary PHP code
+    'eval-file', // Execute PHP from file
+    'shell', // Interactive PHP shell
+    'db query', // Raw SQL execution
+    'db cli', // MySQL CLI access
+];
+/**
+ * Check if a WP-CLI command is blocked for security reasons
+ * Returns the blocked command name if blocked, null if safe
+ */
+function isBlockedWpCommand(command) {
+    const commandStr = command.join(' ').toLowerCase();
+    for (const blocked of exports.BLOCKED_WP_COMMANDS) {
+        if (commandStr.includes(blocked)) {
+            return blocked;
+        }
+    }
+    return null;
+}
+/**
+ * Validate that a file path is safe (no path traversal)
+ * Returns true if the path is within allowed directories
+ */
+function isValidFilePath(filePath, allowedDirs) {
+    // Resolve to absolute path
+    const resolvedPath = path.resolve(filePath);
+    // Default allowed directories: home, tmp, and common paths
+    const homeDir = os.homedir();
+    const defaultAllowed = [
+        homeDir,
+        os.tmpdir(),
+        '/tmp',
+        '/var/tmp',
+    ];
+    const allowedDirectories = allowedDirs || defaultAllowed;
+    // Check if path is within any allowed directory
+    for (const allowedDir of allowedDirectories) {
+        const resolvedAllowed = path.resolve(allowedDir);
+        if (resolvedPath.startsWith(resolvedAllowed + path.sep) || resolvedPath === resolvedAllowed) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Validate that a SQL file path is safe
+ * Must end in .sql and be in an allowed directory
+ */
+function isValidSqlPath(sqlPath) {
+    if (typeof sqlPath !== 'string' || !sqlPath) {
+        return false;
+    }
+    // Must end in .sql
+    if (!sqlPath.toLowerCase().endsWith('.sql')) {
+        return false;
+    }
+    // Must be in an allowed directory
+    return isValidFilePath(sqlPath);
+}
+/**
+ * Create a standardized error result for MCP tools
+ */
+function createErrorResult(message) {
+    return {
+        content: [{ type: 'text', text: message }],
+        isError: true,
+    };
+}
+/**
+ * Validate that a required parameter is present
+ * Returns an error result if missing, null if valid
+ */
+function validateRequiredParam(value, paramName) {
+    if (!value) {
+        return createErrorResult(`Error: ${paramName} parameter is required`);
+    }
+    return null;
+}
+/**
+ * Find a site by name or ID
+ * Supports partial name matching (case-insensitive)
+ */
+function findSite(query, siteData) {
+    const sitesMap = siteData.getSites();
+    const sites = Object.values(sitesMap);
+    // Try exact ID match first
+    const byId = sites.find((s) => s.id === query);
+    if (byId)
+        return byId;
+    // Try exact name match (case-insensitive)
+    const byExactName = sites.find((s) => s.name.toLowerCase() === query.toLowerCase());
+    if (byExactName)
+        return byExactName;
+    // Try partial name match (case-insensitive)
+    const byPartialName = sites.find((s) => s.name.toLowerCase().includes(query.toLowerCase()));
+    if (byPartialName)
+        return byPartialName;
+    // Try domain match
+    const byDomain = sites.find((s) => s.domain?.toLowerCase() === query.toLowerCase());
+    if (byDomain)
+        return byDomain;
+    return undefined;
+}
+/**
+ * Get all site names as a comma-separated string
+ */
+function getAllSiteNames(siteData) {
+    const sitesMap = siteData.getSites();
+    const sites = Object.values(sitesMap);
+    return sites.map((s) => s.name).join(', ') || 'none';
+}
+/**
+ * Find a site or return an error result
+ * Combines site lookup with standardized error handling
+ */
+function findSiteOrError(query, siteData) {
+    const site = findSite(query, siteData);
+    if (!site) {
+        const siteNames = getAllSiteNames(siteData);
+        return {
+            error: createErrorResult(`Site not found: "${query}". Available sites: ${siteNames}`),
+        };
+    }
+    return { site };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../../../src/main/mcp/tools/helpers.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Tool Helper Functions\n */\n\nimport * as path from 'path';\nimport * as os from 'os';\n\n/**\n * Blocked WP-CLI commands that could allow arbitrary code execution\n */\nexport const BLOCKED_WP_COMMANDS = [\n  'eval',        // Execute arbitrary PHP code\n  'eval-file',   // Execute PHP from file\n  'shell',       // Interactive PHP shell\n  'db query',    // Raw SQL execution\n  'db cli',      // MySQL CLI access\n];\n\n/**\n * Check if a WP-CLI command is blocked for security reasons\n * Returns the blocked command name if blocked, null if safe\n */\nexport function isBlockedWpCommand(command: string[]): string | null {\n  const commandStr = command.join(' ').toLowerCase();\n  for (const blocked of BLOCKED_WP_COMMANDS) {\n    if (commandStr.includes(blocked)) {\n      return blocked;\n    }\n  }\n  return null;\n}\n\n/**\n * Validate that a file path is safe (no path traversal)\n * Returns true if the path is within allowed directories\n */\nexport function isValidFilePath(filePath: string, allowedDirs?: string[]): boolean {\n  // Resolve to absolute path\n  const resolvedPath = path.resolve(filePath);\n\n  // Default allowed directories: home, tmp, and common paths\n  const homeDir = os.homedir();\n  const defaultAllowed = [\n    homeDir,\n    os.tmpdir(),\n    '/tmp',\n    '/var/tmp',\n  ];\n\n  const allowedDirectories = allowedDirs || defaultAllowed;\n\n  // Check if path is within any allowed directory\n  for (const allowedDir of allowedDirectories) {\n    const resolvedAllowed = path.resolve(allowedDir);\n    if (resolvedPath.startsWith(resolvedAllowed + path.sep) || resolvedPath === resolvedAllowed) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Validate that a SQL file path is safe\n * Must end in .sql and be in an allowed directory\n */\nexport function isValidSqlPath(sqlPath: unknown): boolean {\n  if (typeof sqlPath !== 'string' || !sqlPath) {\n    return false;\n  }\n\n  // Must end in .sql\n  if (!sqlPath.toLowerCase().endsWith('.sql')) {\n    return false;\n  }\n\n  // Must be in an allowed directory\n  return isValidFilePath(sqlPath);\n}\n\n/**\n * MCP Tool Result type for error responses\n */\nexport interface McpErrorResult {\n  content: Array<{ type: 'text'; text: string }>;\n  isError: true;\n}\n\n/**\n * Create a standardized error result for MCP tools\n */\nexport function createErrorResult(message: string): McpErrorResult {\n  return {\n    content: [{ type: 'text', text: message }],\n    isError: true,\n  };\n}\n\n/**\n * Validate that a required parameter is present\n * Returns an error result if missing, null if valid\n */\nexport function validateRequiredParam(\n  value: unknown,\n  paramName: string\n): McpErrorResult | null {\n  if (!value) {\n    return createErrorResult(`Error: ${paramName} parameter is required`);\n  }\n  return null;\n}\n\n/**\n * Find a site by name or ID\n * Supports partial name matching (case-insensitive)\n */\nexport function findSite(query: string, siteData: any): any | undefined {\n  const sitesMap = siteData.getSites();\n  const sites = Object.values(sitesMap) as any[];\n\n  // Try exact ID match first\n  const byId = sites.find((s: any) => s.id === query);\n  if (byId) return byId;\n\n  // Try exact name match (case-insensitive)\n  const byExactName = sites.find((s: any) => s.name.toLowerCase() === query.toLowerCase());\n  if (byExactName) return byExactName;\n\n  // Try partial name match (case-insensitive)\n  const byPartialName = sites.find((s: any) => s.name.toLowerCase().includes(query.toLowerCase()));\n  if (byPartialName) return byPartialName;\n\n  // Try domain match\n  const byDomain = sites.find((s: any) => s.domain?.toLowerCase() === query.toLowerCase());\n  if (byDomain) return byDomain;\n\n  return undefined;\n}\n\n/**\n * Get all site names as a comma-separated string\n */\nexport function getAllSiteNames(siteData: any): string {\n  const sitesMap = siteData.getSites();\n  const sites = Object.values(sitesMap) as any[];\n  return sites.map((s: any) => s.name).join(', ') || 'none';\n}\n\n/**\n * Find a site or return an error result\n * Combines site lookup with standardized error handling\n */\nexport function findSiteOrError(\n  query: string,\n  siteData: any\n): { site: any } | { error: McpErrorResult } {\n  const site = findSite(query, siteData);\n  if (!site) {\n    const siteNames = getAllSiteNames(siteData);\n    return {\n      error: createErrorResult(\n        `Site not found: \"${query}\". Available sites: ${siteNames}`\n      ),\n    };\n  }\n  return { site };\n}\n"]}

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

@@ -0,0 +1,7 @@
+/**
+ * import_database Tool
+ * Import SQL file into site database using WP-CLI
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const importDatabaseDefinition: McpToolDefinition;
+export declare function importDatabase(args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;