@runflow-ai/cli 0.2.7 → 0.2.9

package/static/test-server-template.js

@@ -11,35 +11,43 @@ app.use(express.json());
 // Configuração será injetada pela CLI
 const CONFIG = {
   port: process.env.RUNFLOW_PORT || 8547,
-  mainFile: process.env.RUNFLOW_MAIN_FILE || 'main.ts'
+  mainFile: process.env.RUNFLOW_MAIN_FILE || 'main.ts',
+  verbose: process.env.RUNFLOW_VERBOSE === 'true',
 };
 
+// Log de inicialização
+console.log('🚀 [INIT] Test server starting...');
+console.log('🔧 [CONFIG]', CONFIG);
+if (CONFIG.verbose) {
+  console.log('📝 [VERBOSE] Verbose mode is ENABLED');
+}
+
 // ============================================================================
 // Load rf.json (agent configuration)
 // ============================================================================
 
 function loadRfConfig() {
   const rfConfigPath = path.join(process.cwd(), '.runflow', 'rf.json');
-  
+
   if (fs.existsSync(rfConfigPath)) {
     try {
       const config = JSON.parse(fs.readFileSync(rfConfigPath, 'utf8'));
       console.log('✅ Loaded rf.json:', {
         agentId: config.agentId,
         tenantId: config.tenantId,
-        apiUrl: config.apiUrl
+        apiUrl: config.apiUrl,
       });
       return config;
     } catch (error) {
       console.warn('⚠️ Could not parse rf.json:', error.message);
     }
   }
-  
+
   console.warn('⚠️ No rf.json found - using defaults');
   return {
     agentId: 'local-agent',
     tenantId: 'test-local',
-    apiUrl: 'http://localhost:3001'
+    apiUrl: 'http://localhost:3001',
   };
 }
 
@@ -59,34 +67,34 @@ function generateRandomId() {
 
 function generateThreadId(input) {
   const companyId = input.companyId || 'test';
-  
+
   // 1. Explicit
   if (input.entityType && input.entityValue) {
     const cleanValue = String(input.entityValue).replace(/[^a-zA-Z0-9]/g, '_');
     return `${input.entityType}_${companyId}_${cleanValue}`;
   }
-  
+
   // 2. SessionId
   if (input.sessionId) {
     return `session_${companyId}_${input.sessionId}`;
   }
-  
+
   // 3. Phone (WhatsApp/Twilio)
   if (input.metadata?.phone || input.metadata?.From) {
     const phone = (input.metadata.phone || input.metadata.From).replace(/\D/g, '');
     return `phone_${companyId}_${phone}`;
   }
-  
+
   // 4. Email
   if (input.metadata?.email) {
     return `email_${companyId}_${input.metadata.email}`;
   }
-  
+
   // 5. ContactId (HubSpot)
   if (input.metadata?.contactId) {
     return `hubspot_contact_${companyId}_${input.metadata.contactId}`;
   }
-  
+
   // 6. Fallback
   return `thread_${companyId}_${Date.now()}_${generateRandomId()}`;
 }
@@ -130,11 +138,11 @@ app.post('/api/chat', async (req, res) => {
   try {
     console.log('\n📥 [Test] Received:', req.body.message);
     console.log('🔄 [Reload] Loading fresh code from', CONFIG.mainFile + '...');
-    
+
     // ============================================================================
     // Generate Execution Context (simula Execution Engine)
     // ============================================================================
-    
+
     const input = {
       message: req.body.message,
       sessionId: req.body.sessionId || `test_session_${Date.now()}`,
@@ -142,15 +150,15 @@ app.post('/api/chat', async (req, res) => {
       userId: req.body.userId,
       channel: req.body.channel || 'test',
       metadata: req.body.metadata || {},
-      timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     };
-    
+
     const executionId = generateExecutionId();
     const threadId = generateThreadId(input);
     const entityType = inferEntityType(input);
     const entityValue = inferEntityValue(input);
     const userId = inferUserId(input);
-    
+
     console.log('🔍 [Context Generated]:', {
       executionId,
       threadId,
@@ -158,12 +166,25 @@ app.post('/api/chat', async (req, res) => {
       entityValue: entityValue || '(none)',
       userId: userId || '(none)',
     });
-    
+
     // Executar TypeScript diretamente com tsx
     const inputData = JSON.stringify(input);
 
-    const tsxProcess = spawn('npx', ['tsx', '--eval', `
-import { main } from './${CONFIG.mainFile}';
+    if (CONFIG.verbose) {
+      console.log('\n📝 [Verbose] Executing:', CONFIG.mainFile);
+      console.log('📝 [Verbose] Input:', input);
+      console.log('📝 [Verbose] Working Directory:', process.cwd());
+    }
+
+    // Criar arquivo temporário para execução (mais confiável que --eval)
+    const tempDir = path.join(process.cwd(), '.runflow');
+    if (!fs.existsSync(tempDir)) {
+      fs.mkdirSync(tempDir, { recursive: true });
+    }
+
+    const tempFile = path.join(tempDir, `exec_${Date.now()}.ts`);
+    const tsxCode = `
+import { main } from '../${CONFIG.mainFile}';
 
 const input = ${inputData};
 
@@ -174,11 +195,20 @@ main(input).then(result => {
   process.exit(0);
 }).catch(error => {
   console.log('🔴 RUNFLOW_ERROR_START');
-  console.log(JSON.stringify({ error: error.message }));
+  console.log(JSON.stringify({ error: error.message, stack: error.stack }));
   console.log('🔴 RUNFLOW_ERROR_END');
   process.exit(1);
 });
-    `], {
+    `;
+
+    fs.writeFileSync(tempFile, tsxCode);
+
+    if (CONFIG.verbose) {
+      console.log('\n📜 [TSX Code written to]:', tempFile);
+    }
+
+    const tsxProcess = spawn('npx', ['tsx', tempFile], {
+      cwd: process.cwd(), // Executar no diretório do projeto
       env: {
         ...process.env,
         // ✅ Passar context via env (igual Execution Engine)
@@ -191,9 +221,29 @@ main(input).then(result => {
         RUNFLOW_LOCAL_TRACES: 'true',
         RUNFLOW_ENV: 'development',
       },
-      stdio: ['pipe', 'pipe', 'pipe']
+      stdio: ['pipe', 'pipe', 'pipe'], // Sempre pipe para capturar resultado
+      // No Windows, npx precisa de shell: true
+      shell: process.platform === 'win32',
     });
-    
+
+    if (CONFIG.verbose) {
+      console.log('🚀 [Process] tsx spawned with PID:', tsxProcess.pid);
+    }
+
+    // Cleanup: remover arquivo temporário após execução
+    const cleanupTempFile = () => {
+      try {
+        if (fs.existsSync(tempFile)) {
+          fs.unlinkSync(tempFile);
+          if (CONFIG.verbose) {
+            console.log('🗑️ [Cleanup] Temp file removed');
+          }
+        }
+      } catch (e) {
+        // Ignorar erros de cleanup
+      }
+    };
+
     let output = '';
     let errorOutput = '';
     let hasResponded = false;
@@ -201,7 +251,7 @@ main(input).then(result => {
     let isCapturingError = false;
     let resultLines = [];
     let errorLines = [];
-    
+
     // Processar saída linha por linha
     const processLine = (line) => {
       if (line.includes('🔵 RUNFLOW_RESULT_START')) {
@@ -209,15 +259,15 @@ main(input).then(result => {
         resultLines = [];
         return;
       }
-      
+
       if (line.includes('🔵 RUNFLOW_RESULT_END')) {
         isCapturingResult = false;
-        
+
         if (!hasResponded && resultLines.length > 0) {
           try {
             const jsonResult = JSON.parse(resultLines.join('\n'));
             console.log('✅ [Result Captured]:', jsonResult);
-            
+
             res.json({
               success: true,
               data: jsonResult,
@@ -229,7 +279,7 @@ main(input).then(result => {
                 entityValue,
                 userId,
               },
-              timestamp: new Date().toISOString()
+              timestamp: new Date().toISOString(),
             });
             hasResponded = true;
             console.log('✅ [Response] Sent to frontend successfully');
@@ -239,25 +289,25 @@ main(input).then(result => {
         }
         return;
       }
-      
+
       if (line.includes('🔴 RUNFLOW_ERROR_START')) {
         isCapturingError = true;
         errorLines = [];
         return;
       }
-      
+
       if (line.includes('🔴 RUNFLOW_ERROR_END')) {
         isCapturingError = false;
-        
+
         if (!hasResponded && errorLines.length > 0) {
           try {
             const errorResult = JSON.parse(errorLines.join('\n'));
             console.log('❌ [Error Captured]:', errorResult);
-            
+
             res.status(500).json({
               success: false,
               error: errorResult.error,
-              timestamp: new Date().toISOString()
+              timestamp: new Date().toISOString(),
             });
             hasResponded = true;
           } catch (e) {
@@ -266,7 +316,7 @@ main(input).then(result => {
         }
         return;
       }
-      
+
       if (isCapturingResult) {
         resultLines.push(line);
       } else if (isCapturingError) {
@@ -274,35 +324,58 @@ main(input).then(result => {
       }
     };
 
-    tsxProcess.stdout.on('data', (data) => {
+    // Sempre capturar output, mas só mostrar logs detalhados se verbose
+    tsxProcess.stdout?.on('data', (data) => {
       const chunk = data.toString();
-      console.log('📤 [stdout]:', chunk.trim());
+      if (CONFIG.verbose) {
+        console.log('📤 [TSX stdout]:', chunk.trim());
+      }
       output += chunk;
-      
+
       const lines = chunk.split('\n');
-      lines.forEach(line => {
+      lines.forEach((line) => {
         if (line.trim()) {
           processLine(line.trim());
         }
       });
     });
-    
-    tsxProcess.stderr.on('data', (data) => {
+
+    tsxProcess.stderr?.on('data', (data) => {
       const chunk = data.toString();
-      console.log('📤 [stderr]:', chunk.trim());
+      if (CONFIG.verbose) {
+        console.log('📤 [TSX stderr]:', chunk.trim());
+      }
       errorOutput += chunk;
     });
 
+    tsxProcess.on('error', (error) => {
+      console.error('❌ [Process Error]:', error.message);
+      if (!hasResponded) {
+        res.status(500).json({
+          success: false,
+          error: `Failed to execute: ${error.message}`,
+          timestamp: new Date().toISOString(),
+        });
+        hasResponded = true;
+      }
+    });
+
     tsxProcess.on('close', (code) => {
-      console.log('🔚 [Process] Closed with code:', code);
-      
+      cleanupTempFile(); // Limpar arquivo temporário
+
+      if (CONFIG.verbose) {
+        console.log('🔚 [Process] Closed with code:', code);
+        console.log('📊 [Captured Output]:', output.substring(0, 500)); // Primeiros 500 chars
+        console.log('📊 [Captured Error]:', errorOutput.substring(0, 500));
+      }
+
       if (!hasResponded) {
         console.log('⚠️ [Fallback] No structured response captured');
-        
+
         if (code === 0) {
           const lines = output.trim().split('\n');
           let jsonResult = null;
-          
+
           for (let i = lines.length - 1; i >= 0; i--) {
             const line = lines[i].trim();
             if (line.startsWith('{') && line.endsWith('}')) {
@@ -315,48 +388,47 @@ main(input).then(result => {
               }
             }
           }
-          
+
           if (jsonResult) {
             res.json({
               success: true,
               data: jsonResult,
-              timestamp: new Date().toISOString()
+              timestamp: new Date().toISOString(),
             });
           } else {
             res.json({
               success: true,
               data: { message: 'Process completed but no result captured' },
-              timestamp: new Date().toISOString()
+              timestamp: new Date().toISOString(),
             });
           }
         } else {
           res.status(500).json({
             success: false,
             error: errorOutput || `Process failed with code ${code}`,
-            timestamp: new Date().toISOString()
+            timestamp: new Date().toISOString(),
           });
         }
       }
     });
-    
   } catch (error) {
     console.error('❌ [Test] Error:', error.message);
-    
+
     res.status(500).json({
       success: false,
       error: error.message,
-      timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     });
   }
 });
 
 // Health check
 app.get('/api/health', (req, res) => {
-  res.json({ 
-    status: 'ok', 
+  res.json({
+    status: 'ok',
     timestamp: new Date().toISOString(),
     agent: CONFIG.mainFile,
-    type: 'test-server'
+    type: 'test-servers',
   });
 });
 
@@ -364,17 +436,17 @@ app.get('/api/health', (req, res) => {
 app.get('/api/scenarios', (req, res) => {
   const fs = require('fs');
   const path = require('path');
-  
+
   const scenarios = [];
-  
+
   // 1. Load CLI default scenarios
   try {
     const cliScenariosPath = process.env.RUNFLOW_SCENARIOS_PATH;
-    
+
     if (cliScenariosPath && fs.existsSync(cliScenariosPath)) {
-      const files = fs.readdirSync(cliScenariosPath).filter(f => f.endsWith('.json'));
-      
-      files.forEach(file => {
+      const files = fs.readdirSync(cliScenariosPath).filter((f) => f.endsWith('.json'));
+
+      files.forEach((file) => {
         try {
           const content = JSON.parse(fs.readFileSync(path.join(cliScenariosPath, file), 'utf8'));
           scenarios.push({ ...content, source: 'cli', id: file.replace('.json', '') });
@@ -386,15 +458,17 @@ app.get('/api/scenarios', (req, res) => {
   } catch (error) {
     console.error('Error loading CLI scenarios:', error.message);
   }
-  
+
   // 2. Load project custom scenarios
   try {
     const projectScenariosPath = path.join(process.cwd(), 'test-scenarios');
     if (fs.existsSync(projectScenariosPath)) {
-      const files = fs.readdirSync(projectScenariosPath).filter(f => f.endsWith('.json'));
-      files.forEach(file => {
+      const files = fs.readdirSync(projectScenariosPath).filter((f) => f.endsWith('.json'));
+      files.forEach((file) => {
         try {
-          const content = JSON.parse(fs.readFileSync(path.join(projectScenariosPath, file), 'utf8'));
+          const content = JSON.parse(
+            fs.readFileSync(path.join(projectScenariosPath, file), 'utf8'),
+          );
           scenarios.push({ ...content, source: 'project', id: file.replace('.json', '') });
         } catch (e) {
           console.error('Error loading project scenario ' + file + ':', e.message);
@@ -404,7 +478,7 @@ app.get('/api/scenarios', (req, res) => {
   } catch (error) {
     console.error('Error loading project scenarios:', error.message);
   }
-  
+
   res.json({ scenarios });
 });
 
@@ -419,22 +493,22 @@ app.get('/api/scenarios', (req, res) => {
 app.get('/api/traces', (req, res) => {
   try {
     const tracesFile = path.join(process.cwd(), '.runflow', 'traces.json');
-    
+
     if (!fs.existsSync(tracesFile)) {
-      return res.json({ 
-        threads: [], 
+      return res.json({
+        threads: [],
         total: 0,
-        message: 'No traces yet. Run your agent to generate traces.' 
+        message: 'No traces yet. Run your agent to generate traces.',
       });
     }
-    
+
     const data = JSON.parse(fs.readFileSync(tracesFile, 'utf-8'));
-    
+
     // Group executions by threadId
     const threadMap = {};
-    Object.values(data.executions || {}).forEach(execution => {
+    Object.values(data.executions || {}).forEach((execution) => {
       const threadId = execution.threadId || 'unknown';
-      
+
       if (!threadMap[threadId]) {
         threadMap[threadId] = {
           threadId,
@@ -445,23 +519,24 @@ app.get('/api/traces', (req, res) => {
           lastActivity: execution.startedAt,
         };
       }
-      
+
       threadMap[threadId].executions.push(execution);
       threadMap[threadId].totalTraces += execution.traces?.length || 0;
-      
+
       // Update last activity
       if (execution.startedAt > threadMap[threadId].lastActivity) {
         threadMap[threadId].lastActivity = execution.startedAt;
       }
     });
-    
-    const threads = Object.values(threadMap)
-      .sort((a, b) => new Date(b.lastActivity) - new Date(a.lastActivity));
-    
-    res.json({ 
+
+    const threads = Object.values(threadMap).sort(
+      (a, b) => new Date(b.lastActivity) - new Date(a.lastActivity),
+    );
+
+    res.json({
       threads,
       total: threads.length,
-      totalTraces: data.traces?.length || 0
+      totalTraces: data.traces?.length || 0,
     });
   } catch (error) {
     console.error('❌ Error reading traces:', error);
@@ -476,27 +551,27 @@ app.get('/api/traces', (req, res) => {
 app.get('/api/traces/executions/:executionId', (req, res) => {
   try {
     const tracesFile = path.join(process.cwd(), '.runflow', 'traces.json');
-    
+
     if (!fs.existsSync(tracesFile)) {
       return res.status(404).json({ error: 'Execution not found' });
     }
-    
+
     const data = JSON.parse(fs.readFileSync(tracesFile, 'utf-8'));
     const execution = data.executions?.[req.params.executionId];
-    
+
     if (!execution) {
       return res.status(404).json({ error: 'Execution not found' });
     }
-    
+
     // Build hierarchy of traces
     const traceMap = new Map();
     const rootTraces = [];
-    
-    execution.traces.forEach(trace => {
+
+    execution.traces.forEach((trace) => {
       traceMap.set(trace.traceId, { ...trace, children: [] });
     });
-    
-    execution.traces.forEach(trace => {
+
+    execution.traces.forEach((trace) => {
       const node = traceMap.get(trace.traceId);
       if (trace.parentTraceId) {
         const parent = traceMap.get(trace.parentTraceId);
@@ -509,7 +584,7 @@ app.get('/api/traces/executions/:executionId', (req, res) => {
         rootTraces.push(node);
       }
     });
-    
+
     res.json({
       execution: {
         executionId: execution.executionId,
@@ -535,15 +610,15 @@ app.get('/api/traces/executions/:executionId', (req, res) => {
 app.delete('/api/traces', (req, res) => {
   try {
     const tracesFile = path.join(process.cwd(), '.runflow', 'traces.json');
-    
+
     if (fs.existsSync(tracesFile)) {
       fs.unlinkSync(tracesFile);
       console.log('🗑️ Local traces cleared');
     }
-    
-    res.json({ 
+
+    res.json({
       success: true,
-      message: 'Local traces cleared successfully' 
+      message: 'Local traces cleared successfully',
     });
   } catch (error) {
     console.error('❌ Error clearing traces:', error);
@@ -552,7 +627,12 @@ app.delete('/api/traces', (req, res) => {
 });
 
 app.listen(CONFIG.port, () => {
-  console.log('✅ Test server ready on port', CONFIG.port);
+  console.log('✅ [READY] Test server ready on port', CONFIG.port);
+  console.log('📂 [CWD]', process.cwd());
+  console.log('📄 [MAIN]', CONFIG.mainFile);
+  if (CONFIG.verbose) {
+    console.log('🔍 [VERBOSE] All logs will be shown');
+  }
 });
 
 process.on('SIGINT', () => {