@runflow-ai/cli 0.2.11 → 0.2.13

package/dist/commands/test/test.command.js

@@ -50,70 +50,74 @@ const nest_commander_1 = require("nest-commander");
 const common_1 = require("@nestjs/common");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const child_process_1 = require("child_process");
 const chalk_1 = __importDefault(require("chalk"));
-const ora_1 = __importDefault(require("ora"));
-const validator_1 = require("../../common/validator");
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const crypto_1 = require("crypto");
 let TestCommand = class TestCommand extends nest_commander_1.CommandRunner {
     constructor() {
         super(...arguments);
         this.server = null;
-        this.frontend = null;
+        this.app = null;
+        this.storageDir = '';
     }
     async run(passedParam, options) {
         try {
-            const port = options?.port || 8547;
-            const host = options?.host || 'localhost';
-            const shouldOpen = options?.open !== false;
-            const verbose = true;
-            console.log('🔍 [DEBUG] Options received:', options);
-            console.log('🔍 [DEBUG] Verbose flag:', verbose);
-            console.log(chalk_1.default.cyan.bold('🧪 Runflow Test Server'));
-            console.log(chalk_1.default.gray('Starting local development environment...\n'));
-            const validation = (0, validator_1.validateForTest)();
-            if (!validation.isValid) {
-                console.error(chalk_1.default.red('\n❌ Project validation failed!'));
-                validation.errors.forEach((error) => {
-                    console.error(chalk_1.default.red(`   • ${error}`));
-                });
-                console.error(chalk_1.default.gray('\n📚 Documentation: https://docs.runflow.ai\n'));
+            console.log(chalk_1.default.cyan.bold('\n🧪 Runflow Test Server'));
+            console.log(chalk_1.default.gray('Starting local observability server...\n'));
+            const config = this.loadRunflowConfig();
+            if (!config || !config.agentId) {
+                console.error(chalk_1.default.red('❌ No agentId found in .runflow/rf.json'));
+                console.error(chalk_1.default.gray('   Run "rf clone <agentId>" first\n'));
                 process.exit(1);
             }
-            const mainFile = validation.mainFile;
-            const spinner = verbose ? null : (0, ora_1.default)('Initializing...').start();
-            try {
-                await this.ensureDependencies(spinner);
-                await this.startTestServer(port, mainFile, verbose, spinner);
-                await this.startFrontend(port + 1000, port, verbose, spinner);
-                if (spinner) {
-                    spinner.succeed('Ready!');
-                }
-                if (!verbose) {
-                    console.clear();
+            console.log(chalk_1.default.green('✓ Found agent config'));
+            console.log(chalk_1.default.gray(`  Agent: ${config.agentName || config.agentId}\n`));
+            this.storageDir = path.join(process.cwd(), '.runflow', 'traces');
+            this.ensureStorageDir();
+            const basePort = options?.port || this.getRandomPort();
+            let port = null;
+            let attempts = 0;
+            const maxAttempts = 3;
+            while (attempts < maxAttempts && !port) {
+                const tryPort = basePort + attempts;
+                try {
+                    await this.startObservabilityServer(tryPort);
+                    port = tryPort;
+                    console.log(chalk_1.default.green(`✓ Local server running on port ${port}\n`));
                 }
-                console.log(chalk_1.default.green.bold('✅ Test Interface Running!'));
-                console.log('');
-                console.log(chalk_1.default.cyan(`🌐 Open: http://${host}:${port + 1000}`));
-                console.log(chalk_1.default.gray(`📄 Testing: ${mainFile}`));
-                console.log('');
-                console.log(chalk_1.default.gray('Press Ctrl+C to stop'));
-                if (shouldOpen) {
-                    this.openBrowser(`http://${host}:${port + 1000}`);
+                catch (error) {
+                    attempts++;
+                    if (attempts < maxAttempts) {
+                        console.log(chalk_1.default.yellow(`⚠️  Port ${tryPort} in use, trying ${tryPort + 1}...`));
+                    }
                 }
-                this.setupCleanupHandlers();
-                await this.keepAlive();
             }
-            catch (error) {
-                if (spinner) {
-                    spinner.fail('Failed to start test environment');
-                }
-                console.error(chalk_1.default.red(`❌ Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
-                await this.cleanup();
+            if (!port) {
+                console.error(chalk_1.default.red(`❌ Failed to start server after ${maxAttempts} attempts`));
+                console.error(chalk_1.default.gray('   All ports are busy. Try again later.\n'));
                 process.exit(1);
             }
+            let portalUrl = `http://localhost:${port}/agents/${config.agentId}/test-monitor?apiUrl=http://localhost:${port}`;
+            if (config.agentName) {
+                portalUrl += `&agentName=${encodeURIComponent(config.agentName)}`;
+            }
+            if (options?.noBrowser !== true) {
+                console.log(chalk_1.default.green('✓ Opening browser...\n'));
+                this.openBrowser(portalUrl);
+            }
+            console.log(chalk_1.default.cyan.bold('📊 Test Portal Ready!'));
+            console.log('');
+            console.log(chalk_1.default.cyan(`   🌐 Portal: ${portalUrl}`));
+            console.log(chalk_1.default.gray(`   📡 API: http://localhost:${port}`));
+            console.log(chalk_1.default.gray(`   🚀 Execute: POST http://localhost:${port}/api/v1/agents/execute`));
+            console.log(chalk_1.default.gray(`   💾 Storage: ${this.storageDir}`));
+            console.log('');
+            console.log(chalk_1.default.gray('Press Ctrl+C to stop\n'));
+            this.setupCleanupHandlers();
+            await this.keepAlive();
         }
         catch (error) {
-            console.log('deu erro aqui');
             console.error(chalk_1.default.red(`❌ Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
             await this.cleanup();
             process.exit(1);
@@ -126,14 +130,7 @@ let TestCommand = class TestCommand extends nest_commander_1.CommandRunner {
         }
         return port;
     }
-    parseHost(val) {
-        return val;
-    }
-    parseOpen() {
-        return false;
-    }
-    parseVerbose(val) {
-        console.log('🔍 [PARSER] parseVerbose called with:', val);
+    parseNoBrowser() {
         return true;
     }
     loadRunflowConfig() {
@@ -148,197 +145,709 @@ let TestCommand = class TestCommand extends nest_commander_1.CommandRunner {
         }
         return null;
     }
-    async ensureDependencies(spinner) {
-        if (spinner) {
-            spinner.text = 'Checking dependencies...';
-        }
-        else {
-            console.log('🔍 Checking dependencies...');
-        }
-        const packageJsonPath = path.join(process.cwd(), 'package.json');
-        if (!fs.existsSync(packageJsonPath)) {
-            throw new Error("No package.json found. Make sure you're in a valid Node.js project.");
-        }
-        const nodeModulesPath = path.join(process.cwd(), 'node_modules');
-        if (!fs.existsSync(nodeModulesPath)) {
-            if (spinner) {
-                spinner.text = 'Installing dependencies...';
+    async executeAgent(message, threadId, sessionId, userId) {
+        try {
+            const possibleFiles = [
+                path.join(process.cwd(), 'agent.ts'),
+                path.join(process.cwd(), 'agent.js'),
+                path.join(process.cwd(), 'src', 'agent.ts'),
+                path.join(process.cwd(), 'src', 'agent.js'),
+                path.join(process.cwd(), 'main.ts'),
+                path.join(process.cwd(), 'main.js'),
+            ];
+            let agentFile = null;
+            for (const file of possibleFiles) {
+                if (fs.existsSync(file)) {
+                    agentFile = file;
+                    break;
+                }
+            }
+            if (!agentFile) {
+                throw new Error('Agent file not found. Expected agent.ts, agent.js, main.ts, or main.js in project root or src/');
+            }
+            process.env.RUNFLOW_LOCAL_TRACES = 'true';
+            process.env.RUNFLOW_ENV = 'development';
+            process.env.RUNFLOW_VERBOSE_TRACING = 'true';
+            let agentModule;
+            if (agentFile.endsWith('.ts')) {
+                require('tsx/cjs');
+                agentModule = require(agentFile);
             }
             else {
-                console.log('📦 Installing dependencies...');
+                agentModule = require(agentFile);
+            }
+            const config = this.loadRunflowConfig();
+            const input = {
+                message,
+                sessionId,
+                userId,
+                channel: 'local-test',
+                threadId,
+                metadata: {
+                    timestamp: new Date().toISOString(),
+                    source: 'local-cli',
+                    agentId: config?.agentId,
+                }
+            };
+            let result;
+            if (typeof agentModule.main === 'function') {
+                result = await agentModule.main(input);
             }
-            await this.runCommand('npm', ['install'], { stdio: 'pipe' });
+            else if (typeof agentModule.default === 'function') {
+                result = await agentModule.default(input);
+            }
+            else {
+                const agent = agentModule.agent || agentModule.default || agentModule;
+                if (typeof agent === 'function') {
+                    const agentInstance = agent();
+                    if (agentInstance && typeof agentInstance.process === 'function') {
+                        result = await agentInstance.process(input);
+                    }
+                    else {
+                        throw new Error('No valid export found. Expected: export async function main(input), export default function, or agent with process() method');
+                    }
+                }
+                else if (agent && typeof agent.process === 'function') {
+                    result = await agent.process(input);
+                }
+                else {
+                    throw new Error('No valid export found. Expected: export async function main(input), export default function, or agent with process() method');
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+            const tracesFile = path.join(process.cwd(), '.runflow', 'traces.json');
+            if (fs.existsSync(tracesFile)) {
+                try {
+                    const content = fs.readFileSync(tracesFile, 'utf-8');
+                    const data = JSON.parse(content);
+                    const execId = result.executionId || result.metadata?.executionId || `exec-${Date.now()}`;
+                    const execution = data.executions?.[execId];
+                    if (execution) {
+                        console.log(chalk_1.default.gray(`   Traces saved: ${execution.traces?.length || 0}`));
+                        const traceTypes = execution.traces?.map((t) => t.type) || [];
+                        console.log(chalk_1.default.gray(`   Types: ${[...new Set(traceTypes)].join(', ')}`));
+                    }
+                }
+                catch (error) {
+                }
+            }
+            return {
+                executionId: result.executionId || result.metadata?.executionId || `exec-${Date.now()}`,
+                message: result.message || result.output || result,
+                metadata: result.metadata || {},
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to execute agent: ${error.message}`);
         }
     }
-    async startTestServer(port, mainFile, verbose, spinner) {
-        if (spinner) {
-            spinner.text = 'Starting test server...';
+    getRandomPort() {
+        return Math.floor(Math.random() * 1000) + 3000;
+    }
+    generateSessionId(req, bodySessionId) {
+        if (bodySessionId) {
+            return bodySessionId;
+        }
+        const headerSessionId = req.headers['x-session-id'];
+        if (headerSessionId) {
+            return headerSessionId;
         }
-        else {
-            console.log('🚀 Starting test server...');
+        const cookieHeader = req.headers['cookie'];
+        if (cookieHeader) {
+            const cookies = cookieHeader.split(';').reduce((acc, cookie) => {
+                const [key, value] = cookie.trim().split('=');
+                acc[key] = value;
+                return acc;
+            }, {});
+            if (cookies['runflow_session']) {
+                return cookies['runflow_session'];
+            }
         }
-        const serverCliDir = path.join(__dirname, '..', '..', '..');
-        const serverTemplatePath = path.join(serverCliDir, 'static', 'test-server-template.js');
-        if (!fs.existsSync(serverTemplatePath)) {
-            throw new Error('Test server template not found. Please ensure the CLI is properly installed.');
+        const fingerprint = this.createFingerprint(req);
+        return `auto_${fingerprint}_${Date.now()}`;
+    }
+    generateUserId(req, sessionId) {
+        const cookieHeader = req.headers['cookie'];
+        if (cookieHeader) {
+            const cookies = cookieHeader.split(';').reduce((acc, cookie) => {
+                const [key, value] = cookie.trim().split('=');
+                acc[key] = value;
+                return acc;
+            }, {});
+            if (cookies['runflow_user']) {
+                return cookies['runflow_user'];
+            }
         }
-        const scenariosPath = path.join(serverCliDir, 'scenarios');
-        this.server = (0, child_process_1.spawn)('node', [serverTemplatePath], {
-            stdio: 'pipe',
-            env: {
-                ...process.env,
-                NODE_ENV: 'development',
-                RUNFLOW_PORT: port.toString(),
-                RUNFLOW_MAIN_FILE: mainFile,
-                RUNFLOW_SCENARIOS_PATH: scenariosPath,
-                RUNFLOW_VERBOSE: verbose ? 'true' : 'false',
-            },
-        });
-        if (verbose) {
-            console.log(chalk_1.default.gray('[DEBUG] Verbose mode enabled - attaching log listeners'));
+        return sessionId;
+    }
+    createFingerprint(req) {
+        const components = [
+            req.headers['user-agent'] || '',
+            req.headers['accept-language'] || '',
+            req.ip || req.socket.remoteAddress || '',
+        ].join('|');
+        return (0, crypto_1.createHash)('md5').update(components).digest('hex').substring(0, 12);
+    }
+    ensureStorageDir() {
+        if (!fs.existsSync(this.storageDir)) {
+            fs.mkdirSync(this.storageDir, { recursive: true });
         }
-        this.server.stdout?.on('data', (data) => {
-            const output = data.toString();
-            if (verbose) {
-                process.stdout.write(`[SERVER] ${output}`);
+    }
+    async startObservabilityServer(port) {
+        return new Promise((resolve, reject) => {
+            this.app = (0, express_1.default)();
+            this.app.use((0, cors_1.default)({
+                origin: true,
+                credentials: true,
+                methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'PATCH'],
+                allowedHeaders: ['Content-Type', 'X-Thread-Id', 'X-Session-Id', 'Authorization', 'Cookie'],
+                exposedHeaders: ['Content-Length', 'X-Request-Id', 'X-Session-ID', 'X-User-ID', 'X-Timestamp'],
+                maxAge: 86400,
+            }));
+            this.app.use(express_1.default.json());
+            const distPath = path.join(__dirname, '..', '..', '..', 'static', 'dist-test');
+            this.app.use('/assets', express_1.default.static(path.join(distPath, 'assets')));
+            this.app.use('/widget', express_1.default.static(path.join(distPath, 'widget')));
+            this.app.get('/health', (req, res) => {
+                res.status(200).json({ status: 'ok', mode: 'local', version: '1.0.0' });
+            });
+            this.setupObservabilityEndpoints();
+            this.app.get('*', (req, res) => {
+                const indexPath = path.join(distPath, 'index-test.html');
+                res.sendFile(indexPath);
+            });
+            this.server = this.app.listen(port, () => {
+                resolve();
+            });
+            this.server.on('error', (error) => {
+                if (error.code === 'EADDRINUSE') {
+                    reject(new Error(`Port ${port} is already in use`));
+                }
+                else {
+                    reject(error);
+                }
+            });
+        });
+    }
+    setupObservabilityEndpoints() {
+        if (!this.app)
+            return;
+        this.app.post('/api/v1/agents/execute', async (req, res) => {
+            try {
+                const { message, threadId, sessionId: bodySessionId } = req.body;
+                if (!message) {
+                    return res.status(400).json({
+                        success: false,
+                        error: 'message is required'
+                    });
+                }
+                const normalizedMessage = message.toLowerCase().trim();
+                if (normalizedMessage === 'ping' || normalizedMessage === 'pong') {
+                    return res.json({
+                        success: true,
+                        executionId: `ping-${Date.now()}`,
+                        message: 'pong',
+                        sessionId: 'ping-session',
+                        userId: 'ping-user',
+                        metadata: { isPing: true },
+                    });
+                }
+                const sessionId = this.generateSessionId(req, bodySessionId);
+                const userId = this.generateUserId(req, sessionId);
+                console.log(chalk_1.default.gray(`📨 [${new Date().toISOString()}] Executing agent...`));
+                console.log(chalk_1.default.gray(`   Message: ${message.substring(0, 50)}${message.length > 50 ? '...' : ''}`));
+                if (threadId) {
+                    console.log(chalk_1.default.gray(`   Thread: ${threadId}`));
+                }
+                console.log(chalk_1.default.gray(`   Session: ${sessionId}`));
+                const result = await this.executeAgent(message, threadId || sessionId, sessionId, userId);
+                console.log(chalk_1.default.green(`✓ [${new Date().toISOString()}] Agent executed successfully`));
+                console.log(chalk_1.default.gray(`   Execution ID: ${result.executionId}`));
+                console.log('');
+                res.setHeader('X-Session-ID', sessionId);
+                res.setHeader('X-User-ID', userId);
+                res.setHeader('X-Timestamp', new Date().toISOString());
+                res.setHeader('Set-Cookie', [
+                    `runflow_session=${sessionId}; Path=/; HttpOnly; SameSite=Lax`,
+                    `runflow_user=${userId}; Path=/; HttpOnly; SameSite=Lax`,
+                ]);
+                res.json({
+                    success: true,
+                    executionId: result.executionId,
+                    message: result.message,
+                    sessionId: sessionId,
+                    userId: userId,
+                    metadata: result.metadata,
+                });
+            }
+            catch (error) {
+                console.error(chalk_1.default.red(`❌ [${new Date().toISOString()}] Agent execution failed:`));
+                console.error(chalk_1.default.red(`   ${error.message}`));
+                console.log('');
+                res.status(500).json({
+                    success: false,
+                    error: error.message
+                });
             }
         });
-        this.server.stderr?.on('data', (data) => {
-            const error = data.toString();
-            if (verbose) {
-                process.stderr.write(`[SERVER-ERR] ${error}`);
+        this.app.get('/api/v1/observability/threads', async (req, res) => {
+            try {
+                const { agentId, threadId, limit = 50 } = req.query;
+                if (!agentId) {
+                    return res.status(400).json({ error: 'agentId is required' });
+                }
+                const threads = await this.getThreads(agentId, threadId, parseInt(limit));
+                res.json({ threads, total: threads.length });
             }
-            else {
-                const trimmed = error.trim();
-                if (trimmed.includes('Error:') || trimmed.includes('EADDRINUSE')) {
-                    console.error(chalk_1.default.red(`Server Error: ${trimmed}`));
+            catch (error) {
+                console.error(chalk_1.default.red(`❌ Error fetching threads: ${error.message}`));
+                res.status(500).json({ error: error.message });
+            }
+        });
+        this.app.get('/api/v1/observability/threads/:threadId/executions', async (req, res) => {
+            try {
+                const { threadId } = req.params;
+                const { agentId } = req.query;
+                if (!agentId) {
+                    return res.status(400).json({ error: 'agentId is required' });
                 }
+                const result = await this.getThreadExecutions(agentId, threadId);
+                res.json(result);
+            }
+            catch (error) {
+                console.error(chalk_1.default.red(`❌ Error fetching executions: ${error.message}`));
+                res.status(500).json({ error: error.message });
             }
         });
-        this.server.on('error', (error) => {
-            console.error(chalk_1.default.red(`Failed to start server: ${error.message}`));
+        this.app.get('/api/v1/observability/executions/:executionId', async (req, res) => {
+            try {
+                const { executionId } = req.params;
+                const { agentId } = req.query;
+                if (!agentId) {
+                    return res.status(400).json({ error: 'agentId is required' });
+                }
+                const result = await this.getExecutionTraces(agentId, executionId);
+                if (!result) {
+                    return res.status(404).json({ error: 'Execution not found' });
+                }
+                res.json(result);
+            }
+            catch (error) {
+                console.error(chalk_1.default.red(`❌ Error fetching execution: ${error.message}`));
+                res.status(500).json({ error: error.message });
+            }
         });
-        await this.waitForServer(port, 10000);
     }
-    async startFrontend(frontendPort, backendPort, verbose, spinner) {
-        if (spinner) {
-            spinner.text = 'Starting frontend...';
-        }
-        else {
-            console.log('🎨 Starting frontend...');
+    async getThreads(agentId, threadId, limit = 50) {
+        const threads = [];
+        const files = this.getAllTraceFiles();
+        for (const filePath of files) {
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const data = JSON.parse(content);
+                if (data.agentId !== agentId)
+                    continue;
+                for (const [tid, threadData] of Object.entries(data.threads || {})) {
+                    if (threadId && tid !== threadId)
+                        continue;
+                    const td = threadData;
+                    const executions = td.executions || [];
+                    const lastExecution = executions[executions.length - 1];
+                    threads.push({
+                        id: `thread-${tid}`,
+                        executionId: lastExecution?.executionId,
+                        threadId: tid,
+                        tenantId: 'local',
+                        agentId: data.agentId,
+                        entityType: td.entityType || 'email',
+                        entityValue: td.entityValue || tid,
+                        userId: td.userId || null,
+                        sessionId: data.sessionId,
+                        channel: td.channel || 'sdk',
+                        source: td.source || 'local',
+                        inputMessage: lastExecution?.inputMessage,
+                        outputMessage: lastExecution?.outputMessage,
+                        totalTraces: executions.reduce((sum, e) => sum + (e.traces?.length || 0), 0),
+                        totalDurationMs: executions.reduce((sum, e) => sum + (e.totalDurationMs || 0), 0),
+                        totalTokens: executions.reduce((sum, e) => sum + (e.totalTokens || 0), 0),
+                        totalCostUsd: executions.reduce((sum, e) => sum + (e.totalCostUsd || 0), 0),
+                        status: lastExecution?.status || 'pending',
+                        error: lastExecution?.error || null,
+                        startedAt: executions[0]?.startedAt,
+                        completedAt: lastExecution?.completedAt,
+                        createdAt: executions[0]?.startedAt,
+                    });
+                }
+            }
+            catch (error) {
+            }
         }
-        const cliRootDir = path.join(__dirname, '..', '..', '..');
-        const staticDir = path.join(cliRootDir, 'static');
-        if (!fs.existsSync(staticDir)) {
-            throw new Error('Static frontend files not found. Please ensure the CLI is properly installed.');
+        const sdkThreads = this.getSDKTraces(agentId);
+        const filteredSDKThreads = threadId
+            ? sdkThreads.filter(t => t.threadId === threadId)
+            : sdkThreads;
+        threads.push(...filteredSDKThreads);
+        return threads
+            .sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime())
+            .slice(0, limit);
+    }
+    async getThreadExecutions(agentId, threadId) {
+        const executions = [];
+        const files = this.getAllTraceFiles();
+        for (const filePath of files) {
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const data = JSON.parse(content);
+                if (data.agentId !== agentId)
+                    continue;
+                const threadData = data.threads?.[threadId];
+                if (threadData?.executions) {
+                    const formattedExecutions = threadData.executions.map((e) => ({
+                        id: e.executionId,
+                        executionId: e.executionId,
+                        threadId: threadId,
+                        tenantId: 'local',
+                        agentId: data.agentId,
+                        entityType: threadData.entityType || 'email',
+                        entityValue: threadData.entityValue || threadId,
+                        userId: threadData.userId || null,
+                        sessionId: data.sessionId,
+                        channel: threadData.channel || 'sdk',
+                        source: threadData.source || 'local',
+                        inputMessage: e.inputMessage,
+                        outputMessage: e.outputMessage,
+                        totalTraces: e.traces?.length || 0,
+                        totalDurationMs: e.totalDurationMs || 0,
+                        totalTokens: e.totalTokens || 0,
+                        totalCostUsd: e.totalCostUsd || 0,
+                        status: e.status || 'pending',
+                        error: e.error || null,
+                        startedAt: e.startedAt,
+                        completedAt: e.completedAt,
+                        createdAt: e.startedAt,
+                    }));
+                    executions.push(...formattedExecutions);
+                }
+            }
+            catch (error) {
+            }
         }
-        const runflowDir = path.join(process.cwd(), '.runflow');
-        const frontendDir = path.join(runflowDir, 'test-frontend');
-        if (!fs.existsSync(frontendDir)) {
-            fs.mkdirSync(frontendDir, { recursive: true });
+        const sdkThreads = this.getSDKTraces(agentId);
+        const sdkThread = sdkThreads.find(t => t.threadId === threadId);
+        if (sdkThread && sdkThread._sdkExecutions) {
+            const formattedExecutions = sdkThread._sdkExecutions.map((e) => ({
+                id: e.executionId,
+                executionId: e.executionId,
+                threadId: threadId,
+                tenantId: 'local',
+                agentId: agentId,
+                entityType: sdkThread.entityType,
+                entityValue: sdkThread.entityValue,
+                userId: sdkThread.userId,
+                sessionId: e.executionId,
+                channel: 'sdk',
+                source: 'local',
+                inputMessage: e.inputMessage,
+                outputMessage: e.outputMessage,
+                totalTraces: e.traces?.length || 0,
+                totalDurationMs: e.totalDurationMs,
+                totalTokens: e.totalTokens,
+                totalCostUsd: e.totalCostUsd,
+                status: e.status,
+                error: e.error || null,
+                startedAt: e.startedAt,
+                completedAt: e.completedAt,
+                createdAt: e.startedAt,
+            }));
+            executions.push(...formattedExecutions);
         }
-        const staticFiles = ['index.html', 'style.css', 'app.js'];
-        for (const file of staticFiles) {
-            const sourcePath = path.join(staticDir, file);
-            const destPath = path.join(frontendDir, file);
-            if (fs.existsSync(sourcePath)) {
-                fs.copyFileSync(sourcePath, destPath);
+        const sorted = executions.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+        return {
+            threadId,
+            executions: sorted,
+            total: sorted.length,
+        };
+    }
+    async getExecutionTraces(agentId, executionId) {
+        const files = this.getAllTraceFiles();
+        for (const filePath of files) {
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const data = JSON.parse(content);
+                if (data.agentId !== agentId)
+                    continue;
+                for (const [tid, threadData] of Object.entries(data.threads || {})) {
+                    const td = threadData;
+                    const execution = td.executions?.find((e) => e.executionId === executionId);
+                    if (execution) {
+                        const formattedExecution = {
+                            id: execution.executionId,
+                            executionId: execution.executionId,
+                            threadId: tid,
+                            tenantId: 'local',
+                            agentId: data.agentId,
+                            entityType: td.entityType || 'email',
+                            entityValue: td.entityValue || tid,
+                            userId: td.userId || null,
+                            sessionId: data.sessionId,
+                            channel: td.channel || 'sdk',
+                            source: td.source || 'local',
+                            inputMessage: execution.inputMessage,
+                            outputMessage: execution.outputMessage,
+                            totalTraces: execution.traces?.length || 0,
+                            totalDurationMs: execution.totalDurationMs || 0,
+                            totalTokens: execution.totalTokens || 0,
+                            totalCostUsd: execution.totalCostUsd || 0,
+                            status: execution.status || 'pending',
+                            error: execution.error || null,
+                            startedAt: execution.startedAt,
+                            completedAt: execution.completedAt,
+                            createdAt: execution.startedAt,
+                        };
+                        const traces = execution.traces || [];
+                        const formattedTraces = traces.map((t) => ({
+                            id: t.id || t.traceId,
+                            traceId: t.id || t.traceId,
+                            parentTraceId: t.parentId || null,
+                            executionId: execution.executionId,
+                            tenantId: 'local',
+                            agentId: data.agentId,
+                            threadId: tid,
+                            userId: td.userId || null,
+                            sessionId: data.sessionId,
+                            type: t.type,
+                            operation: t.name || t.type,
+                            status: t.status,
+                            error: t.error || null,
+                            input: t.input || null,
+                            output: t.output || null,
+                            metadata: t.metadata || {},
+                            startedAt: t.startedAt,
+                            completedAt: t.completedAt,
+                            durationMs: t.durationMs,
+                            tokensTotal: t.metadata?.totalTokens || t.metadata?.tokens || null,
+                            costUsd: t.metadata?.cost || null,
+                            createdAt: t.startedAt,
+                            children: t.children || [],
+                        }));
+                        return {
+                            execution: formattedExecution,
+                            traces: formattedTraces,
+                        };
+                    }
+                }
+            }
+            catch (error) {
             }
         }
-        const frontendTemplatePath = path.join(cliRootDir, 'static', 'frontend-server-template.js');
-        if (!fs.existsSync(frontendTemplatePath)) {
-            throw new Error('Frontend server template not found. Please ensure the CLI is properly installed.');
+        const sdkThreads = this.getSDKTraces(agentId);
+        for (const thread of sdkThreads) {
+            if (thread._sdkExecutions) {
+                const execution = thread._sdkExecutions.find((e) => e.executionId === executionId);
+                if (execution) {
+                    const formattedExecution = {
+                        id: execution.executionId,
+                        executionId: execution.executionId,
+                        threadId: thread.threadId,
+                        tenantId: 'local',
+                        agentId: agentId,
+                        entityType: thread.entityType,
+                        entityValue: thread.entityValue,
+                        userId: thread.userId,
+                        sessionId: execution.executionId,
+                        channel: 'sdk',
+                        source: 'local',
+                        inputMessage: execution.inputMessage,
+                        outputMessage: execution.outputMessage,
+                        totalTraces: this.countAllTraces(execution.traces),
+                        totalDurationMs: execution.totalDurationMs || 0,
+                        totalTokens: execution.totalTokens || 0,
+                        totalCostUsd: execution.totalCostUsd || 0,
+                        status: execution.status || 'success',
+                        error: execution.error || null,
+                        startedAt: execution.startedAt,
+                        completedAt: execution.completedAt,
+                        createdAt: execution.startedAt,
+                    };
+                    const formattedTraces = execution.traces || [];
+                    return {
+                        execution: formattedExecution,
+                        traces: formattedTraces,
+                    };
+                }
+            }
         }
-        this.frontend = (0, child_process_1.spawn)('node', [frontendTemplatePath], {
-            stdio: 'pipe',
-            env: {
-                ...process.env,
-                NODE_ENV: 'development',
-                RUNFLOW_FRONTEND_PORT: frontendPort.toString(),
-                RUNFLOW_STATIC_DIR: frontendDir,
-            },
-        });
-        this.frontend.stdout?.on('data', (data) => {
-            if (verbose) {
-                process.stdout.write(data.toString());
+        return null;
+    }
+    countAllTraces(traces) {
+        let count = traces.length;
+        traces.forEach((trace) => {
+            if (trace.children && trace.children.length > 0) {
+                count += this.countAllTraces(trace.children);
             }
         });
-        this.frontend.stderr?.on('data', (data) => {
-            if (verbose) {
-                process.stderr.write(data.toString());
+        return count;
+    }
+    getAllTraceFiles() {
+        const files = [];
+        if (!fs.existsSync(this.storageDir)) {
+            return files;
+        }
+        const dateDirs = fs.readdirSync(this.storageDir);
+        for (const dateDir of dateDirs) {
+            const datePath = path.join(this.storageDir, dateDir);
+            if (!fs.statSync(datePath).isDirectory())
+                continue;
+            const traceFiles = fs.readdirSync(datePath).filter((f) => f.endsWith('.json'));
+            for (const file of traceFiles) {
+                files.push(path.join(datePath, file));
             }
-        });
-        this.frontend.on('error', (error) => {
-            console.error(chalk_1.default.red(`Failed to start frontend: ${error.message}`));
-        });
-        await this.waitForServer(frontendPort, 5000);
+        }
+        return files;
     }
-    async waitForServer(port, timeout) {
-        const start = Date.now();
-        while (Date.now() - start < timeout) {
-            try {
-                const response = await fetch(`http://localhost:${port}/api/health`);
-                if (response.ok) {
-                    return;
+    getSDKTraces(agentId) {
+        const sdkTracesFile = path.join(process.cwd(), '.runflow', 'traces.json');
+        if (!fs.existsSync(sdkTracesFile)) {
+            return [];
+        }
+        try {
+            const content = fs.readFileSync(sdkTracesFile, 'utf-8');
+            const data = JSON.parse(content);
+            const threads = [];
+            const executionsMap = data.executions || {};
+            const threadGroups = {};
+            for (const [execId, execution] of Object.entries(executionsMap)) {
+                const exec = execution;
+                const threadId = exec.threadId || 'unknown';
+                if (!threadGroups[threadId]) {
+                    threadGroups[threadId] = {
+                        threadId: threadId,
+                        entityType: exec.entityType || 'session',
+                        entityValue: exec.entityValue || null,
+                        userId: exec.userId || null,
+                        channel: 'sdk',
+                        source: 'local',
+                        executions: [],
+                    };
                 }
+                const traces = exec.traces || [];
+                const agentTrace = traces.find((t) => t.type === 'agent_execution' &&
+                    !t.parentTraceId &&
+                    t.operation === 'agent_execution') || traces.find((t) => t.type === 'agent_execution' &&
+                    !t.parentTraceId) || traces.find((t) => t.type === 'agent_execution');
+                const tracesWithChildren = this.buildTraceHierarchy(traces);
+                const executionData = {
+                    executionId: exec.executionId,
+                    inputMessage: agentTrace?.input?.message || 'N/A',
+                    outputMessage: agentTrace?.output?.message || 'N/A',
+                    status: exec.status || 'success',
+                    totalDurationMs: traces.reduce((sum, t) => sum + (t.duration || 0), 0),
+                    totalTokens: traces.reduce((sum, t) => sum + (t.metadata?.totalTokens || 0), 0),
+                    totalCostUsd: 0,
+                    startedAt: exec.startedAt || agentTrace?.startTime,
+                    completedAt: agentTrace?.endTime || exec.completedAt,
+                    traces: tracesWithChildren,
+                };
+                threadGroups[threadId].executions.push(executionData);
             }
-            catch (error) {
+            for (const [threadId, threadData] of Object.entries(threadGroups)) {
+                const td = threadData;
+                const lastExecution = td.executions[td.executions.length - 1];
+                threads.push({
+                    id: `thread-${threadId}`,
+                    executionId: lastExecution?.executionId,
+                    threadId: threadId,
+                    tenantId: 'local',
+                    agentId: agentId,
+                    entityType: td.entityType,
+                    entityValue: td.entityValue,
+                    userId: td.userId,
+                    sessionId: lastExecution?.executionId,
+                    channel: td.channel,
+                    source: td.source,
+                    inputMessage: lastExecution?.inputMessage,
+                    outputMessage: lastExecution?.outputMessage,
+                    totalTraces: td.executions.reduce((sum, e) => sum + (e.traces?.length || 0), 0),
+                    totalDurationMs: td.executions.reduce((sum, e) => sum + (e.totalDurationMs || 0), 0),
+                    totalTokens: td.executions.reduce((sum, e) => sum + (e.totalTokens || 0), 0),
+                    totalCostUsd: td.executions.reduce((sum, e) => sum + (e.totalCostUsd || 0), 0),
+                    status: lastExecution?.status || 'success',
+                    error: lastExecution?.error || null,
+                    startedAt: td.executions[0]?.startedAt,
+                    completedAt: lastExecution?.completedAt,
+                    createdAt: td.executions[0]?.startedAt,
+                    _sdkExecutions: td.executions,
+                });
             }
-            await new Promise((resolve) => setTimeout(resolve, 500));
+            return threads;
+        }
+        catch (error) {
+            console.error(chalk_1.default.yellow('⚠️  Failed to read SDK traces.json:'), error.message);
+            return [];
         }
-        throw new Error(`Server on port ${port} failed to start`);
     }
-    async runCommand(command, args, options = {}) {
-        return new Promise((resolve, reject) => {
-            const child = (0, child_process_1.spawn)(command, args, options);
-            child.on('close', (code) => {
-                if (code === 0) {
-                    resolve();
+    buildTraceHierarchy(traces) {
+        const traceMap = new Map();
+        traces.forEach((t) => {
+            traceMap.set(t.traceId, {
+                id: t.traceId,
+                traceId: t.traceId,
+                parentTraceId: t.parentTraceId || null,
+                type: t.type,
+                operation: t.operation,
+                status: t.status,
+                startedAt: t.startTime,
+                completedAt: t.endTime,
+                durationMs: t.duration,
+                input: t.input,
+                output: t.output,
+                metadata: t.metadata,
+                children: [],
+            });
+        });
+        const rootTraces = [];
+        traces.forEach((t) => {
+            const node = traceMap.get(t.traceId);
+            if (t.parentTraceId) {
+                const parent = traceMap.get(t.parentTraceId);
+                if (parent) {
+                    parent.children.push(node);
                 }
                 else {
-                    reject(new Error(`Command failed with code ${code}`));
+                    rootTraces.push(node);
                 }
-            });
-            child.on('error', reject);
+            }
+            else {
+                rootTraces.push(node);
+            }
         });
+        return rootTraces;
     }
     openBrowser(url) {
+        const { spawn } = require('child_process');
         const start = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
         const spawnOptions = { detached: true, stdio: 'ignore' };
         if (process.platform === 'win32') {
             spawnOptions.shell = true;
         }
-        (0, child_process_1.spawn)(start, [url], spawnOptions);
+        spawn(start, [url], spawnOptions);
     }
     setupCleanupHandlers() {
         const cleanup = async () => {
-            console.log(chalk_1.default.yellow('\n🛑 Shutting down test environment...'));
+            console.log(chalk_1.default.yellow('\n🛑 Shutting down server...'));
             await this.cleanup();
             process.exit(0);
         };
         process.on('SIGINT', cleanup);
         process.on('SIGTERM', cleanup);
-        process.on('exit', () => this.cleanup());
     }
     async cleanup() {
         if (this.server) {
-            this.server.kill('SIGTERM');
+            this.server.close(() => {
+                console.log(chalk_1.default.gray('✓ Server stopped'));
+            });
             this.server = null;
         }
-        if (this.frontend) {
-            this.frontend.kill('SIGTERM');
-            this.frontend = null;
-        }
-        const runflowDir = path.join(process.cwd(), '.runflow');
-        const frontendDir = path.join(runflowDir, 'test-frontend');
-        if (fs.existsSync(frontendDir)) {
-            try {
-                fs.rmSync(frontendDir, { recursive: true, force: true });
-                console.log('🧹 Cleaned up temporary files');
-            }
-            catch (error) {
-            }
-        }
     }
     async keepAlive() {
         return new Promise(() => {
@@ -349,7 +858,7 @@ exports.TestCommand = TestCommand;
 __decorate([
     (0, nest_commander_1.Option)({
         flags: '-p, --port <port>',
-        description: 'Port for the test server (default: 8547)',
+        description: 'Base port for the server (default: random between 3000-4000)',
     }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String]),
@@ -357,36 +866,18 @@ __decorate([
 ], TestCommand.prototype, "parsePort", null);
 __decorate([
     (0, nest_commander_1.Option)({
-        flags: '-h, --host <host>',
-        description: 'Host for the server (default: localhost)',
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", String)
-], TestCommand.prototype, "parseHost", null);
-__decorate([
-    (0, nest_commander_1.Option)({
-        flags: '--no-open',
+        flags: '--no-browser',
         description: "Don't open browser automatically",
     }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Boolean)
-], TestCommand.prototype, "parseOpen", null);
-__decorate([
-    (0, nest_commander_1.Option)({
-        flags: '--verbose',
-        description: 'Show detailed logs',
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Boolean)
-], TestCommand.prototype, "parseVerbose", null);
+], TestCommand.prototype, "parseNoBrowser", null);
 exports.TestCommand = TestCommand = __decorate([
     (0, common_1.Injectable)(),
     (0, nest_commander_1.Command)({
         name: 'test',
-        description: '🧪 Start local test server for Runflow agents with live reload',
+        description: '🧪 Start local observability server and open test portal',
     })
 ], TestCommand);
 //# sourceMappingURL=test.command.js.map