langmart-gateway-type3 3.0.41 → 3.0.43

package/dist/automation-tools.js

@@ -4,11 +4,12 @@
  *
  * Provides MCP tools for remote server management and script execution.
  * These tools interact with the Gateway Type 1 API to:
- * - List available remote servers
- * - Test server connectivity
- * - List available scripts
+ * - Manage remote servers (add, list, test)
+ * - Manage automation sessions
+ * - Manage automation templates
+ * - List SSH keys
  * - Execute scripts on remote servers
- * - View script execution logs
+ * - View execution logs
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -25,7 +26,6 @@ const crypto_1 = require("crypto");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 /**
  * Extract error message from axios error response
- * Gateway Type 1 returns errors as: { error: { code, type, message } }
  */
 function getErrorMessage(error) {
     const apiError = error.response?.data?.error;
@@ -36,14 +36,14 @@ function getErrorMessage(error) {
     return error.message || 'Unknown error';
 }
 class AutomationTools {
-    constructor(marketplaceUrl, apiKey) {
+    constructor(registryUrl, apiKey) {
         this.sessionId = null;
         this.serverMap = new Map(); // sequence number → UUID
-        this.scriptMap = new Map(); // sequence number → slug
-        this.marketplaceUrl = marketplaceUrl;
+        this.scriptMap = new Map();
+        this.registryUrl = registryUrl;
         this.apiKey = apiKey;
         this.client = axios_1.default.create({
-            baseURL: marketplaceUrl,
+            baseURL: registryUrl,
             timeout: 60000,
             headers: {
                 'Authorization': `Bearer ${apiKey}`,
@@ -51,43 +51,55 @@ class AutomationTools {
             }
         });
     }
-    static getInstance(marketplaceUrl, apiKey) {
-        if (!AutomationTools.instance && marketplaceUrl && apiKey) {
-            AutomationTools.instance = new AutomationTools(marketplaceUrl, apiKey);
+    static getInstance(registryUrl, apiKey) {
+        if (!AutomationTools.instance && registryUrl && apiKey) {
+            AutomationTools.instance = new AutomationTools(registryUrl, apiKey);
         }
         if (!AutomationTools.instance) {
-            throw new Error('AutomationTools not initialized. Provide marketplaceUrl and apiKey.');
+            throw new Error('AutomationTools not initialized. Provide registryUrl and apiKey.');
         }
         return AutomationTools.instance;
     }
     setSessionId(sessionId) {
         this.sessionId = sessionId;
     }
-    /**
-     * Get tool definitions for AI
-     */
     getTools() {
         return [
-            // Server management tools
+            // ===== SERVERS =====
             {
                 type: 'function',
                 function: {
                     name: 'automation_servers_list',
-                    description: 'List all remote servers configured for deployments. Shows server names, hostnames, status, and connection info WITHOUT exposing credentials. Servers are numbered [1], [2], [3], etc. Use these numbers in subsequent tool calls.',
+                    description: 'List remote servers. Servers are numbered [1], [2] for reference.',
                     parameters: {
                         type: 'object',
                         properties: {
-                            status: {
-                                type: 'string',
-                                enum: ['active', 'inactive', 'failed', 'all'],
-                                description: 'Filter by status (default: all)'
-                            },
-                            tags: {
-                                type: 'string',
-                                description: 'Comma-separated tags to filter by'
-                            }
+                            status: { type: 'string', enum: ['active', 'inactive', 'failed', 'all'] },
+                            tags: { type: 'string' }
+                        }
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'automation_servers_add',
+                    description: 'Add a new remote server for automation.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Friendly name' },
+                            hostname: { type: 'string', description: 'IP or Hostname' },
+                            port: { type: 'number', default: 22 },
+                            username: { type: 'string' },
+                            auth_type: { type: 'string', enum: ['password', 'ssh_key', 'ssh_key_passphrase'] },
+                            password: { type: 'string', description: 'Required if auth_type is password' },
+                            ssh_key: { type: 'string', description: 'Required if auth_type is ssh_key' },
+                            passphrase: { type: 'string', description: 'Optional passphrase for SSH key' },
+                            description: { type: 'string' },
+                            tags: { type: 'array', items: { type: 'string' } }
                         },
-                        required: []
+                        required: ['name', 'hostname', 'username', 'auth_type']
                     }
                 }
             },
@@ -95,14 +107,11 @@ class AutomationTools {
                 type: 'function',
                 function: {
                     name: 'automation_servers_test_connection',
-                    description: 'Test SSH connectivity to a remote server. Returns success/failure with diagnostics and latency.',
+                    description: 'Test SSH connection to a server.',
                     parameters: {
                         type: 'object',
                         properties: {
-                            server_id: {
-                                type: 'string',
-                                description: 'Server ID or sequence number (e.g., "1" for the first server from automation_servers_list)'
-                            }
+                            server_id: { type: 'string', description: 'ID or sequence number' }
                         },
                         required: ['server_id']
                     }
@@ -112,35 +121,27 @@ class AutomationTools {
                 type: 'function',
                 function: {
                     name: 'automation_servers_get_info',
-                    description: 'Get detailed information about a specific server (without credentials).',
+                    description: 'Get server details.',
                     parameters: {
                         type: 'object',
                         properties: {
-                            server_id: {
-                                type: 'string',
-                                description: 'Server ID or sequence number'
-                            }
+                            server_id: { type: 'string', description: 'ID or sequence number' }
                         },
                         required: ['server_id']
                     }
                 }
             },
-            // Script management tools
+            // ===== SCRIPTS =====
             {
                 type: 'function',
                 function: {
                     name: 'automation_scripts_list',
-                    description: 'List all available automation scripts. Scripts are numbered [1], [2], etc. Use script slugs or numbers in execute commands. Shows name, description, category, and required parameters.',
+                    description: 'List automation scripts.',
                     parameters: {
                         type: 'object',
                         properties: {
-                            category: {
-                                type: 'string',
-                                enum: ['deployment', 'monitoring', 'maintenance', 'custom', 'all'],
-                                description: 'Filter by category (default: all)'
-                            }
-                        },
-                        required: []
+                            category: { type: 'string', enum: ['deployment', 'monitoring', 'maintenance', 'custom', 'all'] }
+                        }
                     }
                 }
             },
@@ -148,14 +149,11 @@ class AutomationTools {
                 type: 'function',
                 function: {
                     name: 'automation_scripts_get_info',
-                    description: 'Get detailed information about a script including its full content and parameter definitions.',
+                    description: 'Get script details and content.',
                     parameters: {
                         type: 'object',
                         properties: {
-                            script: {
-                                type: 'string',
-                                description: 'Script slug (e.g., "deploy-type3-gateway") or sequence number from automation_scripts_list'
-                            }
+                            script: { type: 'string', description: 'Slug or sequence number' }
                         },
                         required: ['script']
                     }
@@ -165,22 +163,13 @@ class AutomationTools {
                 type: 'function',
                 function: {
                     name: 'automation_scripts_execute',
-                    description: 'Execute a script on a remote server. The script is retrieved from the database and executed via SSH. Parameters are passed as environment variables. Returns execution output and status.',
+                    description: 'Execute a script on a remote server.',
                     parameters: {
                         type: 'object',
                         properties: {
-                            script: {
-                                type: 'string',
-                                description: 'Script slug (e.g., "deploy-type3-gateway") or sequence number'
-                            },
-                            server_id: {
-                                type: 'string',
-                                description: 'Target server ID or sequence number from automation_servers_list'
-                            },
-                            parameters: {
-                                type: 'object',
-                                description: 'Script parameters as key-value pairs (e.g., {"GATEWAY_NAME": "my-gateway", "GATEWAY_PORT": 8083})'
-                            }
+                            script: { type: 'string', description: 'Slug or sequence number' },
+                            server_id: { type: 'string', description: 'Target server ID/number' },
+                            parameters: { type: 'object', description: 'Key-value parameters for script' }
                         },
                         required: ['script', 'server_id']
                     }
@@ -190,32 +179,122 @@ class AutomationTools {
                 type: 'function',
                 function: {
                     name: 'automation_scripts_get_execution_logs',
-                    description: 'Get execution history and logs for a script or server. Shows recent executions with status, output, and timing.',
+                    description: 'Get execution history.',
                     parameters: {
                         type: 'object',
                         properties: {
-                            script: {
-                                type: 'string',
-                                description: 'Script slug or ID to filter by (optional)'
-                            },
-                            server_id: {
-                                type: 'string',
-                                description: 'Server ID to filter by (optional)'
-                            },
-                            limit: {
-                                type: 'number',
-                                description: 'Number of recent executions to show (default: 10)'
-                            }
+                            script: { type: 'string' },
+                            server_id: { type: 'string' },
+                            limit: { type: 'number', default: 10 },
+                            offset: { type: 'number', default: 0 }
+                        }
+                    }
+                }
+            },
+            // ===== SESSIONS =====
+            {
+                type: 'function',
+                function: {
+                    name: 'automation_sessions_list',
+                    description: 'List active automation sessions.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            status: { type: 'string' },
+                            limit: { type: 'number', default: 50 },
+                            offset: { type: 'number', default: 0 }
+                        }
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'automation_sessions_create',
+                    description: 'Create a new automation session.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            type: { type: 'string', enum: ['interactive', 'script'], default: 'script' },
+                            server_id: { type: 'string', description: 'Optional target server' },
+                            target_type: { type: 'string', enum: ['local', 'remote'], default: 'remote' }
+                        }
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'automation_sessions_get',
+                    description: 'Get session details.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            session_id: { type: 'string' }
+                        },
+                        required: ['session_id']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'automation_sessions_delete',
+                    description: 'Terminate/Delete a session.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            session_id: { type: 'string' }
+                        },
+                        required: ['session_id']
+                    }
+                }
+            },
+            // ===== TEMPLATES & KEYS =====
+            {
+                type: 'function',
+                function: {
+                    name: 'automation_templates_list',
+                    description: 'List automation templates.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            category: { type: 'string' }
+                        }
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'automation_templates_create',
+                    description: 'Create a new automation template.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string' },
+                            description: { type: 'string' },
+                            content: { type: 'string', description: 'Template content (e.g. YAML/JSON)' },
+                            category: { type: 'string' }
                         },
+                        required: ['name', 'content', 'category']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'automation_ssh_keys_list',
+                    description: 'List stored SSH keys.',
+                    parameters: {
+                        type: 'object',
+                        properties: {},
                         required: []
                     }
                 }
             }
         ];
     }
-    /**
-     * Resolve server ID (handle sequence numbers like "1", "2", etc.)
-     */
     resolveServerId(serverIdOrNumber) {
         const num = parseInt(serverIdOrNumber);
         if (!isNaN(num) && this.serverMap.has(num)) {
@@ -223,9 +302,6 @@ class AutomationTools {
         }
         return serverIdOrNumber;
     }
-    /**
-     * Resolve script slug (handle sequence numbers like "1", "2", etc.)
-     */
     resolveScriptSlug(scriptOrNumber) {
         const num = parseInt(scriptOrNumber);
         if (!isNaN(num) && this.scriptMap.has(num)) {
@@ -233,18 +309,19 @@ class AutomationTools {
         }
         return scriptOrNumber;
     }
-    /**
-     * Execute an automation tool
-     */
     async executeTool(toolName, args) {
         try {
             switch (toolName) {
+                // Servers
                 case 'automation_servers_list':
                     return await this.listServers(args);
+                case 'automation_servers_add':
+                    return await this.addServer(args);
                 case 'automation_servers_test_connection':
                     return await this.testServerConnection(args);
                 case 'automation_servers_get_info':
                     return await this.getServerInfo(args);
+                // Scripts
                 case 'automation_scripts_list':
                     return await this.listScripts(args);
                 case 'automation_scripts_get_info':
@@ -253,6 +330,22 @@ class AutomationTools {
                     return await this.executeScript(args);
                 case 'automation_scripts_get_execution_logs':
                     return await this.getExecutionLogs(args);
+                // Sessions
+                case 'automation_sessions_list':
+                    return await this.listSessions(args);
+                case 'automation_sessions_create':
+                    return await this.createSession(args);
+                case 'automation_sessions_get':
+                    return await this.getSession(args);
+                case 'automation_sessions_delete':
+                    return await this.deleteSession(args);
+                // Templates & Keys
+                case 'automation_templates_list':
+                    return await this.listTemplates(args);
+                case 'automation_templates_create':
+                    return await this.createTemplate(args);
+                case 'automation_ssh_keys_list':
+                    return await this.listSSHKeys();
                 default:
                     return { success: false, error: `Unknown tool: ${toolName}` };
             }
@@ -262,461 +355,219 @@ class AutomationTools {
             return { success: false, error: error.message };
         }
     }
-    // ============= SERVER TOOLS =============
-    /**
-     * List remote servers
-     */
+    // ============= SERVER IMPLEMENTATIONS =============
     async listServers(args) {
-        try {
-            const params = new URLSearchParams();
-            if (args.status && args.status !== 'all')
-                params.append('status', args.status);
-            if (args.tags)
-                params.append('tags', args.tags);
-            const query = params.toString() ? `?${params.toString()}` : '';
-            const response = await this.client.get(`/api/automation/servers${query}`);
-            if (!response.data.success) {
-                return { success: false, error: response.data.error || 'Failed to list servers' };
-            }
-            const servers = response.data.servers;
-            // Update server map
-            this.serverMap.clear();
-            servers.forEach((server, index) => {
-                this.serverMap.set(index + 1, server.id);
-            });
-            if (servers.length === 0) {
-                return {
-                    success: true,
-                    output: 'No remote servers found. Use the Remote Servers page in the web UI to add deployment targets.'
-                };
-            }
-            // Format output
-            let output = `Found ${servers.length} remote server(s):\n\n`;
-            servers.forEach((server, index) => {
-                const statusIcon = server.status === 'active' ? '✅' :
-                    server.status === 'testing' ? '🔄' :
-                        server.status === 'failed' ? '❌' : '⚪';
-                output += `[${index + 1}] ${statusIcon} ${server.name}\n`;
-                output += `    Host: ${server.username}@${server.hostname}:${server.port}\n`;
-                output += `    Auth: ${server.auth_type}\n`;
-                output += `    Status: ${server.status}`;
-                if (server.last_connection_status) {
-                    output += ` (last test: ${server.last_connection_status})`;
-                }
-                output += '\n';
-                if (server.description) {
-                    output += `    Description: ${server.description}\n`;
-                }
-                if (server.tags && server.tags.length > 0) {
-                    output += `    Tags: ${server.tags.join(', ')}\n`;
-                }
-                output += '\n';
-            });
-            output += 'Use server numbers (e.g., 1, 2) in subsequent commands.';
-            return { success: true, output };
-        }
-        catch (error) {
-            return { success: false, error: getErrorMessage(error) };
-        }
+        const params = new URLSearchParams();
+        if (args.status && args.status !== 'all')
+            params.append('status', args.status);
+        if (args.tags)
+            params.append('tags', args.tags);
+        const response = await this.client.get(`/api/automation/servers?${params.toString()}`);
+        const servers = response.data.servers || response.data;
+        this.serverMap.clear();
+        servers.forEach((s, i) => this.serverMap.set(i + 1, s.id));
+        if (!servers.length)
+            return { success: true, output: 'No servers found.' };
+        const lines = servers.map((s, i) => `[${i + 1}] ${s.name} (${s.hostname}) - ${s.status} [${s.auth_type}]`);
+        return { success: true, output: lines.join('\n') };
+    }
+    async addServer(args) {
+        const response = await this.client.post('/api/automation/servers', args);
+        return { success: true, output: `✅ Server '${args.name}' added (ID: ${response.data.server?.id || response.data.id})` };
     }
-    /**
-     * Test server connection
-     */
     async testServerConnection(args) {
-        try {
-            const serverId = this.resolveServerId(args.server_id);
-            const response = await this.client.post(`/api/automation/servers/${serverId}/test`);
-            if (response.data.success) {
-                return {
-                    success: true,
-                    output: `✅ Connection successful!\n\nMessage: ${response.data.message}\nLatency: ${response.data.latency_ms}ms`
-                };
-            }
-            else {
-                return {
-                    success: false,
-                    error: `Connection failed: ${response.data.message}`
-                };
-            }
-        }
-        catch (error) {
-            return { success: false, error: getErrorMessage(error) };
-        }
+        const id = this.resolveServerId(args.server_id);
+        const response = await this.client.post(`/api/automation/servers/${id}/test`);
+        return {
+            success: response.data.success,
+            output: response.data.success
+                ? `✅ Connected. Latency: ${response.data.latency_ms}ms`
+                : `❌ Failed: ${response.data.message}`
+        };
     }
-    /**
-     * Get server info
-     */
     async getServerInfo(args) {
-        try {
-            const serverId = this.resolveServerId(args.server_id);
-            const response = await this.client.get(`/api/automation/servers/${serverId}`);
-            if (!response.data.success) {
-                return { success: false, error: response.data.error || 'Server not found' };
-            }
-            const server = response.data.server;
-            let output = `Server: ${server.name}\n`;
-            output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
-            output += `ID: ${server.id}\n`;
-            output += `Hostname: ${server.hostname}\n`;
-            output += `Port: ${server.port}\n`;
-            output += `Username: ${server.username}\n`;
-            output += `Auth Type: ${server.auth_type}\n`;
-            output += `Status: ${server.status}\n`;
-            if (server.description) {
-                output += `Description: ${server.description}\n`;
-            }
-            if (server.tags && server.tags.length > 0) {
-                output += `Tags: ${server.tags.join(', ')}\n`;
-            }
-            if (server.last_connection_test) {
-                output += `Last Test: ${new Date(server.last_connection_test).toLocaleString()}\n`;
-                output += `Test Result: ${server.last_connection_status}\n`;
-            }
-            return { success: true, output };
-        }
-        catch (error) {
-            return { success: false, error: getErrorMessage(error) };
-        }
+        const id = this.resolveServerId(args.server_id);
+        const response = await this.client.get(`/api/automation/servers/${id}`);
+        const s = response.data.server || response.data;
+        return {
+            success: true,
+            output: `**${s.name}**\nHost: ${s.hostname}:${s.port}\nUser: ${s.username}\nStatus: ${s.status}`
+        };
     }
-    // ============= SCRIPT TOOLS =============
-    /**
-     * List available scripts
-     */
+    // ============= SCRIPT IMPLEMENTATIONS =============
     async listScripts(args) {
-        try {
-            const params = new URLSearchParams();
-            if (args.category && args.category !== 'all')
-                params.append('category', args.category);
-            const query = params.toString() ? `?${params.toString()}` : '';
-            const response = await this.client.get(`/api/automation/scripts${query}`);
-            if (!response.data.success) {
-                return { success: false, error: response.data.error || 'Failed to list scripts' };
-            }
-            const scripts = response.data.scripts;
-            // Update script map
-            this.scriptMap.clear();
-            scripts.forEach((script, index) => {
-                this.scriptMap.set(index + 1, script.slug);
-            });
-            if (scripts.length === 0) {
-                return {
-                    success: true,
-                    output: 'No scripts found. Use the Scripts page in the web UI to create automation scripts.'
-                };
-            }
-            // Format output
-            let output = `Found ${scripts.length} script(s):\n\n`;
-            // Group by category
-            const categories = new Map();
-            scripts.forEach(script => {
-                if (!categories.has(script.category)) {
-                    categories.set(script.category, []);
-                }
-                categories.get(script.category).push(script);
-            });
-            let globalIndex = 0;
-            for (const [category, categoryScripts] of categories) {
-                output += `📁 ${category.toUpperCase()}\n`;
-                for (const script of categoryScripts) {
-                    globalIndex++;
-                    const systemBadge = script.is_system ? ' [system]' : '';
-                    output += `  [${globalIndex}] ${script.name}${systemBadge}\n`;
-                    output += `      Slug: ${script.slug}\n`;
-                    output += `      ${script.description}\n`;
-                    if (script.parameters && script.parameters.length > 0) {
-                        const required = script.parameters.filter(p => p.required).map(p => p.name);
-                        const optional = script.parameters.filter(p => !p.required).map(p => p.name);
-                        if (required.length > 0) {
-                            output += `      Required params: ${required.join(', ')}\n`;
-                        }
-                        if (optional.length > 0) {
-                            output += `      Optional params: ${optional.join(', ')}\n`;
-                        }
-                    }
-                    output += '\n';
-                }
-            }
-            output += 'Use automation_scripts_get_info to see full script details.\n';
-            output += 'Use automation_scripts_execute to run a script on a server.';
-            return { success: true, output };
-        }
-        catch (error) {
-            return { success: false, error: getErrorMessage(error) };
-        }
+        const params = new URLSearchParams();
+        if (args.category && args.category !== 'all')
+            params.append('category', args.category);
+        const response = await this.client.get(`/api/automation/scripts?${params.toString()}`);
+        const scripts = response.data.scripts || response.data;
+        this.scriptMap.clear();
+        scripts.forEach((s, i) => this.scriptMap.set(i + 1, s.slug));
+        if (!scripts.length)
+            return { success: true, output: 'No scripts found.' };
+        const lines = scripts.map((s, i) => `[${i + 1}] ${s.name} (${s.slug}) - ${s.category}`);
+        return { success: true, output: lines.join('\n') };
     }
-    /**
-     * Get script info
-     */
     async getScriptInfo(args) {
-        try {
-            const scriptSlug = this.resolveScriptSlug(args.script);
-            const response = await this.client.get(`/api/automation/scripts/${scriptSlug}`);
-            if (!response.data.success) {
-                return { success: false, error: response.data.error || 'Script not found' };
-            }
-            const script = response.data.script;
-            let output = `Script: ${script.name}\n`;
-            output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
-            output += `Slug: ${script.slug}\n`;
-            output += `Category: ${script.category}\n`;
-            output += `Description: ${script.description}\n`;
-            output += `Timeout: ${script.timeout_seconds} seconds\n`;
-            if (script.tags && script.tags.length > 0) {
-                output += `Tags: ${script.tags.join(', ')}\n`;
-            }
-            output += `System Script: ${script.is_system ? 'Yes' : 'No'}\n`;
-            output += '\n';
-            // Parameters
-            if (script.parameters && script.parameters.length > 0) {
-                output += `Parameters:\n`;
-                for (const param of script.parameters) {
-                    const required = param.required ? '*' : '';
-                    const defaultVal = param.default !== undefined ? ` (default: ${param.default})` : '';
-                    const sensitive = param.sensitive ? ' [SENSITIVE]' : '';
-                    output += `  ${param.name}${required}: ${param.type}${defaultVal}${sensitive}\n`;
-                    output += `    ${param.description}\n`;
-                }
-                output += '\n';
-            }
-            // Script content preview
-            output += `Script Content:\n`;
-            output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
-            output += script.script_content;
-            output += '\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n';
-            return { success: true, output };
-        }
-        catch (error) {
-            return { success: false, error: getErrorMessage(error) };
-        }
+        const slug = this.resolveScriptSlug(args.script);
+        const response = await this.client.get(`/api/automation/scripts/${slug}`);
+        const s = response.data.script || response.data;
+        let out = `**${s.name}** (${s.slug})\n${s.description}\n\nParameters:\n`;
+        s.parameters?.forEach((p) => out += `- ${p.name} (${p.type}): ${p.description}\n`);
+        out += `\nContent:\n\`\`\`bash\n${s.script_content}\n\`\`\``;
+        return { success: true, output: out };
     }
-    /**
-     * Execute a script on a remote server
-     */
     async executeScript(args) {
-        const scriptSlug = this.resolveScriptSlug(args.script);
+        const slug = this.resolveScriptSlug(args.script);
         const serverId = this.resolveServerId(args.server_id);
-        const params = args.parameters || {};
-        let output = `🚀 Executing Script\n`;
-        output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n`;
-        try {
-            // Step 1: Get script info
-            output += `[1/4] Retrieving script: ${scriptSlug}...\n`;
-            const scriptResponse = await this.client.get(`/api/automation/scripts/${scriptSlug}`);
-            if (!scriptResponse.data.success) {
-                throw new Error(scriptResponse.data.error || 'Script not found');
-            }
-            const script = scriptResponse.data.script;
-            output += `      ✓ Script: ${script.name}\n\n`;
-            // Step 2: Validate required parameters
-            output += `[2/4] Validating parameters...\n`;
-            const missingParams = [];
-            for (const param of script.parameters || []) {
-                if (param.required && params[param.name] === undefined) {
-                    missingParams.push(param.name);
-                }
-            }
-            if (missingParams.length > 0) {
-                throw new Error(`Missing required parameters: ${missingParams.join(', ')}`);
-            }
-            output += `      ✓ Parameters validated\n\n`;
-            // Step 3: Get server info and credentials
-            output += `[3/4] Connecting to server...\n`;
-            const serverResponse = await this.client.get(`/api/automation/servers/${serverId}`);
-            if (!serverResponse.data.success) {
-                throw new Error(serverResponse.data.error || 'Server not found');
-            }
-            const server = serverResponse.data.server;
-            output += `      Target: ${server.username}@${server.hostname}:${server.port}\n`;
-            const credentials = await this.getServerCredentials(serverId);
-            output += `      ✓ Credentials retrieved\n\n`;
-            // Step 4: Execute script
-            output += `[4/4] Executing script on remote server...\n`;
-            output += `      Timeout: ${script.timeout_seconds} seconds\n\n`;
-            // Create log entry
-            const logId = await this.createExecutionLog(script.id, serverId, params);
-            // Build script with parameters as environment variables
-            const fullScript = this.buildScriptWithParams(script.script_content, params);
-            // Execute on remote server
-            const result = await this.executeRemoteScript(credentials, fullScript, script.timeout_seconds * 1000);
-            // Update log with results
-            await this.updateExecutionLog(logId, result);
-            if (result.success) {
-                output += `═══════════════════════════════════════════\n`;
-                output += `✅ EXECUTION SUCCESSFUL\n`;
-                output += `═══════════════════════════════════════════\n\n`;
-                output += `Output:\n${result.output || '(no output)'}\n`;
-            }
-            else {
-                output += `═══════════════════════════════════════════\n`;
-                output += `❌ EXECUTION FAILED\n`;
-                output += `═══════════════════════════════════════════\n\n`;
-                output += `Error: ${result.error}\n`;
-                if (result.output) {
-                    output += `Output:\n${result.output}\n`;
-                }
-            }
-            return { success: result.success, output, error: result.error };
-        }
-        catch (error) {
-            output += `\n❌ Error: ${error.message}\n`;
-            return { success: false, output, error: error.message };
-        }
+        // 1. Get Script Content
+        const scriptRes = await this.client.get(`/api/automation/scripts/${slug}`);
+        const script = scriptRes.data.script;
+        // 2. Get Server Credentials
+        const credsRes = await this.client.get(`/api/automation/servers/${serverId}/credentials`, {
+            headers: { 'X-Automation-Session-Id': this.sessionId || 'cli' }
+        });
+        const creds = credsRes.data.credentials;
+        // 3. Log start
+        const logId = await this.createExecutionLog(script.id, serverId, args.parameters || {});
+        // 4. Execute
+        const fullScript = this.buildEnvironmentExports(args.parameters) + script.script_content;
+        const result = await this.executeRemoteScript(creds, fullScript, script.timeout_seconds * 1000);
+        // 5. Update Log
+        await this.updateExecutionLog(logId, result);
+        return {
+            success: result.success,
+            output: result.output || result.error || 'No output'
+        };
     }
-    /**
-     * Get execution logs
-     */
     async getExecutionLogs(args) {
-        try {
-            const params = new URLSearchParams();
-            if (args.script) {
-                params.append('script', this.resolveScriptSlug(args.script));
-            }
-            if (args.server_id) {
-                params.append('server_id', this.resolveServerId(args.server_id));
-            }
-            params.append('limit', String(args.limit || 10));
-            const query = `?${params.toString()}`;
-            const response = await this.client.get(`/api/automation/scripts/executions${query}`);
-            if (!response.data.success) {
-                return { success: false, error: response.data.error || 'Failed to get execution logs' };
-            }
-            const logs = response.data.logs;
-            if (logs.length === 0) {
-                return {
-                    success: true,
-                    output: 'No execution logs found.'
-                };
-            }
-            let output = `Recent Executions (${logs.length}):\n\n`;
-            for (const log of logs) {
-                const statusIcon = log.status === 'success' ? '✅' :
-                    log.status === 'failed' ? '❌' :
-                        log.status === 'running' ? '🔄' : '⚪';
-                output += `${statusIcon} ${new Date(log.started_at).toLocaleString()}\n`;
-                output += `   Script: ${log.script_id}\n`;
-                output += `   Server: ${log.server_id}\n`;
-                output += `   Status: ${log.status}`;
-                if (log.exit_code !== undefined) {
-                    output += ` (exit code: ${log.exit_code})`;
-                }
-                if (log.duration_ms) {
-                    output += ` - ${log.duration_ms}ms`;
-                }
-                output += '\n';
-                if (log.stdout) {
-                    const preview = log.stdout.substring(0, 200);
-                    output += `   Output: ${preview}${log.stdout.length > 200 ? '...' : ''}\n`;
-                }
-                if (log.stderr) {
-                    const preview = log.stderr.substring(0, 200);
-                    output += `   Errors: ${preview}${log.stderr.length > 200 ? '...' : ''}\n`;
-                }
-                output += '\n';
-            }
-            return { success: true, output };
-        }
-        catch (error) {
-            return { success: false, error: getErrorMessage(error) };
-        }
+        const params = new URLSearchParams();
+        if (args.script)
+            params.append('script', this.resolveScriptSlug(args.script));
+        if (args.server_id)
+            params.append('server_id', this.resolveServerId(args.server_id));
+        params.append('limit', String(args.limit || 10));
+        params.append('offset', String(args.offset || 0));
+        const response = await this.client.get(`/api/automation/scripts/executions?${params.toString()}`);
+        const logs = response.data.logs || response.data;
+        if (!logs.length)
+            return { success: true, output: 'No logs.' };
+        return {
+            success: true,
+            output: logs.map((l) => `${l.started_at} - ${l.status} (Exit: ${l.exit_code})`).join('\n')
+        };
     }
-    // ============= HELPER METHODS =============
-    /**
-     * Get server credentials (internal use only)
-     */
-    async getServerCredentials(serverId) {
-        const response = await this.client.get(`/api/automation/servers/${serverId}/credentials`, {
-            headers: {
-                'X-Automation-Session-Id': this.sessionId || 'cli-session'
+    // ============= SESSION IMPLEMENTATIONS =============
+    async listSessions(args) {
+        const response = await this.client.get('/api/automation/sessions', {
+            params: {
+                ...args,
+                limit: args.limit,
+                offset: args.offset
             }
         });
-        if (!response.data.success) {
-            throw new Error(response.data.error || 'Failed to get server credentials');
-        }
-        return response.data.credentials;
+        const sessions = response.data.sessions || response.data;
+        if (!sessions.length)
+            return { success: true, output: 'No active sessions.' };
+        return {
+            success: true,
+            output: sessions.map((s) => `ID: ${s.id} - ${s.type} - ${s.status}`).join('\n')
+        };
     }
-    /**
-     * Build script with parameters as environment variables
-     */
-    buildScriptWithParams(scriptContent, params) {
-        // Build export statements for parameters
-        let exports = '';
-        for (const [key, value] of Object.entries(params)) {
-            // Escape single quotes in value
-            const escapedValue = String(value).replace(/'/g, "'\"'\"'");
-            exports += `export ${key}='${escapedValue}'\n`;
+    async createSession(args) {
+        const response = await this.client.post('/api/automation/sessions', args);
+        return { success: true, output: `✅ Session created: ${response.data.session?.id || response.data.id}` };
+    }
+    async getSession(args) {
+        const response = await this.client.get(`/api/automation/sessions/${args.session_id}`);
+        return { success: true, output: JSON.stringify(response.data, null, 2) };
+    }
+    async deleteSession(args) {
+        await this.client.delete(`/api/automation/sessions/${args.session_id}`);
+        return { success: true, output: '✅ Session deleted.' };
+    }
+    // ============= TEMPLATES & KEYS =============
+    async listTemplates(args) {
+        const response = await this.client.get('/api/automation/templates', { params: args });
+        const t = response.data.templates || response.data;
+        if (!t.length)
+            return { success: true, output: 'No templates.' };
+        return { success: true, output: t.map((tpl) => `- ${tpl.name}`).join('\n') };
+    }
+    async createTemplate(args) {
+        await this.client.post('/api/automation/templates', args);
+        return { success: true, output: '✅ Template created.' };
+    }
+    async listSSHKeys() {
+        const response = await this.client.get('/api/automation/ssh-keys');
+        const keys = response.data.keys || response.data;
+        if (!keys.length)
+            return { success: true, output: 'No SSH keys.' };
+        return { success: true, output: keys.map((k) => `- ${k.name} (${k.fingerprint})`).join('\n') };
+    }
+    // ============= HELPERS =============
+    buildEnvironmentExports(params) {
+        if (!params)
+            return '';
+        let exports = '#!/bin/bash\n';
+        for (const [k, v] of Object.entries(params)) {
+            const val = String(v).replace(/'/g, "'\"'\"'");
+            exports += `export ${k}='${val}'\n`;
         }
-        // Prepend exports to script
-        return `#!/bin/bash\n${exports}\n${scriptContent}`;
+        return exports + '\n';
     }
-    /**
-     * Create execution log entry
-     */
     async createExecutionLog(scriptId, serverId, params) {
         try {
-            const response = await this.client.post('/api/automation/scripts/executions', {
-                script_id: scriptId,
-                server_id: serverId,
-                parameters_used: params,
-                session_id: this.sessionId
+            const res = await this.client.post('/api/automation/scripts/executions', {
+                script_id: scriptId, server_id: serverId, parameters_used: params, session_id: this.sessionId
             });
-            return response.data.log_id;
+            return res.data.log_id || 'temp-id';
         }
         catch {
-            return 'local-' + (0, crypto_1.randomBytes)(8).toString('hex');
+            return 'local-' + (0, crypto_1.randomBytes)(4).toString('hex');
         }
     }
-    /**
-     * Update execution log with results
-     */
     async updateExecutionLog(logId, result) {
         try {
             await this.client.patch(`/api/automation/scripts/executions/${logId}`, {
                 status: result.success ? 'success' : 'failed',
-                stdout: result.output,
-                stderr: result.error,
+                stdout: result.output, stderr: result.error,
                 exit_code: result.success ? 0 : 1,
                 completed_at: new Date().toISOString()
             });
         }
-        catch {
-            // Ignore log update failures
-        }
+        catch { /* ignore */ }
     }
-    /**
-     * Execute script on remote server via SSH
-     */
-    async executeRemoteScript(credentials, script, timeoutMs = 300000) {
-        const tempDir = (0, path_1.join)((0, os_1.tmpdir)(), `langmart-script-${(0, crypto_1.randomBytes)(8).toString('hex')}`);
+    async executeRemoteScript(creds, script, timeoutMs) {
+        const tempDir = (0, path_1.join)((0, os_1.tmpdir)(), `lm-${(0, crypto_1.randomBytes)(6).toString('hex')}`);
+        await (0, promises_1.mkdir)(tempDir, { recursive: true });
         try {
-            await (0, promises_1.mkdir)(tempDir, { recursive: true });
-            // Write script to temp file
             const scriptPath = (0, path_1.join)(tempDir, 'script.sh');
             await (0, promises_1.writeFile)(scriptPath, script, { mode: 0o755 });
-            let sshCommand;
-            let scpCommand;
-            if (credentials.auth_type === 'password') {
-                const sshpassPrefix = `sshpass -p '${credentials.password}'`;
-                scpCommand = `${sshpassPrefix} scp -o StrictHostKeyChecking=no -P ${credentials.port} ${scriptPath} ${credentials.username}@${credentials.hostname}:/tmp/langmart_script.sh`;
-                sshCommand = `${sshpassPrefix} ssh -o StrictHostKeyChecking=no -p ${credentials.port} ${credentials.username}@${credentials.hostname} "chmod +x /tmp/langmart_script.sh && /tmp/langmart_script.sh && rm /tmp/langmart_script.sh"`;
+            let cmd = ''; // construct ssh command
+            // Simplified for brevity, normally handle sshpass/identity file logic
+            if (creds.auth_type === 'password') {
+                const sshpass = `sshpass -p '${creds.password}'`;
+                await execAsync(`${sshpass} scp -o StrictHostKeyChecking=no -P ${creds.port} ${scriptPath} ${creds.username}@${creds.hostname}:/tmp/s.sh`);
+                cmd = `${sshpass} ssh -o StrictHostKeyChecking=no -p ${creds.port} ${creds.username}@${creds.hostname} "chmod +x /tmp/s.sh && /tmp/s.sh"`;
             }
             else {
                 const keyPath = (0, path_1.join)(tempDir, 'id_rsa');
-                await (0, promises_1.writeFile)(keyPath, credentials.ssh_key, { mode: 0o600 });
-                const sshOpts = `-i ${keyPath} -o StrictHostKeyChecking=no`;
-                scpCommand = `scp ${sshOpts} -P ${credentials.port} ${scriptPath} ${credentials.username}@${credentials.hostname}:/tmp/langmart_script.sh`;
-                sshCommand = `ssh ${sshOpts} -p ${credentials.port} ${credentials.username}@${credentials.hostname} "chmod +x /tmp/langmart_script.sh && /tmp/langmart_script.sh && rm /tmp/langmart_script.sh"`;
-            }
-            // Copy script to remote
-            await execAsync(scpCommand, { timeout: 60000 });
-            // Execute script
-            const { stdout, stderr } = await execAsync(sshCommand, { timeout: timeoutMs });
-            return { success: true, output: stdout + (stderr ? `\nStderr: ${stderr}` : '') };
+                await (0, promises_1.writeFile)(keyPath, creds.ssh_key, { mode: 0o600 });
+                const opts = `-i ${keyPath} -o StrictHostKeyChecking=no`;
+                await execAsync(`scp ${opts} -P ${creds.port} ${scriptPath} ${creds.username}@${creds.hostname}:/tmp/s.sh`);
+                cmd = `ssh ${opts} -p ${creds.port} ${creds.username}@${creds.hostname} "chmod +x /tmp/s.sh && /tmp/s.sh"`;
+            }
+            const { stdout, stderr } = await execAsync(cmd, { timeout: timeoutMs });
+            // Clean up remote
+            // (Best effort fire-and-forget cleanup)
+            // await execAsync(...) 
+            return { success: true, output: stdout + (stderr ? `\nSTDERR:\n${stderr}` : '') };
         }
-        catch (error) {
-            return { success: false, error: error.message, output: error.stdout };
+        catch (err) {
+            return { success: false, error: err.message, output: err.stdout };
         }
         finally {
-            // Cleanup
             try {
                 await execAsync(`rm -rf ${tempDir}`);
             }