@silasfmartins/testhub 1.0.0

package/dist/src/infrastructure/adapters/SSHAdapter.js

@@ -0,0 +1,428 @@
+/**
+ * @fileoverview Adaptador SSH para execução remota seguindo padrões DDD
+ * @module Infrastructure/Adapters
+ */
+import { Client } from 'ssh2';
+import { SchemaValidator, SSHCredentialsSchema, } from '../../domain/schemas/ValidationSchemas.js';
+import { IntegrationError } from '../../functions/errors/IntegrationError.js';
+import { ValidationError } from '../../functions/errors/ValidationError.js';
+/**
+ * Adaptador que integra node-ssh com a arquitetura do AutoCore
+ * Implementa a interface ISSHClient usando node-ssh
+ */
+export class SSHAdapter {
+    ssh = null;
+    connected = false;
+    connectionInfo = null;
+    constructor() {
+        // Lazy loading da biblioteca node-ssh
+    }
+    /**
+     * Conecta ao servidor SSH
+     */
+    async connect(credentials) {
+        try {
+            // Validação usando Zod
+            const validCredentials = SchemaValidator.validate(SSHCredentialsSchema, credentials);
+            // Lazy loading da biblioteca SSH
+            if (!this.ssh) {
+                try {
+                    // Usar ssh2 em vez de node-ssh
+                    this.ssh = new Client();
+                }
+                catch (error) {
+                    // Fallback para implementação mock se ssh2 não estiver disponível
+                    this.ssh = {
+                        connect: async () => {
+                            throw new Error('ssh2 não instalado');
+                        },
+                        dispose: async () => { },
+                        execCommand: async () => ({
+                            code: 1,
+                            stdout: '',
+                            stderr: 'node-ssh não instalado',
+                        }),
+                        putFile: async () => {
+                            throw new Error('node-ssh não instalado');
+                        },
+                        getFile: async () => {
+                            throw new Error('node-ssh não instalado');
+                        },
+                    };
+                }
+            }
+            // Preparar configuração de conexão
+            const config = {
+                host: validCredentials.host,
+                port: validCredentials.port,
+                username: validCredentials.username,
+                readyTimeout: 30_000,
+                keepaliveInterval: 15_000,
+                algorithms: {
+                    kex: [
+                        'diffie-hellman-group-exchange-sha256',
+                        'diffie-hellman-group14-sha256',
+                        'diffie-hellman-group14-sha1',
+                        'diffie-hellman-group1-sha1',
+                        'ecdh-sha2-nistp256',
+                        'ecdh-sha2-nistp384',
+                        'ecdh-sha2-nistp521',
+                    ],
+                    cipher: [
+                        'aes128-ctr',
+                        'aes192-ctr',
+                        'aes256-ctr',
+                        'aes128-gcm',
+                        'aes256-gcm',
+                        'aes128-cbc',
+                        'aes192-cbc',
+                        'aes256-cbc',
+                    ],
+                    hmac: ['hmac-sha2-256', 'hmac-sha2-512', 'hmac-sha1'],
+                },
+            };
+            // Adicionar autenticação
+            if (validCredentials.privateKey) {
+                config.privateKey = validCredentials.privateKey;
+                if (validCredentials.passphrase) {
+                    config.passphrase = validCredentials.passphrase;
+                }
+            }
+            else if (validCredentials.password) {
+                config.password = validCredentials.password;
+            }
+            else {
+                throw ValidationError.missingRequiredParameter('password or privateKey');
+            }
+            await this.ssh.connect(config);
+            this.connected = true;
+            this.connectionInfo = validCredentials;
+        }
+        catch (error) {
+            const err = error;
+            this.connected = false;
+            this.connectionInfo = null;
+            throw IntegrationError.sshConnectionFailed(credentials.host, err);
+        }
+    }
+    /**
+     * Desconecta do servidor SSH
+     */
+    async disconnect() {
+        try {
+            if (this.ssh && this.connected) {
+                this.ssh.end();
+            }
+        }
+        finally {
+            this.connected = false;
+            this.connectionInfo = null;
+            this.ssh = null;
+        }
+    }
+    /**
+     * Verifica se está conectado
+     */
+    isConnected() {
+        return this.connected && !!this.ssh;
+    }
+    /**
+     * Executa comando no servidor remoto
+     */
+    async executeCommand(command, options = {}) {
+        if (!this.isConnected()) {
+            throw ValidationError.invalidConfiguration('ssh', 'SSH não está conectado');
+        }
+        if (!command.trim()) {
+            throw ValidationError.missingRequiredParameter('command');
+        }
+        const startTime = new Date();
+        try {
+            const execOptions = {
+                execOptions: {},
+            };
+            if (options.cwd) {
+                // Prefixar comando com mudança de diretório
+                command = `cd ${options.cwd} && ${command}`;
+            }
+            if (options.timeout) {
+                execOptions.execOptions.timeout = options.timeout;
+            }
+            const result = await this.ssh.execCommand(command, execOptions);
+            return {
+                success: result.code === 0,
+                stdout: result.stdout || '',
+                stderr: result.stderr || '',
+                exitCode: result.code || 0,
+                command,
+                timestamp: startTime,
+            };
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.webOperationFailed('executeCommand', `Falha ao executar comando: ${command}`, err);
+        }
+    }
+    /**
+     * Faz upload de arquivo para o servidor
+     */
+    async uploadFile(localPath, remotePath) {
+        if (!this.isConnected()) {
+            throw ValidationError.invalidConfiguration('ssh', 'SSH não está conectado');
+        }
+        if (!(localPath.trim() && remotePath.trim())) {
+            throw ValidationError.missingRequiredParameter('localPath and remotePath');
+        }
+        try {
+            await this.ssh.putFile(localPath, remotePath);
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.fileSystemError('upload', `${localPath} -> ${remotePath}`, err);
+        }
+    }
+    /**
+     * Faz download de arquivo do servidor
+     */
+    async downloadFile(remotePath, localPath) {
+        if (!this.isConnected()) {
+            throw ValidationError.invalidConfiguration('ssh', 'SSH não está conectado');
+        }
+        if (!(localPath.trim() && remotePath.trim())) {
+            throw ValidationError.missingRequiredParameter('localPath and remotePath');
+        }
+        try {
+            await this.ssh.getFile(localPath, remotePath);
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.fileSystemError('download', `${remotePath} -> ${localPath}`, err);
+        }
+    }
+    /**
+     * Cria diretório no servidor
+     */
+    async createDirectory(remotePath, recursive = true) {
+        if (!this.isConnected()) {
+            throw ValidationError.invalidConfiguration('ssh', 'SSH não está conectado');
+        }
+        if (!remotePath.trim()) {
+            throw ValidationError.missingRequiredParameter('remotePath');
+        }
+        try {
+            const command = recursive
+                ? `mkdir -p "${remotePath}"`
+                : `mkdir "${remotePath}"`;
+            const result = await this.executeCommand(command);
+            if (!result.success) {
+                throw new Error(`Falha ao criar diretório: ${result.stderr}`);
+            }
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.fileSystemError('createDirectory', remotePath, err);
+        }
+    }
+    /**
+     * Remove arquivo do servidor
+     */
+    async removeFile(remotePath) {
+        if (!this.isConnected()) {
+            throw ValidationError.invalidConfiguration('ssh', 'SSH não está conectado');
+        }
+        if (!remotePath.trim()) {
+            throw ValidationError.missingRequiredParameter('remotePath');
+        }
+        try {
+            const result = await this.executeCommand(`rm -f "${remotePath}"`);
+            if (!result.success) {
+                throw new Error(`Falha ao remover arquivo: ${result.stderr}`);
+            }
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.fileSystemError('removeFile', remotePath, err);
+        }
+    }
+    /**
+     * Remove diretório do servidor
+     */
+    async removeDirectory(remotePath, recursive = false) {
+        if (!this.isConnected()) {
+            throw ValidationError.invalidConfiguration('ssh', 'SSH não está conectado');
+        }
+        if (!remotePath.trim()) {
+            throw ValidationError.missingRequiredParameter('remotePath');
+        }
+        try {
+            const command = recursive
+                ? `rm -rf "${remotePath}"`
+                : `rmdir "${remotePath}"`;
+            const result = await this.executeCommand(command);
+            if (!result.success) {
+                throw new Error(`Falha ao remover diretório: ${result.stderr}`);
+            }
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.fileSystemError('removeDirectory', remotePath, err);
+        }
+    }
+    /**
+     * Verifica se arquivo existe no servidor
+     */
+    async fileExists(remotePath) {
+        if (!this.isConnected()) {
+            throw ValidationError.invalidConfiguration('ssh', 'SSH não está conectado');
+        }
+        if (!remotePath.trim()) {
+            throw ValidationError.missingRequiredParameter('remotePath');
+        }
+        try {
+            const result = await this.executeCommand(`test -e "${remotePath}" && echo "exists"`);
+            return result.success && result.stdout.includes('exists');
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Obtém informações de arquivo/diretório
+     */
+    async getFileInfo(remotePath) {
+        if (!this.isConnected()) {
+            throw ValidationError.invalidConfiguration('ssh', 'SSH não está conectado');
+        }
+        if (!remotePath.trim()) {
+            throw ValidationError.missingRequiredParameter('remotePath');
+        }
+        try {
+            const result = await this.executeCommand(`stat -c "%s %Y %F" "${remotePath}"`);
+            if (!result.success) {
+                throw new Error(`Arquivo não encontrado: ${remotePath}`);
+            }
+            const parts = result.stdout.trim().split(' ');
+            if (parts.length < 3) {
+                throw new Error('Formato inválido de stat');
+            }
+            const size = Number.parseInt(parts[0], 10);
+            const modifiedTimestamp = Number.parseInt(parts[1], 10);
+            const fileType = parts.slice(2).join(' ');
+            return {
+                size: isNaN(size) ? 0 : size,
+                modified: new Date(modifiedTimestamp * 1000),
+                isDirectory: fileType.includes('directory'),
+            };
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.fileSystemError('getFileInfo', remotePath, err);
+        }
+    }
+    /**
+     * Lista conteúdo de diretório
+     */
+    async listDirectory(remotePath) {
+        if (!this.isConnected()) {
+            throw ValidationError.invalidConfiguration('ssh', 'SSH não está conectado');
+        }
+        if (!remotePath.trim()) {
+            throw ValidationError.missingRequiredParameter('remotePath');
+        }
+        try {
+            const result = await this.executeCommand(`ls -1 "${remotePath}"`);
+            if (!result.success) {
+                throw new Error(`Falha ao listar diretório: ${result.stderr}`);
+            }
+            return result.stdout
+                .split('\n')
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0);
+        }
+        catch (error) {
+            const err = error;
+            throw IntegrationError.fileSystemError('listDirectory', remotePath, err);
+        }
+    }
+    /**
+     * Obtém informações da conexão atual
+     */
+    getConnectionInfo() {
+        return this.connectionInfo;
+    }
+    /**
+     * Obtém a instância do NodeSSH
+     * Para casos onde é necessário acessar funcionalidades específicas
+     */
+    getSSHClient() {
+        return this.ssh;
+    }
+    /**
+     * Executa múltiplos comandos em sequência
+     */
+    async executeCommandSequence(commands, options = {}) {
+        if (!commands || commands.length === 0) {
+            throw ValidationError.missingRequiredParameter('commands');
+        }
+        const results = [];
+        const stopOnError = options.stopOnError !== false;
+        for (const command of commands) {
+            try {
+                const result = await this.executeCommand(command, options);
+                results.push(result);
+                if (stopOnError && !result.success) {
+                    break;
+                }
+            }
+            catch (error) {
+                const errorResult = {
+                    success: false,
+                    stdout: '',
+                    stderr: error.message,
+                    exitCode: -1,
+                    command,
+                    timestamp: new Date(),
+                };
+                results.push(errorResult);
+                if (stopOnError) {
+                    break;
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Executa script local no servidor remoto
+     */
+    async executeScript(scriptContent, options = {}) {
+        if (!scriptContent.trim()) {
+            throw ValidationError.missingRequiredParameter('scriptContent');
+        }
+        const interpreter = options.interpreter || 'bash';
+        const args = options.args ? options.args.join(' ') : '';
+        const tempFile = `/tmp/autocore_script_${Date.now()}.sh`;
+        try {
+            // Upload do script
+            const fs = await import('fs/promises');
+            const localTempFile = `./temp_script_${Date.now()}.sh`;
+            await fs.writeFile(localTempFile, scriptContent);
+            await this.uploadFile(localTempFile, tempFile);
+            await fs.unlink(localTempFile);
+            // Tornar executável e executar
+            await this.executeCommand(`chmod +x "${tempFile}"`);
+            const result = await this.executeCommand(`${interpreter} "${tempFile}" ${args}`, options);
+            // Limpar arquivo temporário
+            await this.removeFile(tempFile);
+            return result;
+        }
+        catch (error) {
+            // Tentar limpar arquivo temporário em caso de erro
+            try {
+                await this.removeFile(tempFile);
+            }
+            catch { }
+            const err = error;
+            throw IntegrationError.webOperationFailed('executeScript', 'Falha ao executar script remoto', err);
+        }
+    }
+}