@local-labs-jpollock/local-cli 0.0.1

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

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * change_php_version Tool
+ * Change PHP version for a site
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changePhpVersionDefinition = void 0;
+exports.changePhpVersion = changePhpVersion;
+const helpers_1 = require("./helpers");
+exports.changePhpVersionDefinition = {
+    name: 'change_php_version',
+    description: 'Change the PHP version for a site',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID',
+            },
+            phpVersion: {
+                type: 'string',
+                description: 'Target PHP version (e.g., "8.2.10", "8.1.27", "7.4.33")',
+            },
+        },
+        required: ['site', 'phpVersion'],
+    },
+};
+async function changePhpVersion(args, services) {
+    const { site: siteQuery, phpVersion } = args;
+    const siteError = (0, helpers_1.validateRequiredParam)(siteQuery, 'site');
+    if (siteError)
+        return siteError;
+    const phpError = (0, helpers_1.validateRequiredParam)(phpVersion, 'phpVersion');
+    if (phpError)
+        return phpError;
+    const siteResult = (0, helpers_1.findSiteOrError)(siteQuery, services.siteData);
+    if ('error' in siteResult)
+        return siteResult.error;
+    const { site } = siteResult;
+    try {
+        // Check if siteProvisioner service exists
+        if (!services.siteProvisioner) {
+            return {
+                content: [{ type: 'text', text: 'Site provisioner service not available' }],
+                isError: true,
+            };
+        }
+        // Get current PHP version for messaging
+        const currentPhp = typeof site.phpVersion === 'object' ? site.phpVersion?.version : site.phpVersion;
+        // Change PHP version using siteProvisioner.swapService
+        // The service name is 'php' and role is 'php'
+        await services.siteProvisioner.swapService(site, 'php', 'php', phpVersion, true);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Successfully changed PHP version for "${site.name}" from ${currentPhp || 'unknown'} to ${phpVersion}. Site services have been restarted.`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        // Provide helpful error message for version not found
+        if (error.message?.includes('not found') || error.message?.includes('not available')) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `PHP version "${phpVersion}" not available. Use get_local_info to see available versions, or check Local preferences for installed PHP versions.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: 'text', text: `Failed to change PHP version: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+/**
+ * clone_site Tool
+ * Clone an existing WordPress site
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const cloneSiteDefinition: McpToolDefinition;
+export declare function cloneSite(args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;

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

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * clone_site Tool
+ * Clone an existing WordPress site
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneSiteDefinition = void 0;
+exports.cloneSite = cloneSite;
+const helpers_1 = require("./helpers");
+exports.cloneSiteDefinition = {
+    name: 'clone_site',
+    description: 'Clone an existing WordPress site to create a copy with a new name',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID to clone',
+            },
+            new_name: {
+                type: 'string',
+                description: 'Name for the cloned site',
+            },
+        },
+        required: ['site', 'new_name'],
+    },
+};
+async function cloneSite(args, services) {
+    const { site: siteQuery, new_name: newName } = args;
+    const siteError = (0, helpers_1.validateRequiredParam)(siteQuery, 'site');
+    if (siteError)
+        return siteError;
+    const nameError = (0, helpers_1.validateRequiredParam)(newName, 'new_name');
+    if (nameError)
+        return nameError;
+    const siteResult = (0, helpers_1.findSiteOrError)(siteQuery, services.siteData);
+    if ('error' in siteResult)
+        return siteResult.error;
+    const { site } = siteResult;
+    try {
+        // Check if cloneSite service exists
+        if (!services.cloneSite) {
+            return {
+                content: [{ type: 'text', text: 'Clone site service not available' }],
+                isError: true,
+            };
+        }
+        // Clone the site
+        const clonedSite = await services.cloneSite(site, newName);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Successfully cloned "${site.name}" to "${clonedSite.name}" (ID: ${clonedSite.id})`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to clone site: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * create_site Tool
+ * Create a new WordPress site
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSiteDefinition = void 0;
+exports.createSite = createSite;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+exports.createSiteDefinition = {
+    name: 'create_site',
+    description: 'Create a new WordPress site in Local',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            name: {
+                type: 'string',
+                description: 'Site name (required)',
+            },
+            domain: {
+                type: 'string',
+                description: 'Site domain (default: name.local)',
+            },
+            phpVersion: {
+                type: 'string',
+                description: 'PHP version (e.g., "8.2.10")',
+            },
+            webServer: {
+                type: 'string',
+                enum: ['nginx', 'apache'],
+                description: 'Web server type (default: nginx)',
+            },
+            database: {
+                type: 'string',
+                enum: ['mysql', 'mariadb'],
+                description: 'Database type (default: mysql)',
+            },
+            wpAdmin: {
+                type: 'object',
+                properties: {
+                    username: {
+                        type: 'string',
+                        description: 'WordPress admin username (default: admin)',
+                    },
+                    password: {
+                        type: 'string',
+                        description: 'WordPress admin password (default: password)',
+                    },
+                    email: {
+                        type: 'string',
+                        description: 'WordPress admin email (default: admin@local.test)',
+                    },
+                },
+                description: 'WordPress admin credentials',
+            },
+        },
+        required: ['name'],
+    },
+};
+async function createSite(args, services) {
+    const { name, domain, phpVersion, webServer = 'nginx', database = 'mysql', wpAdmin = {}, } = args;
+    if (!name) {
+        return {
+            content: [{ type: 'text', text: 'Error: name parameter is required' }],
+            isError: true,
+        };
+    }
+    // Check if site with this name already exists
+    const sitesMap = services.siteData.getSites();
+    const existingSites = Object.values(sitesMap);
+    const existingSite = existingSites.find((s) => s.name.toLowerCase() === name.toLowerCase());
+    if (existingSite) {
+        return {
+            content: [{ type: 'text', text: `Error: A site named "${name}" already exists` }],
+            isError: true,
+        };
+    }
+    try {
+        // Build site slug (used for domain and path)
+        const siteSlug = name
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-|-$/g, '');
+        // Build site domain
+        const siteDomain = domain || `${siteSlug}.local`;
+        // Build site path - Local stores sites in ~/Local Sites/<site-slug>
+        const sitePath = path_1.default.join(os_1.default.homedir(), 'Local Sites', siteSlug);
+        // Build the site creation options
+        const newSiteInfo = {
+            siteName: name,
+            siteDomain: siteDomain,
+            sitePath: sitePath,
+            webServer: webServer,
+            database: database,
+        };
+        // Add PHP version if specified
+        if (phpVersion) {
+            newSiteInfo.phpVersion = phpVersion;
+        }
+        // Create the site using addSite service
+        const newSite = await services.addSite.addSite({
+            newSiteInfo,
+            wpCredentials: {
+                adminUsername: wpAdmin.username || 'admin',
+                adminPassword: wpAdmin.password || 'password',
+                adminEmail: wpAdmin.email || 'admin@local.test',
+            },
+            goToSite: false,
+        });
+        const result = {
+            success: true,
+            site: {
+                id: newSite.id,
+                name: newSite.name,
+                domain: newSite.domain,
+                path: newSite.path,
+                url: `https://${newSite.domain}`,
+                adminUrl: `https://${newSite.domain}/wp-admin`,
+            },
+            message: `Site "${name}" created successfully`,
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to create site: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"createSite.js","sourceRoot":"","sources":["../../../../src/main/mcp/tools/createSite.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * create_site Tool\n * Create a new WordPress site\n */\n\nimport os from 'os';\nimport path from 'path';\nimport { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';\n\nexport const createSiteDefinition: McpToolDefinition = {\n  name: 'create_site',\n  description: 'Create a new WordPress site in Local',\n  inputSchema: {\n    type: 'object',\n    properties: {\n      name: {\n        type: 'string',\n        description: 'Site name (required)',\n      },\n      domain: {\n        type: 'string',\n        description: 'Site domain (default: name.local)',\n      },\n      phpVersion: {\n        type: 'string',\n        description: 'PHP version (e.g., \"8.2.10\")',\n      },\n      webServer: {\n        type: 'string',\n        enum: ['nginx', 'apache'],\n        description: 'Web server type (default: nginx)',\n      },\n      database: {\n        type: 'string',\n        enum: ['mysql', 'mariadb'],\n        description: 'Database type (default: mysql)',\n      },\n      wpAdmin: {\n        type: 'object',\n        properties: {\n          username: {\n            type: 'string',\n            description: 'WordPress admin username (default: admin)',\n          },\n          password: {\n            type: 'string',\n            description: 'WordPress admin password (default: password)',\n          },\n          email: {\n            type: 'string',\n            description: 'WordPress admin email (default: admin@local.test)',\n          },\n        },\n        description: 'WordPress admin credentials',\n      },\n    },\n    required: ['name'],\n  },\n};\n\ninterface CreateSiteArgs {\n  name: string;\n  domain?: string;\n  phpVersion?: string;\n  webServer?: 'nginx' | 'apache';\n  database?: 'mysql' | 'mariadb';\n  wpAdmin?: {\n    username?: string;\n    password?: string;\n    email?: string;\n  };\n}\n\nexport async function createSite(\n  args: Record<string, unknown>,\n  services: LocalServices\n): Promise<McpToolResult> {\n  const {\n    name,\n    domain,\n    phpVersion,\n    webServer = 'nginx',\n    database = 'mysql',\n    wpAdmin = {},\n  } = args as unknown as CreateSiteArgs;\n\n  if (!name) {\n    return {\n      content: [{ type: 'text', text: 'Error: name parameter is required' }],\n      isError: true,\n    };\n  }\n\n  // Check if site with this name already exists\n  const sitesMap = services.siteData.getSites();\n  const existingSites = Object.values(sitesMap) as any[];\n  const existingSite = existingSites.find((s: any) => s.name.toLowerCase() === name.toLowerCase());\n  if (existingSite) {\n    return {\n      content: [{ type: 'text', text: `Error: A site named \"${name}\" already exists` }],\n      isError: true,\n    };\n  }\n\n  try {\n    // Build site slug (used for domain and path)\n    const siteSlug = name\n      .toLowerCase()\n      .replace(/[^a-z0-9]+/g, '-')\n      .replace(/^-|-$/g, '');\n\n    // Build site domain\n    const siteDomain = domain || `${siteSlug}.local`;\n\n    // Build site path - Local stores sites in ~/Local Sites/<site-slug>\n    const sitePath = path.join(os.homedir(), 'Local Sites', siteSlug);\n\n    // Build the site creation options\n    const newSiteInfo: any = {\n      siteName: name,\n      siteDomain: siteDomain,\n      sitePath: sitePath,\n      webServer: webServer,\n      database: database,\n    };\n\n    // Add PHP version if specified\n    if (phpVersion) {\n      newSiteInfo.phpVersion = phpVersion;\n    }\n\n    // Create the site using addSite service\n    const newSite = await services.addSite.addSite({\n      newSiteInfo,\n      wpCredentials: {\n        adminUsername: wpAdmin.username || 'admin',\n        adminPassword: wpAdmin.password || 'password',\n        adminEmail: wpAdmin.email || 'admin@local.test',\n      },\n      goToSite: false,\n    });\n\n    const result = {\n      success: true,\n      site: {\n        id: newSite.id,\n        name: newSite.name,\n        domain: newSite.domain,\n        path: newSite.path,\n        url: `https://${newSite.domain}`,\n        adminUrl: `https://${newSite.domain}/wp-admin`,\n      },\n      message: `Site \"${name}\" created successfully`,\n    };\n\n    return {\n      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],\n    };\n  } catch (error: any) {\n    return {\n      content: [{ type: 'text', text: `Failed to create site: ${error.message}` }],\n      isError: true,\n    };\n  }\n}\n"]}

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

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

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

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * delete_site Tool
+ * Delete a WordPress site (requires confirmation)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteSiteDefinition = void 0;
+exports.deleteSite = deleteSite;
+const helpers_1 = require("./helpers");
+exports.deleteSiteDefinition = {
+    name: 'delete_site',
+    description: 'Delete a WordPress site. Requires confirm=true to prevent accidental deletion.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID (partial names work)',
+            },
+            confirm: {
+                type: 'boolean',
+                description: 'Must be true to confirm deletion. This is a safety measure.',
+            },
+            trashFiles: {
+                type: 'boolean',
+                description: 'Move site files to trash instead of permanent deletion (default: true)',
+            },
+        },
+        required: ['site', 'confirm'],
+    },
+};
+async function deleteSite(args, services) {
+    const { site: siteQuery, confirm, trashFiles = true } = args;
+    const paramError = (0, helpers_1.validateRequiredParam)(siteQuery, 'site');
+    if (paramError)
+        return paramError;
+    if (confirm !== true) {
+        return (0, helpers_1.createErrorResult)('Error: Deletion not confirmed. You must set confirm=true to delete a site. This is a safety measure to prevent accidental deletion.');
+    }
+    const siteResult = (0, helpers_1.findSiteOrError)(siteQuery, services.siteData);
+    if ('error' in siteResult)
+        return siteResult.error;
+    const { site } = siteResult;
+    try {
+        // Stop the site if it's running
+        const currentStatus = await services.siteProcessManager.getSiteStatus(site);
+        if (currentStatus === 'running') {
+            await services.siteProcessManager.stop(site);
+        }
+        // Delete the site
+        await services.deleteSite.deleteSite({
+            site,
+            trashFiles,
+            updateHosts: true,
+        });
+        const result = {
+            success: true,
+            message: `Site "${site.name}" deleted successfully`,
+            trashFiles,
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to delete site: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * export_database Tool
+ * Export site database to SQL file using WP-CLI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportDatabaseDefinition = void 0;
+exports.exportDatabase = exportDatabase;
+const helpers_1 = require("./helpers");
+exports.exportDatabaseDefinition = {
+    name: 'export_database',
+    description: 'Export a site database to a SQL file',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID',
+            },
+            outputPath: {
+                type: 'string',
+                description: 'Output file path (optional, defaults to ~/Downloads/<site-name>.sql)',
+            },
+        },
+        required: ['site'],
+    },
+};
+async function exportDatabase(args, services) {
+    const { site: siteQuery, outputPath } = args;
+    // Validate required parameter
+    const siteError = (0, helpers_1.validateRequiredParam)(siteQuery, 'site');
+    if (siteError)
+        return siteError;
+    // 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 {
+        // Determine output path
+        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        const defaultPath = `${homeDir}/Downloads/${site.name.replace(/[^a-zA-Z0-9-_]/g, '-')}.sql`;
+        const finalPath = outputPath || defaultPath;
+        // Security: Validate output path is safe (no path traversal attacks)
+        if (!(0, helpers_1.isValidFilePath)(finalPath)) {
+            return (0, helpers_1.createErrorResult)('Error: Invalid output path. Path must be within allowed directories (home, tmp).');
+        }
+        // Run WP-CLI db export
+        const result = await services.wpCli.run(site, ['db', 'export', finalPath]);
+        if (result === null) {
+            return {
+                content: [{ type: 'text', text: `Failed to export database for "${site.name}"` }],
+                isError: true,
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Successfully exported database for "${site.name}" to: ${finalPath}`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to export database: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * export_site Tool
+ * Export a WordPress site to 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.exportSiteDefinition = void 0;
+exports.exportSite = exportSite;
+const helpers_1 = require("./helpers");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+exports.exportSiteDefinition = {
+    name: 'export_site',
+    description: 'Export a WordPress site to a zip file',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            site: {
+                type: 'string',
+                description: 'Site name or ID to export',
+            },
+            output_path: {
+                type: 'string',
+                description: 'Output directory path (default: ~/Downloads)',
+            },
+        },
+        required: ['site'],
+    },
+};
+async function exportSite(args, services) {
+    const { site: siteQuery, output_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 {
+        // Check if exportSite service exists
+        if (!services.exportSite) {
+            return {
+                content: [{ type: 'text', text: 'Export site service not available' }],
+                isError: true,
+            };
+        }
+        // Default output path to Downloads folder
+        const outputDir = output_path || path.join(os.homedir(), 'Downloads');
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        const filename = `${site.name}-${timestamp}.zip`;
+        const outputPath = path.join(outputDir, filename);
+        // Export the site
+        await services.exportSite(site, outputPath);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Successfully exported "${site.name}" to ${outputPath}`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to export site: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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