@silasfmartins/testhub 1.0.0

package/dist/scripts/postinstall.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/postinstall.js

@@ -0,0 +1,527 @@
+// @ts-nocheck
+import { ensureInstallationKeys } from '../src/security/KeysManager.js';
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+// ✅ ESM Compatibility
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * PostInstall do AutoCore - APENAS configuração, SEM BUILD
+ */
+console.log('AutoCore: Iniciando PostInstall (configuração apenas)...');
+// ✅ Caracteres zero-width para marcadores invisíveis (igual ao HoneypotManager)
+const PROTECTION_MARKERS = '\u200B\u200C\u200D\uFEFF';
+// ✅ Injetar marcadores invisíveis em arquivos críticos (EXCETO JSON)
+function injectProtectionMarkers(filePath, content) {
+    // ❌ NUNCA adicionar marcadores invisíveis em arquivos JSON
+    if (filePath.endsWith('.json')) {
+        return content; // Retornar conteúdo sem marcadores para JSON
+    }
+    // Verificar se já tem marcadores
+    const hasMarkers = PROTECTION_MARKERS.split('').some((char) => content.includes(char));
+    if (hasMarkers) {
+        return content; // Já protegido
+    }
+    // Adicionar marcadores invisíveis no início do arquivo (apenas para não-JSON)
+    return PROTECTION_MARKERS + content;
+}
+// ✅ Proteger arquivos críticos do sistema
+async function protectCriticalFiles() {
+    const criticalFiles = ['package.json', 'tsconfig.json', '.gitignore'];
+    for (const fileName of criticalFiles) {
+        try {
+            const filePath = path.join(process.cwd(), fileName);
+            if (existsSync(filePath)) {
+                const content = readFileSync(filePath, 'utf8');
+                const protectedContent = injectProtectionMarkers(filePath, content);
+                if (protectedContent !== content) {
+                    writeFileSync(filePath, protectedContent, 'utf8');
+                    console.log(`AutoCore: Marcadores de proteção adicionados a ${fileName}`);
+                }
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.warn(`AutoCore: Erro ao proteger ${fileName}:`, errorMessage);
+        }
+    }
+}
+// ✅ Configurar segurança SEM build
+async function setupSecurity() {
+    try {
+        // Apenas em ambiente de produção/build explícito
+        if (process.env.AUTOCORE_BUILD_SECURITY === 'true') {
+            console.log('AutoCore: Modo build detectado - configurando segurança...');
+            const keys = ensureInstallationKeys();
+            console.log(`AutoCore: Chaves geradas - ID: ${keys.installId.substring(0, 8)}...`);
+        }
+        else {
+            console.log('AutoCore: Configuração básica aplicada (sem build)');
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn('AutoCore: Aviso na configuração:', errorMessage);
+    }
+}
+// ✅ Atualizar .gitignore
+async function updateGitignoreWithProtections() {
+    try {
+        const cwd = process.cwd();
+        const gitignorePath = path.join(cwd, '.gitignore');
+        const protectionEntries = [
+            '',
+            '# AutoCore Protection (gerado automaticamente)',
+            '.generated/',
+            '.rbqa/',
+            '.helpers/',
+            '.automation/',
+            '.rbqa-*',
+            '.test-automation.*',
+            '.appium-helpers.*',
+            '*.rbqa.json',
+            '*.protection.key',
+            '.install.lock',
+            '.build.lock',
+        ];
+        if (existsSync(gitignorePath)) {
+            const currentContent = readFileSync(gitignorePath, 'utf8');
+            if (!currentContent.includes('# AutoCore Protection')) {
+                const newContent = currentContent + '\n' + protectionEntries.join('\n') + '\n';
+                writeFileSync(gitignorePath, newContent);
+                console.log('AutoCore: .gitignore atualizado');
+            }
+        }
+        else {
+            writeFileSync(gitignorePath, protectionEntries.join('\n') + '\n');
+            console.log('AutoCore: .gitignore criado');
+        }
+    }
+    catch {
+        // Falha silenciosa
+    }
+}
+// 🌐 Registry privado do Azure Artifacts (único registry para pacotes @rbqa)
+const AZURE_REGISTRY = 'https://pkgs.dev.azure.com/telefonica-vivo-brasil/_packaging/DevOps/npm/registry/';
+// 🔧 Executa comando npm com environment configurado
+function execNpmSync(args, timeoutMs = 30000) {
+    try {
+        const result = spawnSync('npm', args, {
+            stdio: 'pipe',
+            shell: true,
+            windowsHide: true,
+            timeout: timeoutMs,
+            env: { ...process.env, npm_config_registry: AZURE_REGISTRY }
+        });
+        return {
+            stdout: result.stdout?.toString() || '',
+            status: result.status
+        };
+    }
+    catch {
+        return { stdout: '', status: null };
+    }
+}
+// ✅ Obter versão instalada globalmente do pacote MCP
+function getInstalledMcpVersion() {
+    try {
+        const result = execNpmSync(['list', '-g', '@silasfmartins/testhub-orchestrator-mcp', '--depth=0', '--json']);
+        if (result.status === 0) {
+            const data = JSON.parse(result.stdout);
+            return data.dependencies?.['@silasfmartins/testhub-orchestrator-mcp']?.version || null;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+// ✅ Verificar acesso ao registry e obter última versão do MCP
+function checkRegistryAndGetLatestVersion() {
+    try {
+        const result = execNpmSync(['view', '@silasfmartins/testhub-orchestrator-mcp', 'version', `--registry=${AZURE_REGISTRY}`], 30000);
+        if (result.status === 0 && result.stdout.trim()) {
+            return result.stdout.trim();
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+// ✅ Verificar se o pacote @silasfmartins/testhub-orchestrator-mcp está instalado globalmente
+function checkGlobalMcpPackage() {
+    const result = execNpmSync(['list', '-g', '@silasfmartins/testhub-orchestrator-mcp', '--depth=0']);
+    return result.status === 0 && result.stdout.includes('@silasfmartins/testhub-orchestrator-mcp');
+}
+// ✅ Instalar ou atualizar pacote MCP globalmente
+// 🎯 COMPORTAMENTO:
+// - Se já está na última versão: NÃO reinstala
+// - Se versão antiga: atualiza automaticamente  
+// - Se não instalado: instala globalmente
+// - Se offline: usa versão local existente
+function installOrUpdateMcpPackage() {
+    console.log('AutoCore: ======================================================');
+    console.log('AutoCore: MCP - Verificando instalação global');
+    console.log('AutoCore: ======================================================');
+    const installedVersion = getInstalledMcpVersion();
+    if (installedVersion) {
+        console.log(`AutoCore: Versão global instalada: ${installedVersion}`);
+    }
+    else {
+        console.log('AutoCore: MCP não encontrado globalmente');
+    }
+    // Verificar acesso ao registry e obter última versão
+    console.log('AutoCore: Verificando registry Azure Artifacts...');
+    const latestVersion = checkRegistryAndGetLatestVersion();
+    if (!latestVersion) {
+        console.log('AutoCore: Sem acesso ao registry Azure Artifacts (modo offline)');
+        if (installedVersion) {
+            console.log(`AutoCore: Usando versão global existente: ${installedVersion} ✓`);
+            return { installed: true, updated: false, version: installedVersion };
+        }
+        console.log('AutoCore: MCP será executado via npx quando necessário');
+        return { installed: false, updated: false, version: null };
+    }
+    console.log(`AutoCore: Última versão disponível: ${latestVersion}`);
+    // Comparar versões se já instalado
+    if (installedVersion) {
+        if (installedVersion === latestVersion) {
+            console.log('AutoCore: MCP já está na última versão global - nada a fazer! ✓');
+            return { installed: true, updated: false, version: installedVersion };
+        }
+        // Versão desatualizada - atualizar
+        console.log(`AutoCore: Atualizando MCP: ${installedVersion} → ${latestVersion}`);
+    }
+    else {
+        console.log('AutoCore: Instalando MCP globalmente...');
+    }
+    // Executar instalação/atualização
+    const installResult = execNpmSync(['install', '-g', `@silasfmartins/testhub-orchestrator-mcp@${latestVersion}`, `--registry=${AZURE_REGISTRY}`], 60000);
+    if (installResult.status === 0) {
+        const newVersion = getInstalledMcpVersion();
+        if (installedVersion) {
+            console.log(`AutoCore: MCP atualizado: ${installedVersion} → ${newVersion || latestVersion} ✓`);
+        }
+        else {
+            console.log(`AutoCore: MCP instalado globalmente (v${newVersion || latestVersion}) ✓`);
+        }
+        console.log('AutoCore: Disponível para todos os projetos da máquina');
+        return { installed: true, updated: !!installedVersion, version: newVersion || latestVersion };
+    }
+    console.warn('AutoCore: Falha ao instalar/atualizar MCP');
+    if (installedVersion) {
+        console.log(`AutoCore: Usando versão global existente: ${installedVersion}`);
+        return { installed: true, updated: false, version: installedVersion };
+    }
+    console.log('AutoCore: MCP será executado via npx');
+    return { installed: false, updated: false, version: null };
+}
+// ✅ Extrair user_hash de uma URL existente
+function extractUserHash(url) {
+    const match = url.match(/user_hash=([a-zA-Z0-9]+)/);
+    return match ? match[1] : '';
+}
+// ✅ Copiar copilot-instructions.md para .github/ do projeto consumidor
+async function copyCopilotInstructions() {
+    try {
+        const cwd = process.cwd();
+        // Se estiver em dist/scripts, subir dois níveis; senão, um nível
+        const isDist = __dirname.includes('dist');
+        const levelsUp = isDist ? '../..' : '..';
+        const sourceFile = path.join(__dirname, levelsUp, '.github', 'copilot-instructions.md');
+        const targetDir = path.join(cwd, '.github');
+        const targetFile = path.join(targetDir, 'copilot-instructions.md');
+        // Verificar se o arquivo fonte existe no pacote
+        if (!existsSync(sourceFile)) {
+            console.log('AutoCore: copilot-instructions.md não encontrado no pacote');
+            console.log(`   Caminho: ${sourceFile}`);
+            return;
+        }
+        // Criar a pasta .github se não existir
+        if (!existsSync(targetDir)) {
+            console.log('AutoCore: Criando a pasta .github...');
+            mkdirSync(targetDir, { recursive: true });
+        }
+        // Copiar o arquivo
+        const content = readFileSync(sourceFile, 'utf8');
+        writeFileSync(targetFile, content, 'utf8');
+        console.log('AutoCore: copilot-instructions.md copiado para .github/ ✓');
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn('AutoCore: Erro ao copiar copilot-instructions.md:', errorMessage);
+    }
+}
+// ✅ Criar ou validar o arquivo .vscode/mcp.json (preservando hashes existentes)
+async function ensureMcpConfig() {
+    try {
+        const vscodeDir = path.join(process.cwd(), '.vscode');
+        const mcpFile = path.join(vscodeDir, 'mcp.json');
+        // Criar a pasta .vscode se não existir
+        if (!existsSync(vscodeDir)) {
+            console.log('AutoCore: Criando a pasta .vscode...');
+            mkdirSync(vscodeDir, { recursive: true });
+        }
+        // Instalar/atualizar o MCP apenas em CI (ex.: agentes Azure Pipelines).
+        // Em máquinas dos usuários, não instalar globalmente — usar `npx` quando necessário.
+        const isCiEnv = process.env.AZURE_PIPELINES === 'true' ||
+            process.env.CI === 'true' ||
+            !!process.env.BUILD_BUILDID ||
+            !!process.env.SYSTEM_TEAMFOUNDATIONSERVERURI;
+        const isWindows = process.platform === 'win32';
+        // Instalar/atualizar o MCP apenas em máquinas Windows locais (desenvolvedores).
+        // NÃO instalar em CI (ex.: Azure Pipelines Linux agents).
+        if (!isCiEnv && isWindows) {
+            console.log('AutoCore: Ambiente Windows local detectado - verificando/instalando MCP globalmente');
+            try {
+                installOrUpdateMcpPackage();
+            }
+            catch (e) {
+                console.warn('AutoCore: Falha ao instalar/atualizar MCP:', e);
+                console.log('AutoCore: O MCP será executado via npx quando necessário');
+            }
+        }
+        else if (isCiEnv) {
+            console.log('AutoCore: Ambiente CI detectado - ignorando instalação global do MCP (use npx)');
+        }
+        else {
+            console.log('AutoCore: Ignorando instalação/atualização global do MCP (use npx quando necessário)');
+        }
+        // Configuração padrão
+        const defaultConfig = {
+            servers: {
+                'mcp-estimative': {
+                    url: 'http://brtlvlty0559pl:8080/estimative/mcp?user_hash=',
+                    type: 'http',
+                },
+                'autocore-orchestrator': {
+                    command: 'npx',
+                    args: ['-y', '@silasfmartins/testhub-orchestrator-mcp'],
+                    env: {
+                        HUB_BACKEND_URL: 'http://brtlvlty0559pl:3333',
+                    },
+                    type: 'stdio',
+                },
+            },
+            inputs: [],
+        };
+        if (existsSync(mcpFile)) {
+            // Arquivo existe - preservar hashes do usuário
+            const currentContent = JSON.parse(readFileSync(mcpFile, 'utf8'));
+            // Preservar hash do mcp-estimative
+            let existingEstimativeHash = '';
+            if (currentContent.servers?.['mcp-estimative']?.url) {
+                existingEstimativeHash = extractUserHash(currentContent.servers['mcp-estimative'].url);
+            }
+            // Construir configuração atualizada preservando hashes
+            const updatedConfig = {
+                servers: {
+                    'mcp-estimative': {
+                        url: `http://brtlvlty0559pl:8080/estimative/mcp?user_hash=${existingEstimativeHash}`,
+                        type: 'http',
+                    },
+                    'autocore-orchestrator': {
+                        command: 'npx',
+                        args: ['-y', '@silasfmartins/testhub-orchestrator-mcp'],
+                        env: {
+                            HUB_BACKEND_URL: 'http://brtlvlty0559pl:3333',
+                        },
+                        type: 'stdio',
+                    },
+                },
+                inputs: currentContent.inputs || [],
+            };
+            writeFileSync(mcpFile, JSON.stringify(updatedConfig, null, 2));
+            if (existingEstimativeHash) {
+                console.log('AutoCore: Arquivo mcp.json atualizado (hash mcp-estimative preservado) ✓');
+            }
+            else {
+                console.log('AutoCore: Arquivo mcp.json atualizado ✓');
+            }
+        }
+        else {
+            // Criar novo arquivo com configuração padrão
+            writeFileSync(mcpFile, JSON.stringify(defaultConfig, null, 2));
+            console.log('AutoCore: Arquivo mcp.json criado ✓');
+        }
+        // Mensagem sobre configuração do user_hash
+        console.log('');
+        console.log('AutoCore: 🔑 Para usar o MCP, configure seu user_hash:');
+        console.log('AutoCore:    - mcp-estimative: Adicione seu hash na URL em .vscode/mcp.json');
+        console.log('AutoCore:    - autocore-orchestrator: No Windows, defina a variável de ambiente');
+        console.log('AutoCore:      do usuário HUB_MCP_USER_HASH com seu hash e reinicie o VS Code.');
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn('AutoCore: Erro ao configurar mcp.json:', errorMessage);
+    }
+}
+// ✅ Verificar se o Playwright está instalado (para projetos Frontend/Scenarios)
+async function ensurePlaywrightInstalled() {
+    try {
+        const cwd = process.cwd();
+        const pkgFile = path.join(cwd, 'package.json');
+        if (!existsSync(pkgFile))
+            return;
+        const content = readFileSync(pkgFile, 'utf8');
+        const pkg = JSON.parse(content);
+        // Verificar se é projeto Frontend ou Scenarios (tem @playwright/test nas dependências)
+        const hasPlaywright = pkg.dependencies?.['@playwright/test'] ||
+            pkg.devDependencies?.['@playwright/test'] ||
+            pkg.dependencies?.['@silasfmartins/testhub'] ||
+            pkg.devDependencies?.['@silasfmartins/testhub'];
+        // Determinar se devemos instalar browsers Playwright
+        // Prioridade 1: variável de ambiente PROJECT_TYPE (WEB/FRONTEND or SCENARIOS)
+        const projectTypeEnv = (process.env.PROJECT_TYPE || process.env.PROJECTTYPE || '').toUpperCase();
+        const isProjectTypeWebOrScenarios = projectTypeEnv === 'WEB' || projectTypeEnv === 'FRONTEND' || projectTypeEnv === 'SCENARIOS';
+        // Fallback: Verificar se tem scripts de frontend/scenarios (indica que precisa de browsers)
+        const hasFrontendScripts = !!pkg.scripts?.['test:preprod']?.includes('playwright test') ||
+            !!pkg.scripts?.['ui:preprod'] ||
+            !!pkg.scripts?.['codegen:preprod'];
+        // Só instalar se o projeto for Web/Frontend ou Scenarios (por env ou por scripts indicativos)
+        if (!hasPlaywright || !(isProjectTypeWebOrScenarios || hasFrontendScripts))
+            return;
+        // Verificar se os browsers já estão instalados em vários locais comuns
+        function browsersPresent(dir) {
+            try {
+                if (!existsSync(dir))
+                    return false;
+                const stat = require('node:fs').statSync(dir);
+                return !!stat;
+            }
+            catch {
+                return false;
+            }
+        }
+        const possiblePaths = [
+            path.join(cwd, 'node_modules', '.cache', 'ms-playwright'),
+            path.join(cwd, 'node_modules', 'playwright-core', '.local-browsers'),
+            path.join(cwd, 'node_modules', 'playwright', '.local-browsers'),
+            path.join(cwd, 'node_modules', '.playwright'),
+            path.join(cwd, 'node_modules', 'playwright-core', '.playwright'),
+        ];
+        const browsersInstalled = possiblePaths.some(browsersPresent);
+        if (browsersInstalled) {
+            console.log('AutoCore: Browsers Playwright já instalados ✓');
+            return;
+        }
+        // Tentar instalar browsers Playwright com tentativas e flags úteis
+        console.log('AutoCore: Browsers Playwright não encontrados. Tentando instalar...');
+        const installCommands = [
+            { args: ['playwright', 'install', '--with-deps'], desc: 'install --with-deps' },
+            { args: ['playwright', 'install'], desc: 'install' },
+            { args: ['playwright', 'install', '--force'], desc: 'install --force' },
+        ];
+        let installed = false;
+        for (const cmd of installCommands) {
+            try {
+                console.log(`AutoCore: Executando: npx ${cmd.args.join(' ')} (cwd=${cwd})`);
+                const result = spawnSync('npx', cmd.args, {
+                    stdio: 'pipe',
+                    shell: true,
+                    windowsHide: true,
+                    cwd,
+                    timeout: 300000, // 5 minutos
+                });
+                if (result.status === 0) {
+                    // Rechecar se os browsers foram instalados
+                    const nowInstalled = possiblePaths.some(browsersPresent);
+                    if (nowInstalled) {
+                        console.log(`AutoCore: Browsers Playwright instalados com sucesso (${cmd.desc}) ✓`);
+                        installed = true;
+                        break;
+                    }
+                    else {
+                        console.log(`AutoCore: Comando '${cmd.desc}' finalizou sem erro, mas browsers não foram detectados. Tentando próxima opção...`);
+                    }
+                }
+                else {
+                    console.warn(`AutoCore: Comando 'npx ${cmd.args.join(' ')}' falhou com código ${result.status}`);
+                }
+            }
+            catch (err) {
+                console.warn(`AutoCore: Erro ao executar 'npx ${cmd.args.join(' ')}': ${err}`);
+            }
+        }
+        if (!installed) {
+            console.warn('AutoCore: Falha ao instalar browsers Playwright automaticamente');
+            console.log('AutoCore: Instrução: execute manualmente: npx playwright install');
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn('AutoCore: Erro ao verificar Playwright:', errorMessage);
+    }
+}
+// ✅ Função principal async
+async function main() {
+    // ✅ PRIMEIRO: Proteger arquivos críticos
+    await protectCriticalFiles();
+    try {
+        // ✅ Configurar scripts de proteção (SEM executar)
+        const cwd = process.cwd();
+        const pkgFile = path.join(cwd, 'package.json');
+        if (existsSync(pkgFile)) {
+            const content = readFileSync(pkgFile, 'utf8');
+            const pkg = JSON.parse(content);
+            pkg.scripts ||= {};
+            const loaderFlag = '--loader ./node_modules/@silasfmartins/testhub/protect-loader.mjs';
+            const ensurePre = (key) => {
+                const pre = `pre${key}`;
+                const current = pkg.scripts[pre];
+                if (current?.includes(loaderFlag))
+                    return;
+                const exportCmd = process.platform === 'win32'
+                    ? `set NODE_OPTIONS=%NODE_OPTIONS% ${loaderFlag}`
+                    : `export NODE_OPTIONS="$NODE_OPTIONS ${loaderFlag}"`;
+                pkg.scripts[pre] = current ? `${exportCmd} && ${current}` : exportCmd;
+            };
+            ['test', 'build'].forEach(ensurePre);
+            // Atualizar .gitignore
+            await updateGitignoreWithProtections();
+            // ✅ Salvar com marcadores de proteção
+            const newContent = JSON.stringify(pkg, null, 2);
+            const protectedContent = injectProtectionMarkers(pkgFile, newContent);
+            writeFileSync(pkgFile, protectedContent);
+            console.log('AutoCore: Scripts de proteção configurados');
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn('AutoCore: Erro na configuração de scripts:', errorMessage);
+    }
+    // ✅ Verificar smart-override usando binário
+    try {
+        const result = spawnSync('npx', ['autocore-sync', 'check', '--quiet'], {
+            stdio: 'pipe',
+            shell: true,
+            windowsHide: true,
+        });
+        if (result.status === 0) {
+            console.log('AutoCore: Smart-override verificado');
+        }
+    }
+    catch (e) {
+        // Ignorar erro se binário não existir ainda
+    }
+    // ✅ Configurar segurança (SEM BUILD)
+    await setupSecurity();
+    // ✅ Criar ou validar o arquivo .vscode/mcp.json
+    await ensureMcpConfig();
+    // ✅ Copiar copilot-instructions.md para .github/
+    await copyCopilotInstructions();
+    // ✅ NOVO: Verificar e instalar Playwright para projetos Frontend/Scenarios
+    await ensurePlaywrightInstalled();
+    // ✅ FINAL: Re-proteger após modificações
+    await protectCriticalFiles();
+    console.log('AutoCore: PostInstall concluído SEM build!');
+}
+// ✅ Executar função principal (SEM BUILD)
+main().catch((error) => {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.warn('AutoCore: PostInstall falhou:', errorMessage);
+    // Não falhar o processo - apenas avisar
+});

package/dist/scripts/robust-build.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * 🔧 Build Robusto para Projetos Consumidores
+ * Fallback para quando tsx/esbuild falha em ambientes Linux
+ */
+declare function robustBuild(): void;
+export { robustBuild };

package/dist/scripts/robust-build.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+// @ts-nocheck
+/**
+ * 🔧 Build Robusto para Projetos Consumidores
+ * Fallback para quando tsx/esbuild falha em ambientes Linux
+ */
+import { execSync } from 'child_process';
+import { existsSync, rmSync, writeFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+// ES module compatibility
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function log(message, type = 'info') {
+    const colors = {
+        info: '\x1b[36m', // Cyan
+        warn: '\x1b[33m', // Yellow
+        error: '\x1b[31m', // Red
+        reset: '\x1b[0m',
+    };
+    const prefix = {
+        info: '🔧',
+        warn: '⚠️',
+        error: '❌',
+    };
+    console.log(`${colors[type]}${prefix[type]} ${message}${colors.reset}`);
+}
+function robustBuild() {
+    log('Iniciando build robusto (fallback para esbuild)');
+    try {
+        // 1. Limpar dist
+        if (existsSync('dist')) {
+            log('Limpando pasta dist...');
+            rmSync('dist', { recursive: true, force: true });
+        }
+        // 2. Tentar gerar index via TypeScript diretamente
+        log('Gerando index.ts...');
+        try {
+            execSync('npx tsx ./scripts/generate-index.ts', {
+                stdio: 'inherit',
+                timeout: 30_000, // 30 segundos timeout
+            });
+        }
+        catch (error) {
+            log('Erro ao gerar index via tsx, tentando fallback...', 'warn');
+            // Fallback: usar Node.js puro para gerar index básico
+            const basicIndex = `// Index gerado automaticamente (fallback)
+export * from './dist/index.js'
+`;
+            writeFileSync('index.ts', basicIndex);
+            log('Index básico gerado via fallback');
+        }
+        // 3. Compilar TypeScript
+        log('Compilando TypeScript...');
+        execSync('npx tsc', {
+            stdio: 'inherit',
+            timeout: 60_000, // 60 segundos timeout
+        });
+        // 4. Limpar index.ts temporário
+        if (existsSync('index.ts')) {
+            rmSync('index.ts');
+            log('index.ts temporário removido');
+        }
+        // 5. Tentar registrar override (opcional)
+        log('Tentando registrar smart override...');
+        try {
+            execSync('npx tsx ./scripts/smart-override.ts register', {
+                stdio: 'inherit',
+                timeout: 15_000, // 15 segundos timeout
+            });
+            log('Smart override registrado com sucesso');
+        }
+        catch (error) {
+            log('Smart override falhou, mas build continua', 'warn');
+        }
+        log('✅ Build robusto concluído com sucesso!', 'info');
+    }
+    catch (error) {
+        log(`Build robusto falhou: ${error}`, 'error');
+        process.exit(1);
+    }
+}
+// Executar apenas se chamado diretamente
+const isMainModule = process.argv[1]?.endsWith('robust-build.ts');
+if (isMainModule) {
+    robustBuild();
+}
+export { robustBuild };

package/dist/scripts/setup-local-packages.d.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+declare class LocalPackagesSetup {
+    private projectRoot;
+    private packageJsonPath;
+    constructor();
+    /**
+     * 🚀 Executa setup completo de pacotes locais
+     */
+    run(): Promise<void>;
+    /**
+     * Verifica se AutoCore está instalado
+     */
+    private isAutocoreInstalled;
+    /**
+     * Detecta pacotes locais disponíveis
+     */
+    private promptForLocalPackages;
+    /**
+     * Atualiza package.json com file: paths
+     */
+    private updatePackageJson;
+    /**
+     * Imprime resumo final
+     */
+    private printSummary;
+    /**
+     * Reverte para usar pacotes do Azure
+     */
+    revertToAzure(): Promise<void>;
+}
+export { LocalPackagesSetup };