langmart-gateway-type3 3.0.0

package/dist/devops-tools.js

@@ -0,0 +1,718 @@
+"use strict";
+/**
+ * DevOps Tools for Gateway Type 3
+ *
+ * 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
+ * - Execute scripts on remote servers
+ * - View script execution logs
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevOpsTools = void 0;
+const axios_1 = __importDefault(require("axios"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const os_1 = require("os");
+const crypto_1 = require("crypto");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class DevOpsTools {
+    constructor(marketplaceUrl, apiKey) {
+        this.sessionId = null;
+        this.serverMap = new Map(); // sequence number → UUID
+        this.scriptMap = new Map(); // sequence number → slug
+        this.marketplaceUrl = marketplaceUrl;
+        this.apiKey = apiKey;
+        this.client = axios_1.default.create({
+            baseURL: marketplaceUrl,
+            timeout: 60000,
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+    static getInstance(marketplaceUrl, apiKey) {
+        if (!DevOpsTools.instance && marketplaceUrl && apiKey) {
+            DevOpsTools.instance = new DevOpsTools(marketplaceUrl, apiKey);
+        }
+        if (!DevOpsTools.instance) {
+            throw new Error('DevOpsTools not initialized. Provide marketplaceUrl and apiKey.');
+        }
+        return DevOpsTools.instance;
+    }
+    setSessionId(sessionId) {
+        this.sessionId = sessionId;
+    }
+    /**
+     * Get tool definitions for AI
+     */
+    getTools() {
+        return [
+            // Server management tools
+            {
+                type: 'function',
+                function: {
+                    name: 'devops.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.',
+                    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'
+                            }
+                        },
+                        required: []
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'devops.servers.test_connection',
+                    description: 'Test SSH connectivity to a remote server. Returns success/failure with diagnostics and latency.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            server_id: {
+                                type: 'string',
+                                description: 'Server ID or sequence number (e.g., "1" for the first server from devops.servers.list)'
+                            }
+                        },
+                        required: ['server_id']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'devops.servers.get_info',
+                    description: 'Get detailed information about a specific server (without credentials).',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            server_id: {
+                                type: 'string',
+                                description: 'Server ID or sequence number'
+                            }
+                        },
+                        required: ['server_id']
+                    }
+                }
+            },
+            // Script management tools
+            {
+                type: 'function',
+                function: {
+                    name: 'devops.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.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            category: {
+                                type: 'string',
+                                enum: ['deployment', 'monitoring', 'maintenance', 'custom', 'all'],
+                                description: 'Filter by category (default: all)'
+                            }
+                        },
+                        required: []
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'devops.scripts.get_info',
+                    description: 'Get detailed information about a script including its full content and parameter definitions.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            script: {
+                                type: 'string',
+                                description: 'Script slug (e.g., "deploy-type3-gateway") or sequence number from devops.scripts.list'
+                            }
+                        },
+                        required: ['script']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'devops.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.',
+                    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 devops.servers.list'
+                            },
+                            parameters: {
+                                type: 'object',
+                                description: 'Script parameters as key-value pairs (e.g., {"GATEWAY_NAME": "my-gateway", "GATEWAY_PORT": 8083})'
+                            }
+                        },
+                        required: ['script', 'server_id']
+                    }
+                }
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'devops.scripts.get_execution_logs',
+                    description: 'Get execution history and logs for a script or server. Shows recent executions with status, output, and timing.',
+                    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)'
+                            }
+                        },
+                        required: []
+                    }
+                }
+            }
+        ];
+    }
+    /**
+     * Resolve server ID (handle sequence numbers like "1", "2", etc.)
+     */
+    resolveServerId(serverIdOrNumber) {
+        const num = parseInt(serverIdOrNumber);
+        if (!isNaN(num) && this.serverMap.has(num)) {
+            return this.serverMap.get(num);
+        }
+        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)) {
+            return this.scriptMap.get(num);
+        }
+        return scriptOrNumber;
+    }
+    /**
+     * Execute a DevOps tool
+     */
+    async executeTool(toolName, args) {
+        try {
+            switch (toolName) {
+                case 'devops.servers.list':
+                    return await this.listServers(args);
+                case 'devops.servers.test_connection':
+                    return await this.testServerConnection(args);
+                case 'devops.servers.get_info':
+                    return await this.getServerInfo(args);
+                case 'devops.scripts.list':
+                    return await this.listScripts(args);
+                case 'devops.scripts.get_info':
+                    return await this.getScriptInfo(args);
+                case 'devops.scripts.execute':
+                    return await this.executeScript(args);
+                case 'devops.scripts.get_execution_logs':
+                    return await this.getExecutionLogs(args);
+                default:
+                    return { success: false, error: `Unknown tool: ${toolName}` };
+            }
+        }
+        catch (error) {
+            console.error(`[DevOpsTools] Error executing ${toolName}:`, error.message);
+            return { success: false, error: error.message };
+        }
+    }
+    // ============= SERVER TOOLS =============
+    /**
+     * List remote servers
+     */
+    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/v1/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: error.response?.data?.error || error.message };
+        }
+    }
+    /**
+     * Test server connection
+     */
+    async testServerConnection(args) {
+        try {
+            const serverId = this.resolveServerId(args.server_id);
+            const response = await this.client.post(`/api/v1/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: error.response?.data?.error || error.message };
+        }
+    }
+    /**
+     * Get server info
+     */
+    async getServerInfo(args) {
+        try {
+            const serverId = this.resolveServerId(args.server_id);
+            const response = await this.client.get(`/api/v1/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: error.response?.data?.error || error.message };
+        }
+    }
+    // ============= SCRIPT TOOLS =============
+    /**
+     * List available scripts
+     */
+    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/v1/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 devops.scripts.get_info to see full script details.\n';
+            output += 'Use devops.scripts.execute to run a script on a server.';
+            return { success: true, output };
+        }
+        catch (error) {
+            return { success: false, error: error.response?.data?.error || error.message };
+        }
+    }
+    /**
+     * Get script info
+     */
+    async getScriptInfo(args) {
+        try {
+            const scriptSlug = this.resolveScriptSlug(args.script);
+            const response = await this.client.get(`/api/v1/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: error.response?.data?.error || error.message };
+        }
+    }
+    /**
+     * Execute a script on a remote server
+     */
+    async executeScript(args) {
+        const scriptSlug = 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/v1/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/v1/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 };
+        }
+    }
+    /**
+     * 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/v1/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: error.response?.data?.error || error.message };
+        }
+    }
+    // ============= HELPER METHODS =============
+    /**
+     * Get server credentials (internal use only)
+     */
+    async getServerCredentials(serverId) {
+        const response = await this.client.get(`/api/v1/servers/${serverId}/credentials`, {
+            headers: {
+                'X-DevOps-Session-Id': this.sessionId || 'cli-session'
+            }
+        });
+        if (!response.data.success) {
+            throw new Error(response.data.error || 'Failed to get server credentials');
+        }
+        return response.data.credentials;
+    }
+    /**
+     * 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`;
+        }
+        // Prepend exports to script
+        return `#!/bin/bash\n${exports}\n${scriptContent}`;
+    }
+    /**
+     * Create execution log entry
+     */
+    async createExecutionLog(scriptId, serverId, params) {
+        try {
+            const response = await this.client.post('/api/v1/scripts/executions', {
+                script_id: scriptId,
+                server_id: serverId,
+                parameters_used: params,
+                session_id: this.sessionId
+            });
+            return response.data.log_id;
+        }
+        catch {
+            return 'local-' + (0, crypto_1.randomBytes)(8).toString('hex');
+        }
+    }
+    /**
+     * Update execution log with results
+     */
+    async updateExecutionLog(logId, result) {
+        try {
+            await this.client.patch(`/api/v1/scripts/executions/${logId}`, {
+                status: result.success ? 'success' : 'failed',
+                stdout: result.output,
+                stderr: result.error,
+                exit_code: result.success ? 0 : 1,
+                completed_at: new Date().toISOString()
+            });
+        }
+        catch {
+            // Ignore log update failures
+        }
+    }
+    /**
+     * 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')}`);
+        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"`;
+            }
+            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}` : '') };
+        }
+        catch (error) {
+            return { success: false, error: error.message, output: error.stdout };
+        }
+        finally {
+            // Cleanup
+            try {
+                await execAsync(`rm -rf ${tempDir}`);
+            }
+            catch { }
+        }
+    }
+}
+exports.DevOpsTools = DevOpsTools;
+DevOpsTools.instance = null;
+exports.default = DevOpsTools;
+//# sourceMappingURL=devops-tools.js.map