@runflow-ai/cli 0.2.5 → 0.2.7

package/static/test-server-template.js

@@ -0,0 +1,561 @@
+const express = require('express');
+const cors = require('cors');
+const path = require('path');
+const { spawn } = require('child_process');
+const fs = require('fs');
+
+const app = express();
+app.use(cors());
+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'
+};
+
+// ============================================================================
+// 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
+      });
+      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'
+  };
+}
+
+const RF_CONFIG = loadRfConfig();
+
+// ============================================================================
+// Context Generation (simula Execution Engine)
+// ============================================================================
+
+function generateExecutionId() {
+  return `exec_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+}
+
+function generateRandomId() {
+  return Math.random().toString(36).substring(2, 8);
+}
+
+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()}`;
+}
+
+function inferEntityType(input) {
+  if (input.entityType) return input.entityType;
+  if (input.metadata?.phone || input.metadata?.From) return 'phone';
+  if (input.metadata?.email) return 'email';
+  if (input.metadata?.contactId) return 'hubspot_contact';
+  if (input.sessionId) return 'session';
+  return 'session';
+}
+
+function inferEntityValue(input) {
+  if (input.entityValue) return input.entityValue;
+  if (input.metadata?.phone) return input.metadata.phone;
+  if (input.metadata?.From) return input.metadata.From;
+  if (input.metadata?.email) return input.metadata.email;
+  if (input.metadata?.contactId) return input.metadata.contactId;
+  if (input.sessionId) return input.sessionId;
+  return null;
+}
+
+function inferUserId(input) {
+  if (input.userId) return input.userId;
+  if (input.metadata?.phone) return input.metadata.phone;
+  if (input.metadata?.From) return input.metadata.From;
+  if (input.metadata?.email) return input.metadata.email;
+  if (input.metadata?.contactId) return input.metadata.contactId;
+  return null;
+}
+
+console.log('🧪 Runflow Test Server');
+console.log('📄 Testing file:', CONFIG.mainFile);
+console.log('🔧 Server port:', CONFIG.port);
+console.log('🎯 Agent ID:', RF_CONFIG.agentId);
+console.log('🏢 Tenant ID:', RF_CONFIG.tenantId);
+
+// Endpoint para testar o agente local
+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()}`,
+      companyId: req.body.companyId || 'test',
+      userId: req.body.userId,
+      channel: req.body.channel || 'test',
+      metadata: req.body.metadata || {},
+      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,
+      entityType,
+      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}';
+
+const input = ${inputData};
+
+main(input).then(result => {
+  console.log('🔵 RUNFLOW_RESULT_START');
+  console.log(JSON.stringify(result));
+  console.log('🔵 RUNFLOW_RESULT_END');
+  process.exit(0);
+}).catch(error => {
+  console.log('🔴 RUNFLOW_ERROR_START');
+  console.log(JSON.stringify({ error: error.message }));
+  console.log('🔴 RUNFLOW_ERROR_END');
+  process.exit(1);
+});
+    `], {
+      env: {
+        ...process.env,
+        // ✅ Passar context via env (igual Execution Engine)
+        RUNFLOW_EXECUTION_ID: executionId,
+        RUNFLOW_THREAD_ID: threadId,
+        RUNFLOW_API_URL: RF_CONFIG.apiUrl || 'http://localhost:3001',
+        RUNFLOW_TENANT_ID: RF_CONFIG.tenantId,
+        RUNFLOW_AGENT_ID: RF_CONFIG.agentId,
+        // ✅ NOVO: Flag para salvar traces localmente
+        RUNFLOW_LOCAL_TRACES: 'true',
+        RUNFLOW_ENV: 'development',
+      },
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    
+    let output = '';
+    let errorOutput = '';
+    let hasResponded = false;
+    let isCapturingResult = false;
+    let isCapturingError = false;
+    let resultLines = [];
+    let errorLines = [];
+    
+    // Processar saída linha por linha
+    const processLine = (line) => {
+      if (line.includes('🔵 RUNFLOW_RESULT_START')) {
+        isCapturingResult = true;
+        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,
+              // ✅ Incluir context no response (para debugging)
+              observability: {
+                executionId,
+                threadId,
+                entityType,
+                entityValue,
+                userId,
+              },
+              timestamp: new Date().toISOString()
+            });
+            hasResponded = true;
+            console.log('✅ [Response] Sent to frontend successfully');
+          } catch (e) {
+            console.log('⚠️ [Result Parse Error]:', e.message);
+          }
+        }
+        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()
+            });
+            hasResponded = true;
+          } catch (e) {
+            console.log('⚠️ [Error Parse Error]:', e.message);
+          }
+        }
+        return;
+      }
+      
+      if (isCapturingResult) {
+        resultLines.push(line);
+      } else if (isCapturingError) {
+        errorLines.push(line);
+      }
+    };
+
+    tsxProcess.stdout.on('data', (data) => {
+      const chunk = data.toString();
+      console.log('📤 [stdout]:', chunk.trim());
+      output += chunk;
+      
+      const lines = chunk.split('\n');
+      lines.forEach(line => {
+        if (line.trim()) {
+          processLine(line.trim());
+        }
+      });
+    });
+    
+    tsxProcess.stderr.on('data', (data) => {
+      const chunk = data.toString();
+      console.log('📤 [stderr]:', chunk.trim());
+      errorOutput += chunk;
+    });
+
+    tsxProcess.on('close', (code) => {
+      console.log('🔚 [Process] Closed with code:', code);
+      
+      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('}')) {
+              try {
+                jsonResult = JSON.parse(line);
+                console.log('✅ [Fallback JSON]:', jsonResult);
+                break;
+              } catch (e) {
+                // Continue procurando
+              }
+            }
+          }
+          
+          if (jsonResult) {
+            res.json({
+              success: true,
+              data: jsonResult,
+              timestamp: new Date().toISOString()
+            });
+          } else {
+            res.json({
+              success: true,
+              data: { message: 'Process completed but no result captured' },
+              timestamp: new Date().toISOString()
+            });
+          }
+        } else {
+          res.status(500).json({
+            success: false,
+            error: errorOutput || `Process failed with code ${code}`,
+            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()
+    });
+  }
+});
+
+// Health check
+app.get('/api/health', (req, res) => {
+  res.json({ 
+    status: 'ok', 
+    timestamp: new Date().toISOString(),
+    agent: CONFIG.mainFile,
+    type: 'test-server'
+  });
+});
+
+// Get test scenarios
+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 => {
+        try {
+          const content = JSON.parse(fs.readFileSync(path.join(cliScenariosPath, file), 'utf8'));
+          scenarios.push({ ...content, source: 'cli', id: file.replace('.json', '') });
+        } catch (e) {
+          console.error('Error loading CLI scenario ' + file + ':', e.message);
+        }
+      });
+    }
+  } 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 => {
+        try {
+          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);
+        }
+      });
+    }
+  } catch (error) {
+    console.error('Error loading project scenarios:', error.message);
+  }
+  
+  res.json({ scenarios });
+});
+
+// ============================================================================
+// OBSERVABILITY ENDPOINTS - Local Development
+// ============================================================================
+
+/**
+ * Get local traces (grouped by thread)
+ * Mimics: GET /api/v1/observability/threads
+ */
+app.get('/api/traces', (req, res) => {
+  try {
+    const tracesFile = path.join(process.cwd(), '.runflow', 'traces.json');
+    
+    if (!fs.existsSync(tracesFile)) {
+      return res.json({ 
+        threads: [], 
+        total: 0,
+        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 => {
+      const threadId = execution.threadId || 'unknown';
+      
+      if (!threadMap[threadId]) {
+        threadMap[threadId] = {
+          threadId,
+          entityType: execution.entityType,
+          entityValue: execution.entityValue,
+          executions: [],
+          totalTraces: 0,
+          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({ 
+      threads,
+      total: threads.length,
+      totalTraces: data.traces?.length || 0
+    });
+  } catch (error) {
+    console.error('❌ Error reading traces:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * Get execution details with traces
+ * Mimics: GET /api/v1/observability/executions/:executionId
+ */
+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 => {
+      traceMap.set(trace.traceId, { ...trace, children: [] });
+    });
+    
+    execution.traces.forEach(trace => {
+      const node = traceMap.get(trace.traceId);
+      if (trace.parentTraceId) {
+        const parent = traceMap.get(trace.parentTraceId);
+        if (parent) {
+          parent.children.push(node);
+        } else {
+          rootTraces.push(node);
+        }
+      } else {
+        rootTraces.push(node);
+      }
+    });
+    
+    res.json({
+      execution: {
+        executionId: execution.executionId,
+        threadId: execution.threadId,
+        entityType: execution.entityType,
+        entityValue: execution.entityValue,
+        userId: execution.userId,
+        agentName: execution.agentName,
+        startedAt: execution.startedAt,
+        totalTraces: execution.traces.length,
+      },
+      traces: rootTraces,
+    });
+  } catch (error) {
+    console.error('❌ Error reading execution:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * Clear local traces
+ */
+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({ 
+      success: true,
+      message: 'Local traces cleared successfully' 
+    });
+  } catch (error) {
+    console.error('❌ Error clearing traces:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+app.listen(CONFIG.port, () => {
+  console.log('✅ Test server ready on port', CONFIG.port);
+});
+
+process.on('SIGINT', () => {
+  console.log('\n🛑 Shutting down test server...');
+  process.exit(0);
+});