@silasfmartins/testhub 1.0.0

package/dist/src/ssh/SSHClient.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Cliente SSH de baixo nível para execução de comandos e leitura de saída.
+ */
+export declare class SSHClient {
+    private conn;
+    private output;
+    private isConnected;
+    private startTime;
+    /**
+     * Cria uma nova instância de SSHClient e adiciona ao pool de clientes ativos.
+     */
+    constructor();
+    /**
+     * Conecta ao servidor SSH usando chave privada.
+     *
+     * 🆕 IMPORTANTE: HOST e USERNAME são obtidos automaticamente do AutoCore Hub
+     * quando você chama TestAnnotations.setSystem('SISTEMA').
+     * A CHAVE PRIVADA é passada pelo usuário (keyPath).
+     *
+     * O Hub injeta em process.env.SSH_HOST, SSH_USER, SSH_PASSWORD, SSH_PORT.
+     *
+     * @param keyPath Caminho para a chave privada (obrigatório - fornecido pelo usuário)
+     * @param options Opções opcionais para sobrescrever valores do Hub
+     * @returns this
+     *
+     * @example
+     * // Uso simples - host/user vêm do Hub, chave é local
+     * await SSHActions.connectWithKey('secrets/minha_chave')
+     *
+     * // Uso avançado - sobrescrevendo valores do Hub
+     * await SSHClient.setPrivateKeyPath('secrets/chave', { host: 'outro-host.com' })
+     */
+    setPrivateKeyPath(keyPath: string, options?: {
+        host?: string;
+        port?: number;
+        username?: string;
+        passphrase?: string;
+    }): Promise<this>;
+    /**
+     * 🆕 Conecta ao servidor SSH usando usuário e senha (sem chave privada).
+     * Útil para conexões automatizadas via AutoCore Hub.
+     *
+     * @param host Host do servidor SSH
+     * @param port Porta SSH (default: 22)
+     * @param username Usuário SSH
+     * @param password Senha SSH
+     * @returns this
+     *
+     * @example
+     * const client = new SSHClient()
+     * await client.connectWithPassword('servidor.com', 22, 'user', 'senha')
+     */
+    connectWithPassword(host: string, port: number | undefined, username: string, password: string): Promise<this>;
+    /**
+     * Envia um comando SSH para o servidor remoto.
+     * @param command Comando SSH a ser enviado.
+     * @param description Descrição da ação.
+     * @returns this
+     */
+    write(command: string, description?: string): Promise<this>;
+    /**
+     * Lê a saída do log do servidor remoto.
+     * @param description Descrição da ação.
+     * @returns Saída do log como string.
+     */
+    read(description?: string): string;
+    /**
+     * Lê a última linha da saída do log.
+     * @param description Descrição da ação.
+     * @returns Última linha da saída.
+     */
+    readLast(description?: string): string;
+    /**
+     * Limpa o buffer de saída.
+     */
+    clearOutput(): void;
+    /**
+     * Verifica se a conexão SSH está ativa.
+     * @returns true se conectado, false caso contrário.
+     */
+    isSSHConnected(): boolean;
+    /**
+     * Desconecta do servidor SSH.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Executa um comando e retorna a saída.
+     * @param command Comando SSH a ser enviado.
+     * @param description Descrição da ação.
+     * @returns Saída do comando.
+     */
+    executeAndRead(command: string, description?: string): Promise<string>;
+    /**
+     * Desconecta todos os SSHClient ativos (usado no teardown global).
+     */
+    static disconnectAll(): Promise<void>;
+    /** Pool de clientes ativos para teardown global */
+    private static activeSSHClients;
+}

package/dist/src/ssh/SSHClient.js

@@ -0,0 +1,409 @@
+import fs from 'node:fs';
+import { createRequire } from 'module';
+import path from 'path';
+import { Client } from 'ssh2';
+import { ExecutionTracker } from '../hubdocs/ExecutionTracker.js';
+import { StatementTracker } from '../hubdocs/StatementTracker.js';
+import { TestContext } from '../testContext/TestContext.js';
+import { Logger } from '../utils/Logger.js';
+import { SSHActions } from './SSHActions.js';
+const require = createRequire(import.meta.url);
+/**
+ * Cliente SSH de baixo nível para execução de comandos e leitura de saída.
+ */
+export class SSHClient {
+    conn = new Client();
+    output = '';
+    isConnected = false;
+    startTime = 0;
+    /**
+     * Cria uma nova instância de SSHClient e adiciona ao pool de clientes ativos.
+     */
+    constructor() {
+        SSHClient.activeSSHClients.push(this);
+    }
+    /**
+     * Conecta ao servidor SSH usando chave privada.
+     *
+     * 🆕 IMPORTANTE: HOST e USERNAME são obtidos automaticamente do AutoCore Hub
+     * quando você chama TestAnnotations.setSystem('SISTEMA').
+     * A CHAVE PRIVADA é passada pelo usuário (keyPath).
+     *
+     * O Hub injeta em process.env.SSH_HOST, SSH_USER, SSH_PASSWORD, SSH_PORT.
+     *
+     * @param keyPath Caminho para a chave privada (obrigatório - fornecido pelo usuário)
+     * @param options Opções opcionais para sobrescrever valores do Hub
+     * @returns this
+     *
+     * @example
+     * // Uso simples - host/user vêm do Hub, chave é local
+     * await SSHActions.connectWithKey('secrets/minha_chave')
+     *
+     * // Uso avançado - sobrescrevendo valores do Hub
+     * await SSHClient.setPrivateKeyPath('secrets/chave', { host: 'outro-host.com' })
+     */
+    async setPrivateKeyPath(keyPath, options) {
+        const privateKey = fs.readFileSync(path.resolve(keyPath), 'utf-8');
+        // 🆕 Credenciais do Hub (injetadas via setSystem → injectIntoEnvironment)
+        // O usuário pode sobrescrever via options se necessário
+        const host = options?.host || process.env.SSH_HOST;
+        const port = options?.port || Number.parseInt(process.env.SSH_PORT || '22', 10);
+        const username = options?.username || process.env.SSH_USER;
+        const passphrase = options?.passphrase || process.env.SSH_PASSPHRASE || process.env.SSH_PASSWORD || '';
+        // Validar credenciais obrigatórias
+        if (!host || host === 'não definido') {
+            throw new Error(`
+❌ SSH_HOST não configurado!
+
+Certifique-se de:
+1. Chamar TestAnnotations.setSystem('NOME_DO_SISTEMA') antes de conectar
+2. O sistema ter o campo 'url' (host SSH) configurado no Hub
+3. Ou passar o host manualmente: setPrivateKeyPath('chave', { host: 'seu-host.com' })
+
+Valor atual de SSH_HOST: ${process.env.SSH_HOST || '(não definido)'}
+`);
+        }
+        if (!username || username === 'não definido') {
+            throw new Error(`
+❌ SSH_USER não configurado!
+
+Certifique-se de:
+1. Chamar TestAnnotations.setSystem('NOME_DO_SISTEMA') antes de conectar
+2. O sistema ter o campo 'username' configurado no Hub
+3. Ou passar o username manualmente: setPrivateKeyPath('chave', { username: 'seu-user' })
+
+Valor atual de SSH_USER: ${process.env.SSH_USER || '(não definido)'}
+`);
+        }
+        Logger.bloco('Iniciando conexão SSH com chave privada');
+        Logger.info(`Host: ${host} (do Hub)`);
+        Logger.info(`Porta: ${port}`);
+        Logger.info(`Usuário: ${username} (do Hub)`);
+        Logger.info(`Chave: ${keyPath} (local)`);
+        Logger.info(`Passphrase: ${passphrase ? '********' : 'não definida'}`);
+        SSHActions.adicionarLog(`Iniciando conexão SSH em ${host}:${port}`, 'info');
+        SSHActions.registrarInicioExecucao();
+        Logger.debug && Logger.debug('SSHClient: iniciando conexão (setPrivateKeyPath)');
+        return new Promise((resolve, reject) => {
+            this.conn
+                .on('ready', () => {
+                this.isConnected = true;
+                Logger.success(`Conexão SSH estabelecida com sucesso em ${host}:${port}`);
+                Logger.debug && Logger.debug('SSHClient: evento ready recebido');
+                SSHActions.adicionarLog(`Conexão SSH estabelecida: ${host}:${port}`, 'success');
+                resolve(this);
+            })
+                .on('error', (err) => {
+                Logger.error(`Erro ao conectar no SSH (${host}:${port})`, err);
+                Logger.debug && Logger.debug(`SSHClient: erro de conexão: ${err.stack || err}`);
+                SSHActions.adicionarLog(`Erro na conexão SSH: ${err.message}`, 'error');
+                reject(err);
+            })
+                .connect({
+                host,
+                port,
+                username,
+                privateKey,
+                passphrase: passphrase || undefined,
+            });
+        });
+    }
+    /**
+     * 🆕 Conecta ao servidor SSH usando usuário e senha (sem chave privada).
+     * Útil para conexões automatizadas via AutoCore Hub.
+     *
+     * @param host Host do servidor SSH
+     * @param port Porta SSH (default: 22)
+     * @param username Usuário SSH
+     * @param password Senha SSH
+     * @returns this
+     *
+     * @example
+     * const client = new SSHClient()
+     * await client.connectWithPassword('servidor.com', 22, 'user', 'senha')
+     */
+    async connectWithPassword(host, port = 22, username, password) {
+        Logger.bloco('Iniciando conexão SSH com senha');
+        Logger.info(`Host: ${host}`);
+        Logger.info(`Porta: ${port}`);
+        Logger.info(`Usuário: ${username}`);
+        Logger.info(`Senha: ********`);
+        SSHActions.adicionarLog(`Iniciando conexão SSH em ${host}:${port}`, 'info');
+        SSHActions.registrarInicioExecucao();
+        return new Promise((resolve, reject) => {
+            this.conn
+                .on('ready', () => {
+                this.isConnected = true;
+                Logger.success(`Conexão SSH estabelecida com sucesso em ${host}:${port}`);
+                SSHActions.adicionarLog(`Conexão SSH estabelecida: ${host}:${port}`, 'success');
+                resolve(this);
+            })
+                .on('error', (err) => {
+                Logger.error(`Erro ao conectar no SSH (${host}:${port})`, err);
+                SSHActions.adicionarLog(`Erro na conexão SSH: ${err.message}`, 'error');
+                reject(err);
+            })
+                .connect({
+                host,
+                port,
+                username,
+                password,
+            });
+        });
+    }
+    /**
+     * Envia um comando SSH para o servidor remoto.
+     * @param command Comando SSH a ser enviado.
+     * @param description Descrição da ação.
+     * @returns this
+     */
+    async write(command, description = '') {
+        return new Promise(async (resolve, reject) => {
+            if (!this.isConnected) {
+                const msg = 'Tentativa de escrever sem conexão SSH ativa.';
+                Logger.error(msg);
+                SSHActions.adicionarLog(`Erro: ${msg}`, 'error');
+                return reject(msg);
+            }
+            // 🆕 Registrar início da execução SSH
+            SSHActions.registrarInicioExecucao();
+            // 🆕 Registrar statement no StatementTracker
+            let statementTimestamp = null;
+            try {
+                statementTimestamp = StatementTracker.startStatement('SSHClient', `write: ${description || command}`);
+            }
+            catch (error) {
+                Logger.warning(`Não foi possível registrar statement no StatementTracker: ${error}`);
+            }
+            this.startTime = Date.now();
+            const commandTimestamp = new Date().toISOString();
+            // 🆕 Registrar comando SSH no ExecutionTracker para AutoDocs
+            const sshCommand = {
+                command,
+                output: '',
+                host: process.env.SSH_HOST || 'unknown',
+                user: process.env.SSH_USER || 'unknown',
+                timestamp: commandTimestamp,
+                testName: TestContext.getSafeTestInfo()?.title || description || 'SSH Command',
+                duration: 0,
+                exitCode: undefined,
+            };
+            this.conn.exec(command, (err, stream) => {
+                if (err) {
+                    Logger.error(`Erro ao executar comando: ${command}`, err);
+                    SSHActions.logEvent(`❌ ${description} → ${command}: ${err.message}`);
+                    // 🆕 Atualizar ExecutionTracker com erro
+                    sshCommand.duration = Date.now() - this.startTime;
+                    sshCommand.output = `ERROR: ${err.message}`;
+                    sshCommand.exitCode = 1;
+                    ExecutionTracker.trackSSH(sshCommand);
+                    // 🆕 Finalizar statement com erro
+                    if (statementTimestamp) {
+                        import('../hubdocs/StatementTracker.js')
+                            .then(({ StatementTracker }) => {
+                            StatementTracker.finishStatement(statementTimestamp, false, `❌ ${description}: ${err.message}`);
+                        })
+                            .catch((error) => {
+                            Logger.warning(`Não foi possível finalizar statement no StatementTracker: ${error}`);
+                        });
+                    }
+                    return reject(err);
+                }
+                Logger.info(`Executando: ${description} → ${command}`);
+                SSHActions.logEvent(`🔹 ${description} → ${command}`);
+                stream
+                    .on('close', (code) => {
+                    const duracao = Date.now() - this.startTime;
+                    SSHActions.registrarDuracaoDoTeste(description, duracao);
+                    Logger.success(`Comando finalizado: ${description}`);
+                    SSHActions.adicionarLog(`Comando finalizado: ${description} (${duracao}ms)`, 'success');
+                    // 🆕 Atualizar ExecutionTracker com sucesso
+                    sshCommand.duration = duracao;
+                    sshCommand.output = this.output;
+                    sshCommand.exitCode = code;
+                    ExecutionTracker.trackSSH(sshCommand);
+                    // 🚀 CRÍTICO: Registrar ação automaticamente no StatementTracker como o API faz
+                    import('../hubdocs/StatementTracker.js')
+                        .then(({ StatementTracker }) => {
+                        StatementTracker.recordAction('SSH', `${description || command}`, code === 0, duracao, {
+                            command,
+                            action: `SSH: ${description || command}`,
+                        });
+                    })
+                        .catch((error) => {
+                        Logger.error('Não foi possível registrar ação SSH no StatementTracker:', error);
+                    });
+                    // 🆕 Atualizar resultado SSH com base no exitCode
+                    const success = code === 0;
+                    ExecutionTracker.updateSSHResult(command, commandTimestamp, success, duracao, code, success ? undefined : `Exit code: ${code}`);
+                    // 🆕 Finalizar statement no StatementTracker
+                    if (statementTimestamp) {
+                        import('../hubdocs/StatementTracker.js')
+                            .then(({ StatementTracker }) => {
+                            const statusMessage = success
+                                ? `✅ ${description}: Comando executado com sucesso (${duracao}ms)`
+                                : `❌ ${description}: Comando falhou com exit code ${code}`;
+                            StatementTracker.finishStatement(statementTimestamp, success, statusMessage);
+                        })
+                            .catch((error) => {
+                            Logger.warning(`Não foi possível finalizar statement no StatementTracker: ${error}`);
+                        });
+                    }
+                    resolve(this);
+                })
+                    .on('data', (data) => {
+                    const text = data.toString();
+                    this.output += `\n[${description}] ${text}`;
+                    sshCommand.output += text;
+                    SSHActions.adicionarLog(`Saída recebida de "${description}": ${text.trim()}`, 'info');
+                })
+                    .stderr.on('data', (data) => {
+                    const errorText = data.toString();
+                    this.output += `\n[${description} - STDERR] ${errorText}`;
+                    sshCommand.output += `\nSTDERR: ${errorText}`;
+                    Logger.warning(`STDERR: ${errorText.trim()}`);
+                    SSHActions.adicionarLog(`STDERR de "${description}": ${errorText.trim()}`, 'warning');
+                });
+            });
+        });
+    }
+    /**
+     * Lê a saída do log do servidor remoto.
+     * @param description Descrição da ação.
+     * @returns Saída do log como string.
+     */
+    read(description = '') {
+        // 🆕 Registrar statement no StatementTracker
+        let statementTimestamp = null;
+        try {
+            const { StatementTracker } = require('../hubdocs/StatementTracker.js');
+            statementTimestamp = StatementTracker.startStatement('SSHClient', `read: ${description}`);
+        }
+        catch (error) {
+            Logger.warning(`Não foi possível registrar statement no StatementTracker: ${error}`);
+        }
+        if (this.output) {
+            Logger.info(`[${description}] Saída capturada com sucesso.`);
+            SSHActions.adicionarLog(`Saída capturada com sucesso: ${description}`, 'success');
+        }
+        else {
+            Logger.warning(`[${description}] Nenhuma saída foi capturada até o momento.`);
+            SSHActions.adicionarLog(`Nenhuma saída capturada para: ${description}`, 'warning');
+        }
+        SSHActions.logEvent(`📤 ${description} → ${this.output.trim()}`);
+        SSHActions.registrarFimExecucao();
+        // 🆕 Registrar operação de leitura SSH no ExecutionTracker
+        // ✅ CORRIGIDO: read() sempre é sucesso se não lança exceção
+        const sshReadCommand = {
+            command: `read: ${description}`,
+            output: this.output,
+            host: process.env.SSH_HOST || 'unknown',
+            user: process.env.SSH_USER || 'unknown',
+            timestamp: new Date().toISOString(),
+            testName: TestContext.getSafeTestInfo()?.title || description || 'SSH Read',
+            duration: 0,
+            exitCode: 0, // ✅ Sempre 0 - read() sempre é sucesso se chegou até aqui
+        };
+        ExecutionTracker.trackSSH(sshReadCommand);
+        // 🆕 Finalizar statement
+        if (statementTimestamp) {
+            try {
+                const { StatementTracker } = require('../hubdocs/StatementTracker.js');
+                const success = this.output ? true : false;
+                const message = success
+                    ? `✅ ${description}: Saída capturada com sucesso`
+                    : `⚠️ ${description}: Nenhuma saída capturada`;
+                StatementTracker.finishStatement(statementTimestamp, success, message);
+            }
+            catch (error) {
+                Logger.warning(`Não foi possível finalizar statement no StatementTracker: ${error}`);
+            }
+        }
+        return this.output;
+    }
+    /**
+     * Lê a última linha da saída do log.
+     * @param description Descrição da ação.
+     * @returns Última linha da saída.
+     */
+    readLast(description = '') {
+        const lines = this.output.split('\n');
+        const lastOutput = lines[lines.length - 1] || '';
+        Logger.info(`[${description}] Última saída capturada: ${lastOutput.trim()}`);
+        SSHActions.adicionarLog(`Última saída: ${description} → ${lastOutput.trim()}`, 'info');
+        return lastOutput;
+    }
+    /**
+     * Limpa o buffer de saída.
+     */
+    clearOutput() {
+        this.output = '';
+        Logger.info('Buffer de saída SSH limpo');
+        SSHActions.adicionarLog('Buffer de saída limpo', 'info');
+    }
+    /**
+     * Verifica se a conexão SSH está ativa.
+     * @returns true se conectado, false caso contrário.
+     */
+    isSSHConnected() {
+        return this.isConnected;
+    }
+    /**
+     * Desconecta do servidor SSH.
+     */
+    async disconnect() {
+        if (this.isConnected) {
+            this.conn.end();
+            this.isConnected = false;
+            Logger.info('Conexão SSH encerrada');
+            SSHActions.adicionarLog('Conexão SSH encerrada', 'info');
+        }
+    }
+    /**
+     * Executa um comando e retorna a saída.
+     * @param command Comando SSH a ser enviado.
+     * @param description Descrição da ação.
+     * @returns Saída do comando.
+     */
+    async executeAndRead(command, description = '') {
+        const startTime = Date.now();
+        const commandTimestamp = new Date().toISOString();
+        await this.write(command, description);
+        const output = this.read(description);
+        const duration = Date.now() - startTime;
+        // 🆕 Registrar comando completo SSH no ExecutionTracker
+        const sshCompleteCommand = {
+            command: `execute: ${command}`,
+            output,
+            host: process.env.SSH_HOST || 'unknown',
+            user: process.env.SSH_USER || 'unknown',
+            timestamp: commandTimestamp,
+            testName: TestContext.getSafeTestInfo()?.title ||
+                description ||
+                'SSH Execute+Read',
+            duration,
+            exitCode: 0,
+        };
+        ExecutionTracker.trackSSH(sshCompleteCommand);
+        // 🆕 Atualizar resultado SSH - assumindo sucesso se não houve exceção
+        ExecutionTracker.updateSSHResult(`execute: ${command}`, commandTimestamp, true, // sucesso se chegou até aqui
+        duration, 0);
+        return output;
+    }
+    /**
+     * Desconecta todos os SSHClient ativos (usado no teardown global).
+     */
+    static async disconnectAll() {
+        for (const client of SSHClient.activeSSHClients) {
+            try {
+                await client.disconnect();
+            }
+            catch {
+                // Ignorar erros individuais
+            }
+        }
+        SSHClient.activeSSHClients.length = 0;
+    }
+    /** Pool de clientes ativos para teardown global */
+    static activeSSHClients = [];
+}

package/dist/src/statements/BaseStatement.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 🎯 Classe base para Statements - Interface de tracking
+ */
+export declare abstract class Track {
+    /**
+     * ✅ Nome do CT sendo executado
+     */
+    ctName: string;
+    /**
+     * ✅ Dados de execução
+     */
+    executionData: any;
+    /**
+     * ✅ Status da execução
+     */
+    status: 'pending' | 'running' | 'completed' | 'error';
+    constructor();
+    /**
+     * 🔧 Método abstrato para execução do CT
+     */
+    abstract execute(...args: any[]): Promise<any> | any;
+    /**
+     * 📊 Registrar dados de execução
+     */
+    track(data: any): void;
+    /**
+     * ✅ Marcar como completado
+     */
+    complete(result?: any): void;
+    /**
+     * ❌ Marcar como erro
+     */
+    error(error: any): void;
+}
+/**
+ * 🎯 Decorator para métodos Statement
+ */
+export declare function statement(target: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;

package/dist/src/statements/BaseStatement.js

@@ -0,0 +1,78 @@
+import { Logger } from '../utils/Logger.js';
+/**
+ * 🎯 Classe base para Statements - Interface de tracking
+ */
+export class Track {
+    /**
+     * ✅ Nome do CT sendo executado
+     */
+    ctName = '';
+    /**
+     * ✅ Dados de execução
+     */
+    executionData = {};
+    /**
+     * ✅ Status da execução
+     */
+    status = 'pending';
+    constructor() {
+        // Garantir que o tracking está ativo
+        this.ctName = this.constructor.name;
+        Logger.info(`🎯 [Track] Statement criado: ${this.ctName}`);
+    }
+    /**
+     * 📊 Registrar dados de execução
+     */
+    track(data) {
+        this.executionData = { ...this.executionData, ...data };
+        Logger.info(`📊 [Track] Dados registrados para ${this.ctName}: ${JSON.stringify(data)}`);
+    }
+    /**
+     * ✅ Marcar como completado
+     */
+    complete(result) {
+        this.status = 'completed';
+        if (result !== undefined) {
+            this.executionData.result = result;
+        }
+        Logger.success(`✅ [Track] ${this.ctName} completado`);
+    }
+    /**
+     * ❌ Marcar como erro
+     */
+    error(error) {
+        this.status = 'error';
+        this.executionData.error = error;
+        Logger.error(`❌ [Track] ${this.ctName} com erro`, error);
+    }
+}
+/**
+ * 🎯 Decorator para métodos Statement
+ */
+export function statement(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = function (...args) {
+        Logger.info(`🚀 [Statement] Executando método: ${propertyKey}`);
+        try {
+            const result = originalMethod.apply(this, args);
+            if (result instanceof Promise) {
+                return result
+                    .then((res) => {
+                    Logger.success(`✅ [Statement] Método ${propertyKey} completado`);
+                    return res;
+                })
+                    .catch((error) => {
+                    Logger.error(`❌ [Statement] Método ${propertyKey} com erro`, error);
+                    throw error;
+                });
+            }
+            Logger.success(`✅ [Statement] Método ${propertyKey} completado`);
+            return result;
+        }
+        catch (error) {
+            Logger.error(`❌ [Statement] Método ${propertyKey} com erro`, error);
+            throw error;
+        }
+    };
+    return descriptor;
+}