@devquest/cli 1.0.0

package/dist/commands/auth.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authCommand = void 0;
+exports.getToken = getToken;
+const commander_1 = require("commander");
+const http_1 = __importDefault(require("http"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.devquest');
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
+exports.authCommand = new commander_1.Command('auth')
+    .description('Autenticação via navegador no CLI')
+    .action(async () => {
+    const PORT = 3838;
+    const DASHBOARD_URL = process.env.DEVQUEST_URL || 'http://localhost:3000';
+    console.log(chalk_1.default.blue('⏳ Iniciando autenticação...'));
+    console.log(chalk_1.default.gray(`Abriremos o seu navegador em breve para aprovação.`));
+    const server = http_1.default.createServer((req, res) => {
+        // Cors para permitir o front-end fazer o fetch na API localhost:3838
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        const url = new URL(req.url || '/', `http://localhost:${PORT}`);
+        if (url.pathname === '/callback') {
+            const token = url.searchParams.get('token');
+            if (token) {
+                try {
+                    if (!fs_1.default.existsSync(CONFIG_DIR)) {
+                        fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true });
+                    }
+                    const config = fs_1.default.existsSync(CONFIG_FILE) ? JSON.parse(fs_1.default.readFileSync(CONFIG_FILE, 'utf-8')) : {};
+                    config.token = token;
+                    fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ success: true }));
+                    console.log(chalk_1.default.green('\n✅ Autenticado com sucesso! Seu token foi guardado localmente protegido.'));
+                    console.log(chalk_1.default.yellow('Agora você pode clonar e submeter desafios!'));
+                    console.log(chalk_1.default.gray('Use: devquest clone <id-do-curso>'));
+                    server.close();
+                    process.exit(0);
+                }
+                catch (err) {
+                    console.error('\nErro ao salvar token de forma segura:', err);
+                    res.writeHead(500);
+                    res.end(JSON.stringify({ error: 'Erro interno' }));
+                    server.close();
+                    process.exit(1);
+                }
+            }
+            else {
+                res.writeHead(400);
+                res.end(JSON.stringify({ error: 'Token ausente' }));
+            }
+        }
+        else {
+            res.writeHead(404);
+            res.end('Not found');
+        }
+    });
+    server.listen(PORT, () => {
+        const cliAuthPath = encodeURIComponent(`/dashboard/cli-auth?port=${PORT}`);
+        const authUrl = `${DASHBOARD_URL}/login?callbackUrl=${cliAuthPath}`;
+        (0, child_process_1.exec)(`open "${authUrl}"`, (err) => {
+            if (err) {
+                console.log(chalk_1.default.yellow(`Não foi possível abrir o navegador automaticamente.`));
+                console.log(`Por favor, acesse manualmente: ${chalk_1.default.cyan(authUrl)}`);
+            }
+        });
+    });
+    // Timeout of 5 minutes
+    setTimeout(() => {
+        console.log(chalk_1.default.red('\n❌ Tempo de autenticação esgotado.'));
+        server.close();
+        process.exit(1);
+    }, 5 * 60 * 1000);
+});
+async function getToken() {
+    if (!fs_1.default.existsSync(CONFIG_FILE))
+        return null;
+    try {
+        const config = JSON.parse(fs_1.default.readFileSync(CONFIG_FILE, 'utf-8'));
+        return config.token || null;
+    }
+    catch (e) {
+        return null;
+    }
+}

package/dist/commands/clone.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneCommand = void 0;
+const commander_1 = require("commander");
+const simple_git_1 = __importDefault(require("simple-git"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const axios_1 = __importDefault(require("axios"));
+const auth_1 = require("./auth");
+const API_BASE = process.env.DEVQUEST_API_URL || 'http://localhost:8787';
+exports.cloneCommand = new commander_1.Command('clone')
+    .argument('<id>', 'ID do desafio (ex: build-your-own-redis)')
+    .description('Clona o repositório boilerplate personalizado configurando o remoto')
+    .action(async (id) => {
+    const token = await (0, auth_1.getToken)();
+    if (!token) {
+        console.log(chalk_1.default.red('Você não está autenticado. Use `devquest auth`.'));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.blue(`🚀 Iniciando o desafio: ${id}`));
+    try {
+        // 1. Requisitar a URL do repositório para este usuário/desafio do Backend
+        // Isso criaria um "provisionamento" do repositório no backend
+        const response = await axios_1.default.post(`${API_BASE}/challenges/${id}/clone`, {}, {
+            headers: { Authorization: `Bearer ${token}` }
+        });
+        const { cloneUrl, targetDir } = response.data;
+        const destPath = path_1.default.resolve(process.cwd(), targetDir || id);
+        if (fs_1.default.existsSync(destPath)) {
+            console.log(chalk_1.default.red(`O diretório ${destPath} já existe.`));
+            process.exit(1);
+        }
+        let finalUrl = cloneUrl;
+        // Trata casos locais (para dev) onde o banco retorna 'file://../../templates/xyz'
+        if (cloneUrl.startsWith('file://../../templates/')) {
+            const repoRoot = path_1.default.resolve(__dirname, '../../../..'); // de dist/commands -> root turborepo
+            finalUrl = `file://${path_1.default.join(repoRoot, 'templates', targetDir || id)}`;
+        }
+        console.log(chalk_1.default.gray(`Clonando de ${finalUrl} para ${destPath}...`));
+        const git = (0, simple_git_1.default)();
+        await git.clone(finalUrl, destPath);
+        // 2. O boilerplate baixado deverá ter o origin já devidamente setado
+        // O remote será algo como http://git.plataforma.com/hash.git (servidor git interno)
+        console.log(chalk_1.default.green(`✅ Desafio clonado com sucesso em ./${targetDir || id}`));
+        console.log(chalk_1.default.yellow(`\nPróximos passos:`));
+        console.log(`  cd ${targetDir || id}`);
+        console.log(`  Leia o README.md e comece a desenvolver.`);
+        console.log(`  Para submeter: devquest submit`);
+    }
+    catch (err) {
+        console.error(chalk_1.default.red('\n❌ Falha ao clonar desafio.'));
+        if (err.response) {
+            console.error(chalk_1.default.red(`Erro da API: ${err.response.data.message || err.response.statusText}`));
+        }
+        else {
+            console.error(chalk_1.default.red(err.message));
+        }
+    }
+});

package/dist/commands/submit.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitCommand = void 0;
+const commander_1 = require("commander");
+const simple_git_1 = __importDefault(require("simple-git"));
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const axios_1 = __importDefault(require("axios"));
+const auth_1 = require("./auth");
+const API_BASE = process.env.DEVQUEST_API_URL || 'http://localhost:8787';
+const SSE_BASE = process.env.DEVQUEST_SSE_URL || 'http://localhost:8787/challenges/sse';
+exports.submitCommand = new commander_1.Command('submit')
+    .description('Envia seu código para os testes automatizados da plataforma')
+    .action(async () => {
+    const token = await (0, auth_1.getToken)();
+    if (!token) {
+        console.log(chalk_1.default.red('Você não está autenticado. Use `devquest auth`.'));
+        process.exit(1);
+    }
+    const currentDir = process.cwd();
+    if (!fs_1.default.existsSync(path_1.default.join(currentDir, '.git'))) {
+        console.log(chalk_1.default.red('Não encontrei um repositório git no diretório atual. Execute esse comando na raiz do desafio.'));
+        process.exit(1);
+    }
+    const git = (0, simple_git_1.default)(currentDir);
+    const packageJsonPath = path_1.default.join(currentDir, 'package.json');
+    let challengeId = 'unknown';
+    if (fs_1.default.existsSync(packageJsonPath)) {
+        try {
+            const pkg = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+            challengeId = pkg.name;
+        }
+        catch (e) { }
+    }
+    let stageOrder = 1;
+    try {
+        const progRes = await axios_1.default.get(`${API_BASE}/challenges/${challengeId}/progress`, {
+            headers: { Authorization: `Bearer ${token}` }
+        });
+        if (progRes.data.stageOrder) {
+            stageOrder = progRes.data.stageOrder;
+        }
+    }
+    catch (e) {
+        console.log(chalk_1.default.yellow('⚠️ Não foi possível determinar o estágio na API. Assumindo Estágio 1.'));
+    }
+    console.log(chalk_1.default.blue(`\\n📌 Você está no Estágio ${stageOrder} deste desafio.`));
+    const { DevQuestTester } = require('../utils/tester');
+    const tester = new DevQuestTester(currentDir, challengeId, stageOrder);
+    const passed = await tester.execute();
+    if (!passed) {
+        console.log(chalk_1.default.red('\n🚫 Execução interrompida pela falha dos testes rigorosos de submissão do Estágio.'));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.green('\n✅ Integração aprovada! Empacotando build processada...'));
+    try {
+        // 1. Commit and push automated
+        console.log(chalk_1.default.gray('Preparando entrega gerando commit automático...'));
+        await git.add('.');
+        const status = await git.status();
+        if (status.staged.length > 0 || status.not_added.length > 0) {
+            await git.commit('Feat: Submissão via devquest CLI');
+        }
+        console.log(chalk_1.default.gray('Conectando ao Git interno e enviando código...'));
+        // Assumindo que o "origin" foi configurado no clone com o remoto da plataforma
+        try {
+            await git.push('origin', 'main');
+        }
+        catch (pushErr) {
+            const remotes = await git.getRemotes(true);
+            const originUrl = remotes.find(r => r.name === 'origin')?.refs.push || '';
+            if (originUrl.startsWith('file://')) {
+                // Ignora erros de push se origin for um local file (ambiente dev/mock)
+                console.log(chalk_1.default.yellow('⚠️  Aviso Modulação Local: Push nativo do git ignorado pois o remote é apenas uma pasta file:// do Template local. Submetendo o payload diretamente...'));
+            }
+            else {
+                throw pushErr;
+            }
+        }
+        console.log(chalk_1.default.green('🚀 Código enviado! Conectando à Sandbox para log em tempo real...'));
+        // 2. Conexão WebSockets para logs da MicroVM Firecracker
+        startStreamingLogs(token, currentDir, challengeId, stageOrder);
+    }
+    catch (err) {
+        console.error(chalk_1.default.red('\n❌ Falha ao enviar a submissão.'));
+        console.error(err.message);
+    }
+});
+async function startStreamingLogs(token, challengeDir, challengeId, stageOrder) {
+    const url = `${SSE_BASE}?token=${encodeURIComponent(token)}&challengeId=${encodeURIComponent(challengeId)}&stageOrder=${stageOrder}`;
+    console.log(chalk_1.default.cyan('📡 Conectando à Sandbox segurizada (MicroVM Firecracker)...'));
+    try {
+        const response = await fetch(url);
+        if (!response.body) {
+            console.error(chalk_1.default.red('Não foi possível obter os logs.'));
+            return;
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder('utf-8');
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            const chunk = decoder.decode(value, { stream: true });
+            const lines = chunk.split('\\n');
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    const dataStr = line.slice(6);
+                    try {
+                        const payload = JSON.parse(dataStr);
+                        switch (payload.type) {
+                            case 'INFO':
+                                console.log(chalk_1.default.blue(payload.message));
+                                break;
+                            case 'TEST_SUCCESS':
+                                console.log(chalk_1.default.green('✅ ' + payload.message));
+                                break;
+                            case 'TEST_FAILED':
+                                console.log(chalk_1.default.red('❌ ' + payload.message));
+                                break;
+                            case 'FINISHED':
+                                console.log(chalk_1.default.green.bold('\\n🎉 Parabéns! Você completou este estágio.'));
+                                process.exit(0);
+                            case 'ERROR':
+                                console.log(chalk_1.default.red.bold('\\n💥 Erro na execução: ' + payload.message));
+                                process.exit(1);
+                        }
+                    }
+                    catch (e) {
+                        // ignores bad json fragments
+                    }
+                }
+            }
+        }
+        console.log(chalk_1.default.gray('Conexão encerrada pelo servidor.'));
+    }
+    catch (err) {
+        console.error(chalk_1.default.red('Erro na escuta da MicroVM: ' + err.message));
+    }
+}

package/dist/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const auth_1 = require("./commands/auth");
+const clone_1 = require("./commands/clone");
+const submit_1 = require("./commands/submit");
+const program = new commander_1.Command();
+program
+    .name('devquest')
+    .description('DevQuest CLI - Construa seu próprio Redis, Docker, Git e mais')
+    .version('1.0.0');
+program.addCommand(auth_1.authCommand);
+program.addCommand(clone_1.cloneCommand);
+program.addCommand(submit_1.submitCommand);
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+    process.exit(0);
+}
+program.parse(process.argv);

package/dist/utils/tester.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevQuestTester = void 0;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+class DevQuestTester {
+    cwd;
+    challengeId;
+    stageOrder;
+    constructor(cwd, challengeId, stageOrder) {
+        this.cwd = cwd;
+        this.challengeId = challengeId;
+        this.stageOrder = stageOrder;
+    }
+    async execute() {
+        console.log(chalk_1.default.cyan(`\n[DevQuest Tester] Iniciando avaliação padrão (Integration Tests)...`));
+        console.log(chalk_1.default.gray(`[DevQuest Tester] Diretório alvo: ${this.cwd}`));
+        try {
+            console.log(chalk_1.default.gray(`[DevQuest Tester] Emitindo TypeScript (Compilação)...`));
+            (0, child_process_1.execSync)('npx tsc', { cwd: this.cwd, stdio: 'ignore' });
+        }
+        catch (e) {
+            console.log(chalk_1.default.red('\\n❌ Falha de Compilação! Os tipos do TypeScript ou sintaxe estão incorretos.'));
+            return false;
+        }
+        let success = false;
+        try {
+            // Dynamic import
+            const testSuite = require(`./tests/${this.challengeId}`);
+            success = await testSuite.runStage(this.stageOrder, this.cwd);
+        }
+        catch (e) {
+            if (e.code === 'MODULE_NOT_FOUND') {
+                console.log(chalk_1.default.yellow(`[DevQuest Tester] Nenhuma suite de testes rigorosa definida para ${this.challengeId} no estágio ${this.stageOrder}. Passando...`));
+                success = true;
+            }
+            else {
+                console.log(chalk_1.default.red(`[!] Erro fatal ao carregar a suite de testes: ${e.message}`));
+                success = false;
+            }
+        }
+        return success;
+    }
+}
+exports.DevQuestTester = DevQuestTester;

package/dist/utils/tests/build-your-own-ai-framework.js

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStage = runStage;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+function runStage(stageOrder, cwd) {
+    if (stageOrder === 1) {
+        console.log(chalk_1.default.blue(`[Stage 1: AI Framework] Verificando encapsulamento e requests para provider...`));
+        const testFilePath = path_1.default.join(cwd, '.eval-stage1.ts');
+        const code = `
+      let userApp: any;
+      try { userApp = require('./src/index'); } 
+      catch(e: any) { console.error('[!] Falha ao importar src/index.ts: ' + e.message); process.exit(1); }
+
+      function assert(condition: boolean, failMsg: string, expected?: any, got?: any) {
+         if (!condition) {
+            console.error('\\n❌ FALHA DE ASSERÇÃO');
+            console.error('📝 ' + failMsg);
+            if (expected !== undefined) console.error('🎯 Esperado : ' + String(expected));
+            if (got !== undefined)      console.error('💥 Recebido : ' + String(got));
+            console.error('');
+            process.exit(1);
+         }
+      }
+
+      const { callOpenAI } = userApp;
+      assert(typeof callOpenAI === 'function', 'A função callOpenAI não foi exportada no src/index.ts', 'function', typeof callOpenAI);
+
+      let fetchCallParams: any = null;
+      (global as any).fetch = async (url: string, options: any) => {
+        fetchCallParams = { url, options };
+        return { 
+           json: async () => ({
+             id: "chatcmpl-mock",
+             choices: [{ message: { content: "DevQuest LLM Response" } }]
+           }) 
+        } as any;
+      };
+
+      async function testSuite() {
+        try {
+          const prompt = 'Qual a capital do Brasil?';
+          const result = await callOpenAI(prompt);
+          
+          assert(fetchCallParams !== null, 'Seu código não utilizou a API global fetch()', 'Chamada em fetch(...)', 'Nenhum request de rede feito');
+          assert(fetchCallParams.url === 'https://api.openai.com/v1/chat/completions', 'A URL da OpenAI base está errada na sua request', 'https://api.openai.com/v1/chat/completions', fetchCallParams.url);
+          
+          const auth = fetchCallParams.options?.headers?.Authorization;
+          assert(!!auth, 'Header Authoziration Bearer <token> faltando nas configurações.', 'Bearer <Key>', auth);
+          
+          let parsedBody;
+          try { parsedBody = JSON.parse(fetchCallParams.options?.body || '{}'); } catch(e) {}
+          assert(parsedBody?.model === 'gpt-4o', 'O modelo no payload não é gpt-4o de acordo com as instruções', 'gpt-4o', parsedBody?.model);
+          
+          const messages = parsedBody?.messages || [];
+          const lastMsg = messages[messages.length - 1];
+          assert(lastMsg?.content === prompt, 'Você não repassou o prompt dinamicamente.', prompt, lastMsg?.content);
+          assert(result === 'DevQuest LLM Response', 'Retorno da função incorreto.', 'DevQuest LLM Response', result);
+
+          console.log('PASS');
+        } catch(e: any) {
+          console.error(e.message);
+          process.exit(1);
+        }
+      }
+      testSuite();
+    `;
+        try {
+            fs_1.default.writeFileSync(testFilePath, code);
+            const stdout = (0, child_process_1.execSync)('npx ts-node -T .eval-stage1.ts', { cwd, stdio: 'pipe' });
+            return stdout.toString().includes('PASS');
+        }
+        catch (err) {
+            console.log(chalk_1.default.red(err.stderr?.toString().trim() || err.stdout?.toString().trim() || err.message));
+            return false;
+        }
+        finally {
+            if (fs_1.default.existsSync(testFilePath))
+                fs_1.default.unlinkSync(testFilePath);
+        }
+    }
+    if (stageOrder === 2) {
+        console.log(chalk_1.default.blue(`[Stage 2: Provider Abstraction] Testando unificação de adaptadores...`));
+        const testFilePath = path_1.default.join(cwd, '.eval-stage2.ts');
+        const code = `
+      let userApp: any;
+      try { userApp = require('./src/index'); } 
+      catch(e: any) { console.error('[!] Erro de importação: ' + e.message); process.exit(1); }
+
+      function assert(condition: boolean, failMsg: string, expected?: any, got?: any) {
+         if (!condition) {
+            console.error('\\n❌ FALHA DE ASSERÇÃO');
+            console.error('📝 ' + failMsg);
+            if (expected !== undefined) console.error('🎯 Esperado : ' + String(expected));
+            if (got !== undefined)      console.error('💥 Recebido : ' + String(got));
+            console.error('');
+            process.exit(1);
+         }
+      }
+
+      const { openai } = userApp;
+      assert(typeof openai === 'function', 'Você deve exportar o helper openai() para criar o adaptador.', 'function', typeof openai);
+
+      async function testSuite() {
+        try {
+          const model = openai('gpt-4o');
+          assert(typeof model.doGenerate === 'function', 'O adaptador instanciado via openai() deve ter o método doGenerate().', 'function', typeof model.doGenerate);
+
+          console.log('PASS');
+        } catch(e: any) {
+          console.error(e.message);
+          process.exit(1);
+        }
+      }
+      testSuite();
+    `;
+        try {
+            fs_1.default.writeFileSync(testFilePath, code);
+            const stdout = (0, child_process_1.execSync)('npx ts-node -T .eval-stage2.ts', { cwd, stdio: 'pipe' });
+            return stdout.toString().includes('PASS');
+        }
+        catch (err) {
+            console.log(chalk_1.default.red(err.stderr?.toString().trim() || err.stdout?.toString().trim() || err.message));
+            return false;
+        }
+        finally {
+            if (fs_1.default.existsSync(testFilePath))
+                fs_1.default.unlinkSync(testFilePath);
+        }
+    }
+    if (stageOrder === 3) {
+        console.log(chalk_1.default.blue(`[Stage 3: Core generateText] Testando função unificada e normalização de retorno...`));
+        const testFilePath = path_1.default.join(cwd, '.eval-stage3.ts');
+        const code = `
+      let userApp: any;
+      try { userApp = require('./src/index'); } 
+      catch(e: any) { console.error('[!] Erro de importação: ' + e.message); process.exit(1); }
+
+      function assert(condition: boolean, failMsg: string, expected?: any, got?: any) {
+         if (!condition) {
+            console.error('\\n❌ FALHA DE ASSERÇÃO');
+            console.error('📝 ' + failMsg);
+            if (expected !== undefined) console.error('🎯 Esperado : ' + String(expected));
+            if (got !== undefined)      console.error('💥 Recebido : ' + String(got));
+            console.error('');
+            process.exit(1);
+         }
+      }
+
+      const { generateText, openai } = userApp;
+      assert(typeof generateText === 'function', 'Você não exportou a função unificada generateText()', 'function', typeof generateText);
+
+      let fetchCallParams: any = null;
+      (global as any).fetch = async (url: string, options: any) => {
+        fetchCallParams = { url, options };
+        return { 
+           json: async () => ({
+             choices: [{ message: { content: "Parsed Text" }, finish_reason: "stop" }],
+             usage: { prompt_tokens: 5, completion_tokens: 10 }
+           }) 
+        } as any;
+      };
+
+      async function testSuite() {
+        try {
+          const result = await generateText({
+            model: openai('gpt-4o'),
+            prompt: 'Explain the core function',
+            maxTokens: 50
+          });
+          
+          assert(result.text === 'Parsed Text', 'Propriedade \\'text\\' ausente ou incorreta no retorno de generateText.', 'Parsed Text', result.text);
+          assert(result.usage !== undefined, 'Propriedade \\'usage\\' ausente no retorno.', '{ promptTokens, ... }', result.usage);
+          assert(result.usage.promptTokens === 5, 'Mapping incorreto de usage.promptTokens (OpenAI snake_case -> CamelCase).', 5, result.usage.promptTokens);
+          assert(result.finishReason === 'stop', 'Propriedade \\'finishReason\\' ausente ou incorreta no retorno.', 'stop', result.finishReason);
+
+          console.log('PASS');
+        } catch(e: any) {
+          console.error(e.message);
+          process.exit(1);
+        }
+      }
+      testSuite();
+    `;
+        try {
+            fs_1.default.writeFileSync(testFilePath, code);
+            const stdout = (0, child_process_1.execSync)('npx ts-node -T .eval-stage3.ts', { cwd, stdio: 'pipe' });
+            return stdout.toString().includes('PASS');
+        }
+        catch (err) {
+            console.log(chalk_1.default.red(err.stderr?.toString().trim() || err.stdout?.toString().trim() || err.message));
+            return false;
+        }
+        finally {
+            if (fs_1.default.existsSync(testFilePath))
+                fs_1.default.unlinkSync(testFilePath);
+        }
+    }
+    console.log(chalk_1.default.yellow(`⚠️ Nenhuma suite implementada ainda para Stage ${stageOrder} deste desafio. Bypass (Aprovado).`));
+    return true;
+}

package/dist/utils/tests/build-your-own-compiler.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStage = runStage;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+function runStage(stageOrder, cwd) {
+    if (stageOrder === 1) {
+        console.log(chalk_1.default.blue(`[Stage 1: Compiler Lexer] Tokenizando subset de C...`));
+        const testFilePath = path_1.default.join(cwd, '.eval-stage1.ts');
+        const code = `
+      const { execSync } = require('child_process');
+      const fs = require('fs');
+      const path = require('path');
+
+      function assert(condition: boolean, failMsg: string, expected?: any, got?: any) {
+         if (!condition) {
+            console.error('\\n❌ FALHA DE ASSERÇÃO');
+            console.error('📝 ' + failMsg);
+            if (expected !== undefined) console.error('🎯 Esperado : ' + String(expected));
+            if (got !== undefined)      console.error('💥 Recebido : ' + String(got));
+            console.error('');
+            process.exit(1);
+         }
+      }
+
+      async function testSuite() {
+        try {
+          const testFile = path.join('${cwd}', 'main.c');
+          fs.writeFileSync(testFile, 'int main() { return 42; }');
+
+          console.log('-> Executando seu comando: node src/index.js tokenize main.c');
+          const output = execSync('npx ts-node src/index.ts tokenize main.c', { cwd: '${cwd}', stdio: 'pipe' });
+
+          const content = output.toString().toUpperCase();
+          assert(content.includes('INT') && content.includes('RETURN') && content.includes('42'), 'O Lexer falhou em identificar os tokens básicos.', 'INT, RETURN, 42', content);
+
+          console.log('PASS');
+          if (fs.existsSync(testFile)) fs.unlinkSync(testFile);
+        } catch(e: any) {
+          console.error(e.stderr?.toString() || e.message);
+          process.exit(1);
+        }
+      }
+      testSuite();
+    `;
+        try {
+            fs_1.default.writeFileSync(testFilePath, code);
+            const stdout = (0, child_process_1.execSync)('npx ts-node -T .eval-stage1.ts', { cwd, stdio: 'pipe' });
+            return stdout.toString().includes('PASS');
+        }
+        catch (err) {
+            console.log(chalk_1.default.red(err.stderr?.toString().trim() || err.stdout?.toString().trim() || err.message));
+            return false;
+        }
+        finally {
+            if (fs_1.default.existsSync(testFilePath))
+                fs_1.default.unlinkSync(testFilePath);
+        }
+    }
+    return true;
+}

package/dist/utils/tests/build-your-own-git.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStage = runStage;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+function runStage(stageOrder, cwd) {
+    if (stageOrder === 1) {
+        console.log(chalk_1.default.blue(`[Stage 1: Git Init] Verificando criação da estrutura .git/...`));
+        const testFilePath = path_1.default.join(cwd, '.eval-stage1.ts');
+        const code = `
+      const fs = require('fs');
+      const path = require('path');
+      const { execSync } = require('child_process');
+
+      function assert(condition: boolean, failMsg: string, expected?: any, got?: any) {
+         if (!condition) {
+            console.error('\\n❌ FALHA DE ASSERÇÃO');
+            console.error('📝 ' + failMsg);
+            if (expected !== undefined) console.error('🎯 Esperado : ' + String(expected));
+            if (got !== undefined)      console.error('💥 Recebido : ' + String(got));
+            console.error('');
+            process.exit(1);
+         }
+      }
+
+      async function testSuite() {
+        try {
+          const repoPath = path.join('${cwd}', 'test-repo-' + Date.now());
+          fs.mkdirSync(repoPath);
+
+          execSync('npx ts-node src/index.ts init', { cwd: repoPath, stdio: 'pipe' });
+
+          const gitPath = path.join(repoPath, '.git');
+          assert(fs.existsSync(gitPath), 'O diretório .git não foi criado.', 'EXISTE: .git/', 'NÃO ENCONTRADO');
+          assert(fs.existsSync(path.join(gitPath, 'objects')), 'Pasta .git/objects não encontrada.', 'folder', 'false');
+          assert(fs.existsSync(path.join(gitPath, 'refs')), 'Pasta .git/refs não encontrada.', 'folder', 'false');
+          assert(fs.existsSync(path.join(gitPath, 'HEAD')), 'Arquivo .git/HEAD não encontrado.', 'file', 'false');
+
+          console.log('PASS');
+          fs.rmSync(repoPath, { recursive: true, force: true });
+        } catch(e: any) {
+          console.error(e.stderr?.toString() || e.message);
+          process.exit(1);
+        }
+      }
+      testSuite();
+    `;
+        try {
+            fs_1.default.writeFileSync(testFilePath, code);
+            const stdout = (0, child_process_1.execSync)('npx ts-node -T .eval-stage1.ts', { cwd, stdio: 'pipe' });
+            return stdout.toString().includes('PASS');
+        }
+        catch (err) {
+            console.log(chalk_1.default.red(err.stderr?.toString().trim() || err.stdout?.toString().trim() || err.message));
+            return false;
+        }
+        finally {
+            if (fs_1.default.existsSync(testFilePath))
+                fs_1.default.unlinkSync(testFilePath);
+        }
+    }
+    if (stageOrder === 2) {
+        console.log(chalk_1.default.blue(`[Stage 2: Git Cat-File] Verificando leitura de blobs (zlib decompression)...`));
+        const testFilePath = path_1.default.join(cwd, '.eval-stage2.ts');
+        const code = `
+      const fs = require('fs');
+      const path = require('path');
+      const zlib = require('zlib');
+      const { execSync } = require('child_process');
+
+      function assert(condition: boolean, failMsg: string, expected?: any, got?: any) {
+         if (!condition) {
+            console.error('\\n❌ FALHA DE ASSERÇÃO');
+            console.error('📝 ' + failMsg);
+            if (expected !== undefined) console.error('🎯 Esperado : ' + String(expected));
+            if (got !== undefined)      console.error('💥 Recebido : ' + String(got));
+            console.error('');
+            process.exit(1);
+         }
+      }
+
+      async function testSuite() {
+        try {
+          const repoPath = path.join('${cwd}', 'test-repo-cat-' + Date.now());
+          fs.mkdirSync(repoPath, { recursive: true });
+          
+          const objectsPath = path.join(repoPath, '.git', 'objects');
+          const hash = 'e69de29bb2d1d6434b8b29ae775ad8c2e48c5391';
+          const dir = hash.slice(0, 2);
+          const file = hash.slice(2);
+          
+          fs.mkdirSync(path.join(objectsPath, dir), { recursive: true });
+          const content = Buffer.concat([Buffer.from("blob 5\\0"), Buffer.from("hello")]);
+          const compressed = zlib.deflateSync(content);
+          fs.writeFileSync(path.join(objectsPath, dir, file), compressed);
+
+          const output = execSync('npx ts-node src/index.ts cat-file -p ' + hash, { cwd: repoPath, stdio: 'pipe' });
+          assert(output.toString().trim() === 'hello', 'O comando cat-file não descompactou ou não imprimiu o conteúdo correto.', 'hello', output.toString().trim());
+
+          console.log('PASS');
+          fs.rmSync(repoPath, { recursive: true, force: true });
+        } catch(e: any) {
+          console.error(e.stderr?.toString() || e.message);
+          process.exit(1);
+        }
+      }
+      testSuite();
+    `;
+        try {
+            fs_1.default.writeFileSync(testFilePath, code);
+            const stdout = (0, child_process_1.execSync)('npx ts-node -T .eval-stage2.ts', { cwd, stdio: 'pipe' });
+            return stdout.toString().includes('PASS');
+        }
+        catch (err) {
+            console.log(chalk_1.default.red(err.stderr?.toString().trim() || err.stdout?.toString().trim() || err.message));
+            return false;
+        }
+        finally {
+            if (fs_1.default.existsSync(testFilePath))
+                fs_1.default.unlinkSync(testFilePath);
+        }
+    }
+    return true;
+}

package/dist/utils/tests/build-your-own-http-framework.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStage = runStage;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+async function runStage(stageOrder, cwd) {
+    if (stageOrder === 1) {
+        console.log(chalk_1.default.blue(`[Stage 1: HTTP Server] Rodando TCP Connection Tests...`));
+        return new Promise(async (resolve) => {
+            let child = null;
+            try {
+                console.log(chalk_1.default.gray(`Iniciando servidor do usário [node dist/index.js]...`));
+                child = (0, child_process_1.spawn)('node', ['dist/index.js'], { cwd });
+                await new Promise(r => setTimeout(r, 1500));
+                console.log(chalk_1.default.gray(`Disparando Requests em rotas conhecidas e desconhecidas...`));
+                let passed = true;
+                // TestCase 1: Invalid Route
+                try {
+                    const res = await fetch('http://localhost:3000/rota-que-nao-existe');
+                    // The first stage of DevQuest TCP requires returning 200 dynamically by default if implemented simply, 
+                    // but normally a baseline server just accepts socket connections.
+                    if (res.status) {
+                        console.log(chalk_1.default.green('✅ Conexão HTTP estabelecida com sucesso!'));
+                    }
+                }
+                catch (e) {
+                    console.log(chalk_1.default.red('❌ FALHA DE ASSERÇÃO\n📝 O servidor não aceitou a conexão TCP na porta 3000.\n🎯 Esperado : Conexão Open\n💥 Recebido : ECONNREFUSED'));
+                    passed = false;
+                }
+                // Testcase 2: Valid Param
+                // HTTP framework challenge stage 1 generally involves simply binding a socket server.
+                // Once bound, it passes.
+                child.kill();
+                resolve(passed);
+            }
+            catch (e) {
+                if (child)
+                    child.kill();
+                console.log(chalk_1.default.red('❌ Falha fatal ao executar o daemon local.'));
+                resolve(false);
+            }
+        });
+    }
+    console.log(chalk_1.default.yellow(`⚠️ Nenhuma suite implementada ainda para Stage ${stageOrder} deste desafio. Bypass (Aprovado).`));
+    return true;
+}

package/dist/utils/tests/build-your-own-interpreter.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStage = runStage;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+function runStage(stageOrder, cwd) {
+    if (stageOrder === 1) {
+        console.log(chalk_1.default.blue(`[Stage 1: Interpreter Entry Point] Verificando subcomandos (tokenize/parse/run)...`));
+        const testFilePath = path_1.default.join(cwd, '.eval-stage1.ts');
+        const code = `
+      const { execSync } = require('child_process');
+      const fs = require('fs');
+      const path = require('path');
+
+      function assert(condition: boolean, failMsg: string, expected?: any, got?: any) {
+         if (!condition) {
+            console.error('\\n❌ FALHA DE ASSERÇÃO');
+            console.error('📝 ' + failMsg);
+            if (expected !== undefined) console.error('🎯 Esperado : ' + String(expected));
+            if (got !== undefined)      console.error('💥 Recebido : ' + String(got));
+            console.error('');
+            process.exit(1);
+         }
+      }
+
+      async function testSuite() {
+        try {
+          const testFile = path.join('${cwd}', 'test.lox');
+          fs.writeFileSync(testFile, 'print "hello";');
+
+          console.log('-> Testando subcomando: tokenize');
+          const outputTokenize = execSync('npx ts-node src/index.ts tokenize test.lox', { cwd: '${cwd}', stdio: 'pipe' });
+          assert(outputTokenize.toString().toLowerCase().includes('print') || outputTokenize.toString().toLowerCase().includes('hello'), 'O subcomando tokenize não funcionou.', 'Tokens: PRINT, STRING', outputTokenize.toString());
+
+          console.log('-> Testando subcomando: run');
+          const outputRun = execSync('npx ts-node src/index.ts run test.lox', { cwd: '${cwd}', stdio: 'pipe' });
+          // Even if it doesn't run yet, it should at least not crash if implemented properly.
+          // But we expect it to output 'hello' if implemented.
+          
+          console.log('PASS');
+          if (fs.existsSync(testFile)) fs.unlinkSync(testFile);
+        } catch(e: any) {
+          console.error(e.stderr?.toString() || e.message);
+          process.exit(1);
+        }
+      }
+      testSuite();
+    `;
+        try {
+            fs_1.default.writeFileSync(testFilePath, code);
+            const stdout = (0, child_process_1.execSync)('npx ts-node -T .eval-stage1.ts', { cwd, stdio: 'pipe' });
+            return stdout.toString().includes('PASS');
+        }
+        catch (err) {
+            console.log(chalk_1.default.red(err.stderr?.toString().trim() || err.stdout?.toString().trim() || err.message));
+            return false;
+        }
+        finally {
+            if (fs_1.default.existsSync(testFilePath))
+                fs_1.default.unlinkSync(testFilePath);
+        }
+    }
+    return true;
+}

package/dist/utils/tests/build-your-own-redis.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStage = runStage;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+async function runStage(stageOrder, cwd) {
+    if (stageOrder === 1) {
+        console.log(chalk_1.default.blue(`[Stage 1: Redis TCP Bind] Verificando servidor TCP escutando na porta 6379...`));
+        return new Promise(async (resolve) => {
+            let child = null;
+            try {
+                console.log(chalk_1.default.gray(`Iniciando servidor Redis do usuário (node src/index.js)...`));
+                // Use ts-node -T to run the index.ts directly if that's the setup, or check if dist exists.
+                // Assuming the Redis template follows the same pattern.
+                child = (0, child_process_1.spawn)('npx', ['ts-node', '-T', 'src/index.ts'], { cwd });
+                // Wait for bind
+                await new Promise(r => setTimeout(r, 2000));
+                let passed = false;
+                const net = require('net');
+                try {
+                    const client = new net.Socket();
+                    await new Promise((resolveSocket, rejectSocket) => {
+                        client.connect(6379, '127.0.0.1', () => {
+                            passed = true;
+                            client.destroy();
+                            resolveSocket();
+                        });
+                        client.on('error', (err) => {
+                            rejectSocket(err);
+                        });
+                        setTimeout(() => rejectSocket(new Error('Timeout ao conectar')), 1000);
+                    });
+                }
+                catch (e) {
+                    console.error('\n❌ FALHA DE ASSERÇÃO');
+                    console.error('📝 O servidor não aceitou conexão TCP na porta 6379.');
+                    console.error('🎯 Esperado : Conexão Estabelecida (Port 6379)');
+                    console.error('💥 Recebido : Erro de Conexão (ECONNREFUSED)');
+                    passed = false;
+                }
+                if (passed) {
+                    console.log(chalk_1.default.green('✅ Conexão TCP na porta 6379 detectada!'));
+                }
+                child.kill();
+                resolve(passed);
+            }
+            catch (e) {
+                if (child)
+                    child.kill();
+                console.error(chalk_1.default.red(`[!] Erro fatal: ${e.message}`));
+                resolve(false);
+            }
+        });
+    }
+    if (stageOrder === 2) {
+        console.log(chalk_1.default.blue(`[Stage 2: Redis PONG Response] Verificando resposta +PONG\\r\\n...`));
+        return new Promise(async (resolve) => {
+            let child = null;
+            try {
+                child = (0, child_process_1.spawn)('npx', ['ts-node', '-T', 'src/index.ts'], { cwd });
+                await new Promise(r => setTimeout(r, 2000));
+                let passed = false;
+                const net = require('net');
+                try {
+                    const client = new net.Socket();
+                    await new Promise((resolveSocket, rejectSocket) => {
+                        let receivedData = '';
+                        client.connect(6379, '127.0.0.1', () => {
+                            client.write('PING\\r\\n');
+                        });
+                        client.on('data', (data) => {
+                            receivedData += data.toString();
+                            if (receivedData.includes('+PONG\\r\\n')) {
+                                passed = true;
+                                client.destroy();
+                                resolveSocket();
+                            }
+                        });
+                        client.on('error', (err) => rejectSocket(err));
+                        setTimeout(() => rejectSocket(new Error('Timeout ao receber +PONG')), 2000);
+                    });
+                }
+                catch (e) {
+                    console.error('\\n❌ FALHA DE ASSERÇÃO');
+                    console.error('📝 O servidor não respondeu com +PONG\\r\\n.');
+                    console.error('🎯 Esperado : +PONG\\r\\n');
+                    console.error('💥 Recebido : ' + (e.message || 'Sem resposta'));
+                    passed = false;
+                }
+                if (passed)
+                    console.log(chalk_1.default.green('✅ Recebido +PONG\\r\\n do servidor!'));
+                child.kill();
+                resolve(passed);
+            }
+            catch (e) {
+                if (child)
+                    child.kill();
+                resolve(false);
+            }
+        });
+    }
+    if (stageOrder === 3) {
+        console.log(chalk_1.default.blue(`[Stage 3: Redis Concurrent] Verificando múltiplas conexões simultâneas...`));
+        return new Promise(async (resolve) => {
+            let child = null;
+            try {
+                child = (0, child_process_1.spawn)('npx', ['ts-node', '-T', 'src/index.ts'], { cwd });
+                await new Promise(r => setTimeout(r, 2000));
+                const net = require('net');
+                let connectedCount = 0;
+                const clients = [new net.Socket(), new net.Socket(), new net.Socket()];
+                try {
+                    await Promise.all(clients.map(client => {
+                        return new Promise((res, rej) => {
+                            client.connect(6379, '127.0.0.1', () => {
+                                connectedCount++;
+                                res();
+                            });
+                            client.on('error', rej);
+                            setTimeout(() => rej(new Error('Timeout Concorrência')), 2000);
+                        });
+                    }));
+                    if (connectedCount === 3) {
+                        console.log(chalk_1.default.green('✅ O servidor lidou com 3 conexões simultâneas sem travar!'));
+                        clients.forEach(c => c.destroy());
+                        child.kill();
+                        return resolve(true);
+                    }
+                }
+                catch (e) {
+                    console.error('\\n❌ FALHA DE ASSERÇÃO\\n📝 Servidor bloqueou conexões paralelas.');
+                    clients.forEach(c => c.destroy());
+                    child.kill();
+                    return resolve(false);
+                }
+            }
+            catch (e) {
+                if (child)
+                    child.kill();
+                resolve(false);
+            }
+        });
+    }
+    console.log(chalk_1.default.yellow(`⚠️ Nenhuma suite implementada ainda para Stage ${stageOrder} de Redis. Bypass (Aprovado).`));
+    return true;
+}

package/dist/utils/tests/build-your-own-shell.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStage = runStage;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+function runStage(stageOrder, cwd) {
+    if (stageOrder === 1) {
+        console.log(chalk_1.default.blue(`[Stage 1: Shell Echo] Verificando comando echo do seu Shell...`));
+        // O Shell Stage 1 geralmente envolve criar um prompt e lidar com comandos triviais
+        const testFilePath = path_1.default.join(cwd, '.eval-stage1.ts');
+        const code = `
+      const { execSync } = require('child_process');
+      const fs = require('fs');
+
+      function assert(condition: boolean, failMsg: string, expected?: any, got?: any) {
+         if (!condition) {
+            console.error('\\n❌ FALHA DE ASSERÇÃO');
+            console.error('📝 ' + failMsg);
+            if (expected !== undefined) console.error('🎯 Esperado : ' + String(expected));
+            if (got !== undefined)      console.error('💥 Recebido : ' + String(got));
+            console.error('');
+            process.exit(1);
+         }
+      }
+
+      async function testSuite() {
+        try {
+          // Vamos passar 'echo Hello World' para o shell e ver se o output possui Hello World
+          console.log('-> Injetando comandos via stdin no seu Shell (src/index.ts)...');
+          const output = execSync('echo "echo Hello World\\nexit 0" | npx ts-node src/index.ts', { cwd: '${cwd}', stdio: 'pipe' });
+          
+          assert(output.toString().includes('Hello World'), 'O comando echo não funcionou no seu Shell.', 'Hello World', output.toString());
+          console.log('PASS');
+        } catch(e: any) {
+          console.error(e.stderr?.toString() || e.message);
+          process.exit(1);
+        }
+      }
+      testSuite();
+    `;
+        try {
+            fs_1.default.writeFileSync(testFilePath, code);
+            const stdout = (0, child_process_1.execSync)('npx ts-node -T .eval-stage1.ts', { cwd, stdio: 'pipe' });
+            return stdout.toString().includes('PASS');
+        }
+        catch (err) {
+            console.log(chalk_1.default.red(err.stderr?.toString().trim() || err.stdout?.toString().trim() || err.message));
+            return false;
+        }
+        finally {
+            if (fs_1.default.existsSync(testFilePath))
+                fs_1.default.unlinkSync(testFilePath);
+        }
+    }
+    return true;
+}

package/dist/utils/tests/build-your-own-vercel.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStage = runStage;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+function runStage(stageOrder, cwd) {
+    if (stageOrder === 1) {
+        console.log(chalk_1.default.blue(`[Stage 1: Vercel CLI] Verificando comando deploy...`));
+        const testFilePath = path_1.default.join(cwd, '.eval-stage1.ts');
+        const code = `
+      const { execSync } = require('child_process');
+      const fs = require('fs');
+
+      function assert(condition: boolean, failMsg: string, expected?: any, got?: any) {
+         if (!condition) {
+            console.error('\\n❌ FALHA DE ASSERÇÃO');
+            console.error('📝 ' + failMsg);
+            if (expected !== undefined) console.error('🎯 Esperado : ' + String(expected));
+            if (got !== undefined)      console.error('💥 Recebido : ' + String(got));
+            console.error('');
+            process.exit(1);
+         }
+      }
+
+      async function testSuite() {
+        try {
+          console.log('-> Executando seu comando: node src/index.js deploy');
+          const output = execSync('npx ts-node src/index.ts deploy', { cwd: '${cwd}', stdio: 'pipe' });
+
+          const content = output.toString().toLowerCase();
+          assert(content.includes('deploy') || content.includes('build') || content.includes('uploading'), 'O comando deploy não iniciou o fluxo esperado.', 'Deploying...', output.toString());
+
+          console.log('PASS');
+        } catch(e: any) {
+          console.error(e.stderr?.toString() || e.message);
+          process.exit(1);
+        }
+      }
+      testSuite();
+    `;
+        try {
+            fs_1.default.writeFileSync(testFilePath, code);
+            const stdout = (0, child_process_1.execSync)('npx ts-node -T .eval-stage1.ts', { cwd, stdio: 'pipe' });
+            return stdout.toString().includes('PASS');
+        }
+        catch (err) {
+            console.log(chalk_1.default.red(err.stderr?.toString().trim() || err.stdout?.toString().trim() || err.message));
+            return false;
+        }
+        finally {
+            if (fs_1.default.existsSync(testFilePath))
+                fs_1.default.unlinkSync(testFilePath);
+        }
+    }
+    return true;
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@devquest/cli",
+  "version": "1.0.0",
+  "description": "DevQuest CLI - Construa seu próprio Redis, Docker, Git e mais",
+  "main": "dist/index.js",
+  "bin": {
+    "devquest": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "ts-node src/index.ts",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "axios": "^1.6.8",
+    "chalk": "^4.1.2",
+    "commander": "^12.0.0",
+    "keytar": "^7.9.0",
+    "simple-git": "^3.24.0",
+    "ws": "^8.16.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.7",
+    "@types/ws": "^8.5.10",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
+  }
+}