aiexecode 1.0.157

package/payload_viewer/web_server.js

@@ -0,0 +1,861 @@
+import express from 'express';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import OpenAI from 'openai';
+import Anthropic from '@anthropic-ai/sdk';
+function consolelog() { }
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Get home directory
+function getHomeDirectory() {
+    return process.env.HOME || process.env.USERPROFILE || '/home/ubuntu';
+}
+
+// Get AI Agent config directory
+const CONFIG_DIR = path.join(getHomeDirectory(), '.aiexe');
+const PAYLOAD_LOG_DIR = path.join(CONFIG_DIR, 'payload_log');
+
+// Load AI Agent settings
+function loadAIAgentSettings() {
+    try {
+        const settingsPath = path.join(CONFIG_DIR, 'settings.json');
+        if (fs.existsSync(settingsPath)) {
+            const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+            consolelog('✅ AI Agent settings loaded from ~/.aiexe/settings.json');
+            return settings;
+        }
+    } catch (error) {
+        consolelog('⚠️  Could not load AI Agent settings:', error.message);
+    }
+    return {};
+}
+
+const aiAgentSettings = loadAIAgentSettings();
+
+// Initialize OpenAI client (check multiple sources for API key)
+let openai = null;
+const openaiApiKey = process.env.OPENAI_API_KEY || aiAgentSettings.OPENAI_API_KEY;
+
+if (openaiApiKey) {
+    openai = new OpenAI({
+        apiKey: openaiApiKey,
+    });
+    consolelog('✅ OpenAI client initialized');
+} else {
+    consolelog('⚠️  OpenAI API key not found - API testing will return mock responses');
+    consolelog('   Checked: process.env.OPENAI_API_KEY and ~/.aiexe/settings.json');
+}
+
+// Initialize Z.AI client (Anthropic SDK with Z.AI base URL)
+let zaiClient = null;
+const zaiApiKey = process.env.ZAI_API_KEY || aiAgentSettings.API_KEY;
+const ZAI_BASE_URL = 'https://api.z.ai/api/anthropic';
+
+// Check if API key is Z.AI format (32-char hex + '.' + 16-char alphanumeric)
+function isZaiApiKey(apiKey) {
+    if (!apiKey || typeof apiKey !== 'string') return false;
+    return /^[a-f0-9]{32}\.[A-Za-z0-9]{16}$/.test(apiKey);
+}
+
+if (zaiApiKey && isZaiApiKey(zaiApiKey)) {
+    zaiClient = new Anthropic({
+        apiKey: zaiApiKey,
+        baseURL: ZAI_BASE_URL,
+    });
+    consolelog('✅ Z.AI client initialized (Anthropic SDK with Z.AI base URL)');
+} else {
+    consolelog('⚠️  Z.AI API key not found or invalid format - Z.AI testing will return mock responses');
+}
+
+// Initialize Anthropic client
+let anthropicClient = null;
+const anthropicApiKey = process.env.ANTHROPIC_API_KEY || aiAgentSettings.ANTHROPIC_API_KEY;
+
+// Check if API key is Anthropic format (sk-ant-...)
+function isAnthropicApiKey(apiKey) {
+    if (!apiKey || typeof apiKey !== 'string') return false;
+    return apiKey.startsWith('sk-ant-');
+}
+
+if (anthropicApiKey && isAnthropicApiKey(anthropicApiKey)) {
+    anthropicClient = new Anthropic({
+        apiKey: anthropicApiKey,
+    });
+    consolelog('✅ Anthropic client initialized');
+} else {
+    consolelog('⚠️  Anthropic API key not found or invalid format - Anthropic testing will return mock responses');
+}
+
+
+// ID generation function
+function generateId() {
+    return Math.random().toString(36).substring(2, 12) + Date.now().toString(36);
+}
+
+function startWebServer(port = 3000) {
+    const app = express();
+
+    // Parse JSON bodies (increase limit for large AI request/response payloads)
+    app.use(express.json({ limit: '50mb' }));
+
+    // Serve static files from Next.js build
+    const outPath = path.join(__dirname, 'out');
+    const isProduction = true; // Always production mode
+
+    // Serve all static files from 'out' directory (Next.js export output)
+    if (fs.existsSync(outPath)) {
+        app.use(express.static(outPath));
+        consolelog(`📁 Serving Next.js static files from: ${outPath}`);
+    } else {
+        consolelog(`⚠️  Warning: 'out' directory not found at ${outPath}`);
+        consolelog(`   Please run: npm run build`);
+    }
+
+    // Helper function to parse log filename
+    function parseLogFileName(fileName) {
+        const match = fileName.match(/^(\d{4}-\d{2}-\d{2})_(\d{9})_(.+)_(REQ|RES)\.json$/);
+
+        if (match) {
+            const [, date, timestamp, component, type] = match;
+            const hour = timestamp.substring(0, 2);
+            const minute = timestamp.substring(2, 4);
+            const second = timestamp.substring(4, 6);
+            const millisecond = timestamp.substring(6, 9);
+
+            return {
+                date,
+                timestamp,
+                component,
+                type,
+                datetime: new Date(`${date}T${hour}:${minute}:${second}.${millisecond}Z`)
+            };
+        }
+
+        return null;
+    }
+
+    // Helper function to create workflow groups (improved version from payload_viewer_old)
+    function createWorkflowGroups(files) {
+        const workflows = new Map();
+
+        files.forEach(file => {
+            if (!file.parsedInfo) return;
+
+            const { date, timestamp } = file.parsedInfo;
+            const workflowKey = `${date}_${timestamp.substring(0, 6)}`; // Group by date and time up to seconds
+
+            if (!workflows.has(workflowKey)) {
+                workflows.set(workflowKey, {
+                    id: workflowKey,
+                    date: date,
+                    startTime: file.parsedInfo.datetime,
+                    files: [],
+                    components: new Set(),
+                    status: 'unknown'
+                });
+            }
+
+            const workflow = workflows.get(workflowKey);
+            workflow.files.push(file);
+            workflow.components.add(file.parsedInfo.component);
+
+            // Determine workflow status
+            if (workflow.files.some(f => f.parsedInfo.component === 'verifier' && f.parsedInfo.type === 'RES')) {
+                workflow.status = 'completed';
+            } else if (workflow.files.length > 0) {
+                workflow.status = 'in_progress';
+            }
+        });
+
+        // Convert Map to array and sort by time
+        return Array.from(workflows.values())
+            .sort((a, b) => b.startTime - a.startTime)
+            .map(workflow => ({
+                ...workflow,
+                components: Array.from(workflow.components),
+                duration: calculateWorkflowDuration(workflow.files),
+                startTime: workflow.startTime,
+                endTime: workflow.files.length > 0 ?
+                    new Date(Math.max(...workflow.files.map(f => f.parsedInfo ? new Date(f.parsedInfo.datetime).getTime() : 0))).toISOString() :
+                    workflow.startTime
+            }));
+    }
+
+    // Helper function to calculate workflow duration
+    function calculateWorkflowDuration(files) {
+        if (files.length < 2) return 0;
+
+        const times = files
+            .filter(f => f.parsedInfo)
+            .map(f => new Date(f.parsedInfo.datetime))
+            .sort((a, b) => a.getTime() - b.getTime());
+
+        if (times.length < 2) return 0;
+
+        return times[times.length - 1].getTime() - times[0].getTime();
+    }
+
+    // API routes for payload logs
+    app.get('/api/logs', (req, res) => {
+        try {
+            const logDir = PAYLOAD_LOG_DIR;
+            if (!fs.existsSync(logDir)) {
+                return res.json({ files: [], workflows: [] });
+            }
+
+            const files = fs.readdirSync(logDir)
+                .filter(file => file.endsWith('.json'))
+                .map(file => {
+                    const filePath = path.join(logDir, file);
+                    const stats = fs.statSync(filePath);
+                    const parsedInfo = parseLogFileName(file);
+
+                    const fileInfo = {
+                        name: file,
+                        size: stats.size,
+                        modified: stats.mtime.toISOString(),
+                        created: stats.birthtime.toISOString(),
+                        extension: path.extname(file),
+                        parsedInfo: parsedInfo || undefined
+                    };
+
+                    // Convert datetime to ISO string if it exists
+                    if (fileInfo.parsedInfo && fileInfo.parsedInfo.datetime) {
+                        fileInfo.parsedInfo.datetime = fileInfo.parsedInfo.datetime.toISOString();
+                    }
+
+                    return fileInfo;
+                });
+
+            // Sort files by time
+            files.sort((a, b) => {
+                const timeA = a.parsedInfo?.datetime ? new Date(a.parsedInfo.datetime) : new Date(a.created);
+                const timeB = b.parsedInfo?.datetime ? new Date(b.parsedInfo.datetime) : new Date(b.created);
+                return timeB.getTime() - timeA.getTime();
+            });
+
+            const workflows = createWorkflowGroups(files);
+
+            res.json({ files, workflows });
+        } catch (error) {
+            consolelog('Error reading log files:', error);
+            res.status(500).json({ error: 'Failed to read log files' });
+        }
+    });
+
+    app.get('/api/logs/:filename', (req, res) => {
+        try {
+            const filename = decodeURIComponent(req.params.filename);
+            const filePath = path.join(PAYLOAD_LOG_DIR, filename);
+
+            // Security check
+            if (!filePath.startsWith(PAYLOAD_LOG_DIR)) {
+                return res.status(400).json({ error: 'Invalid file path' });
+            }
+
+            if (!fs.existsSync(filePath)) {
+                return res.status(404).json({ error: 'File not found' });
+            }
+
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const data = JSON.parse(content);
+            res.json(data);
+        } catch (error) {
+            consolelog('Error reading file:', error);
+            if (error instanceof SyntaxError) {
+                res.status(400).json({ error: 'Invalid JSON file' });
+            } else {
+                res.status(500).json({ error: 'Failed to read file' });
+            }
+        }
+    });
+
+    app.put('/api/logs/:filename', (req, res) => {
+        try {
+            const filename = decodeURIComponent(req.params.filename);
+            const filePath = path.join(PAYLOAD_LOG_DIR, filename);
+
+            // Security check
+            if (!filePath.startsWith(PAYLOAD_LOG_DIR)) {
+                return res.status(400).json({ error: 'Invalid file path' });
+            }
+
+            const body = JSON.stringify(req.body, null, 2);
+
+            // Backup original file
+            const backupPath = `${filePath}.backup.${Date.now()}`;
+            if (fs.existsSync(filePath)) {
+                fs.copyFileSync(filePath, backupPath);
+            }
+
+            // Save file
+            fs.writeFileSync(filePath, body, 'utf-8');
+
+            res.json({ success: true });
+        } catch (error) {
+            consolelog('Error saving file:', error);
+            res.status(500).json({ error: 'Failed to save file' });
+        }
+    });
+
+    // OpenAI API test endpoint
+    app.post('/api/test-openai', async (req, res) => {
+        try {
+            const payload = req.body;
+
+            // Actual OpenAI API call (if API key is available)
+            if (openai && openaiApiKey) {
+                // Use OpenAI responses.create (pass payload as is)
+                let response = await openai.responses.create(payload);
+                let allToolOutputs = [];
+                let currentPayload = payload;
+                let allResponses = [response];
+
+                // Handle function_calls iteratively
+                let maxIterations = 10; // Prevent infinite loops
+                let iteration = 0;
+                let hasProcessedFunctionCalls = false;
+
+                // Process function_calls while they exist
+                while (iteration < maxIterations) {
+                    // Check response structure (response or response.data)
+                    const responseData = response.data || response;
+
+                    if (!responseData || !responseData.output || !Array.isArray(responseData.output)) {
+                        break;
+                    }
+
+                    const functionCalls = responseData.output.filter(item => item.type === 'function_call');
+
+                    if (functionCalls.length === 0) {
+                        if (hasProcessedFunctionCalls) {
+                            break; // No more function_calls to execute
+                        } else {
+                            break; // No function_calls in first response
+                        }
+                    }
+
+                    hasProcessedFunctionCalls = true;
+                    const currentIterationOutputs = [];
+
+                    // Execute each function_call sequentially
+                    for (const functionCall of functionCalls) {
+                        try {
+                            // Mock function execution for now
+                            const toolOutput = {
+                                tool_call_id: functionCall.call_id || functionCall.id || generateId(),
+                                output: JSON.stringify({
+                                    result: "Mock function execution result",
+                                    status: "success",
+                                    timestamp: new Date().toISOString()
+                                })
+                            };
+                            currentIterationOutputs.push(toolOutput);
+                            allToolOutputs.push(toolOutput);
+                        } catch (error) {
+                            consolelog(`Function call execution failed: ${error.message}`);
+                            const errorOutput = {
+                                tool_call_id: functionCall.call_id || functionCall.id || generateId(),
+                                output: JSON.stringify({
+                                    error: `Execution failed: ${error.message}`,
+                                    status: "failed",
+                                    timestamp: new Date().toISOString()
+                                })
+                            };
+                            currentIterationOutputs.push(errorOutput);
+                            allToolOutputs.push(errorOutput);
+                        }
+                    }
+
+                    // Continuation request with tool_outputs
+                    if (currentIterationOutputs.length > 0) {
+                        currentPayload = {
+                            ...payload,
+                            tool_outputs: [...allToolOutputs],
+                            response_id: response?.id || responseData?.id,
+                            messages: [
+                                ...(payload.messages || []),
+                            ]
+                        };
+
+                        try {
+                            response = await openai.responses.create(currentPayload);
+                            allResponses.push(response);
+                            iteration++;
+                        } catch (error) {
+                            consolelog(`Continuation request failed: ${error.message}`);
+                            break;
+                        }
+                    } else {
+                        break;
+                    }
+                }
+
+                // Final response composition
+                const finalResponse = allResponses[0];
+                const finalResponseData = finalResponse.data || finalResponse;
+
+                res.json({
+                    success: true,
+                    provider: 'openai',
+                    status: 200,
+                    data: {
+                        ...finalResponseData,
+                        provider: 'openai',
+                        tool_outputs: allToolOutputs,
+                        all_responses: allResponses,
+                        iterations_executed: iteration,
+                        function_calls_processed: allToolOutputs.length
+                    },
+                    tool_outputs: allToolOutputs,
+                    iterations: iteration,
+                    originalPayload: payload,
+                    convertedPayload: payload
+                });
+            } else {
+                // Mock response when API key is not available
+                res.json({
+                    success: false,
+                    provider: 'openai',
+                    error: 'OPENAI_API_KEY environment variable not set',
+                    mockResponse: {
+                        taskName: "api_test_RES",
+                        timestamp: new Date().toISOString(),
+                        data: {
+                            id: `resp_${generateId()}`,
+                            object: "response",
+                            created_at: Math.floor(Date.now() / 1000),
+                            status: "completed",
+                            model: payload.model || 'gpt-5-mini',
+                            provider: 'openai',
+                            output: [{
+                                id: `msg_${generateId()}`,
+                                type: "message",
+                                status: "completed",
+                                content: [{
+                                    type: "output_text",
+                                    text: 'This is a mock response. Set OPENAI_API_KEY to get real responses.'
+                                }],
+                                role: "assistant"
+                            }],
+                            usage: {
+                                input_tokens: 10,
+                                output_tokens: 15,
+                                total_tokens: 25
+                            }
+                        }
+                    },
+                    originalPayload: payload
+                });
+            }
+        } catch (error) {
+            res.status(500).json({
+                success: false,
+                provider: 'openai',
+                error: error.message,
+                originalPayload: req.body
+            });
+        }
+    });
+
+    // Anthropic API test endpoint
+    app.post('/api/test-anthropic', async (req, res) => {
+        try {
+            const payload = req.body;
+
+            if (anthropicClient && anthropicApiKey && isAnthropicApiKey(anthropicApiKey)) {
+                // Convert Responses API format to Anthropic Messages API format if needed
+                let anthropicPayload = { ...payload };
+
+                // If payload uses Responses API format (input array), convert to messages
+                if (payload.input && Array.isArray(payload.input)) {
+                    const messages = [];
+                    let systemMessage = null;
+
+                    for (const item of payload.input) {
+                        if (item.role === 'system') {
+                            if (Array.isArray(item.content)) {
+                                systemMessage = item.content.map(c => c.text || c).join('\n');
+                            } else if (typeof item.content === 'string') {
+                                systemMessage = item.content;
+                            }
+                        } else if (item.role === 'user' || item.role === 'assistant') {
+                            let content;
+                            if (Array.isArray(item.content)) {
+                                content = item.content.map(c => ({
+                                    type: 'text',
+                                    text: c.text || c
+                                }));
+                            } else {
+                                content = [{ type: 'text', text: item.content || '' }];
+                            }
+                            messages.push({ role: item.role, content });
+                        }
+                    }
+
+                    anthropicPayload = {
+                        model: payload.model || 'claude-3-haiku-20240307',
+                        max_tokens: payload.max_output_tokens || payload.max_tokens || 4096,
+                        messages: messages,
+                    };
+
+                    if (systemMessage) {
+                        anthropicPayload.system = systemMessage;
+                    }
+                }
+
+                // Ensure required fields
+                if (!anthropicPayload.model) anthropicPayload.model = 'claude-3-haiku-20240307';
+                if (!anthropicPayload.max_tokens) anthropicPayload.max_tokens = 4096;
+
+                // Make the API call
+                const response = await anthropicClient.messages.create(anthropicPayload);
+
+                // Convert Anthropic response to Responses API format
+                const output = [];
+                let outputText = '';
+
+                if (response.content && Array.isArray(response.content)) {
+                    for (const block of response.content) {
+                        if (block.type === 'text') {
+                            outputText += block.text;
+                        } else if (block.type === 'tool_use') {
+                            output.push({
+                                type: 'function_call',
+                                id: block.id,
+                                call_id: block.id,
+                                name: block.name,
+                                arguments: JSON.stringify(block.input)
+                            });
+                        }
+                    }
+                }
+
+                if (outputText) {
+                    output.unshift({
+                        type: 'message',
+                        id: `msg_${generateId()}`,
+                        status: 'completed',
+                        role: 'assistant',
+                        content: [{
+                            type: 'output_text',
+                            text: outputText
+                        }]
+                    });
+                }
+
+                const convertedResponse = {
+                    id: response.id,
+                    object: 'response',
+                    created_at: Math.floor(Date.now() / 1000),
+                    status: response.stop_reason === 'end_turn' ? 'completed' : 'incomplete',
+                    model: response.model,
+                    provider: 'anthropic',
+                    output: output,
+                    usage: {
+                        input_tokens: response.usage?.input_tokens || 0,
+                        output_tokens: response.usage?.output_tokens || 0,
+                        total_tokens: (response.usage?.input_tokens || 0) + (response.usage?.output_tokens || 0),
+                        cache_creation_input_tokens: response.usage?.cache_creation_input_tokens,
+                        cache_read_input_tokens: response.usage?.cache_read_input_tokens
+                    },
+                    stop_reason: response.stop_reason
+                };
+
+                res.json({
+                    success: true,
+                    provider: 'anthropic',
+                    status: 200,
+                    data: convertedResponse,
+                    originalPayload: payload,
+                    convertedPayload: anthropicPayload,
+                    rawResponse: response
+                });
+            } else {
+                // Mock response when API key is not available
+                res.json({
+                    success: false,
+                    provider: 'anthropic',
+                    error: 'Anthropic API key not found or invalid format',
+                    hint: 'Anthropic API key format: sk-ant-...',
+                    mockResponse: {
+                        taskName: "api_test_RES",
+                        timestamp: new Date().toISOString(),
+                        data: {
+                            id: `resp_${generateId()}`,
+                            object: "response",
+                            created_at: Math.floor(Date.now() / 1000),
+                            status: "completed",
+                            model: payload.model || 'claude-3-haiku-20240307',
+                            provider: 'anthropic',
+                            output: [{
+                                id: `msg_${generateId()}`,
+                                type: "message",
+                                status: "completed",
+                                content: [{
+                                    type: "output_text",
+                                    text: 'This is a mock response. Set a valid Anthropic API key to get real responses.'
+                                }],
+                                role: "assistant"
+                            }],
+                            usage: {
+                                input_tokens: 10,
+                                output_tokens: 15,
+                                total_tokens: 25
+                            }
+                        }
+                    },
+                    originalPayload: payload
+                });
+            }
+        } catch (error) {
+            res.status(500).json({
+                success: false,
+                provider: 'anthropic',
+                error: error.message,
+                originalPayload: req.body
+            });
+        }
+    });
+
+    // Z.AI (GLM) API test endpoint - Uses Anthropic SDK with Z.AI base URL
+    app.post('/api/test-zai', async (req, res) => {
+        try {
+            const payload = req.body;
+
+            if (zaiClient && zaiApiKey && isZaiApiKey(zaiApiKey)) {
+                // Convert Responses API format to Anthropic Messages API format if needed
+                let zaiPayload = { ...payload };
+
+                // If payload uses Responses API format (input array), convert to messages
+                if (payload.input && Array.isArray(payload.input)) {
+                    const messages = [];
+                    let systemMessage = null;
+
+                    for (const item of payload.input) {
+                        if (item.role === 'system') {
+                            // Extract system message content
+                            if (Array.isArray(item.content)) {
+                                systemMessage = item.content.map(c => c.text || c).join('\n');
+                            } else if (typeof item.content === 'string') {
+                                systemMessage = item.content;
+                            }
+                        } else if (item.role === 'user' || item.role === 'assistant') {
+                            let content;
+                            if (Array.isArray(item.content)) {
+                                content = item.content.map(c => ({
+                                    type: 'text',
+                                    text: c.text || c
+                                }));
+                            } else {
+                                content = [{ type: 'text', text: item.content || '' }];
+                            }
+                            messages.push({ role: item.role, content });
+                        }
+                    }
+
+                    zaiPayload = {
+                        model: payload.model || 'glm-4.5',
+                        max_tokens: payload.max_output_tokens || payload.max_tokens || 8192,
+                        messages: messages,
+                    };
+
+                    if (systemMessage) {
+                        zaiPayload.system = systemMessage;
+                    }
+                }
+
+                // Ensure required fields
+                if (!zaiPayload.model) zaiPayload.model = 'glm-4.5';
+                if (!zaiPayload.max_tokens) zaiPayload.max_tokens = 8192;
+
+                // Make the API call
+                const response = await zaiClient.messages.create(zaiPayload);
+
+                // Convert Anthropic response to Responses API format
+                const output = [];
+                let outputText = '';
+
+                if (response.content && Array.isArray(response.content)) {
+                    for (const block of response.content) {
+                        if (block.type === 'text') {
+                            outputText += block.text;
+                        } else if (block.type === 'tool_use') {
+                            output.push({
+                                type: 'function_call',
+                                id: block.id,
+                                call_id: block.id,
+                                name: block.name,
+                                arguments: JSON.stringify(block.input)
+                            });
+                        }
+                    }
+                }
+
+                if (outputText) {
+                    output.unshift({
+                        type: 'message',
+                        id: `msg_${generateId()}`,
+                        status: 'completed',
+                        role: 'assistant',
+                        content: [{
+                            type: 'output_text',
+                            text: outputText
+                        }]
+                    });
+                }
+
+                const convertedResponse = {
+                    id: response.id,
+                    object: 'response',
+                    created_at: Math.floor(Date.now() / 1000),
+                    status: response.stop_reason === 'end_turn' ? 'completed' : 'incomplete',
+                    model: response.model,
+                    provider: 'zai',
+                    output: output,
+                    usage: {
+                        input_tokens: response.usage?.input_tokens || 0,
+                        output_tokens: response.usage?.output_tokens || 0,
+                        total_tokens: (response.usage?.input_tokens || 0) + (response.usage?.output_tokens || 0),
+                        cache_creation_input_tokens: response.usage?.cache_creation_input_tokens,
+                        cache_read_input_tokens: response.usage?.cache_read_input_tokens
+                    },
+                    stop_reason: response.stop_reason
+                };
+
+                res.json({
+                    success: true,
+                    provider: 'zai',
+                    status: 200,
+                    data: convertedResponse,
+                    originalPayload: payload,
+                    convertedPayload: zaiPayload,
+                    rawResponse: response
+                });
+            } else {
+                // Mock response when API key is not available
+                res.json({
+                    success: false,
+                    provider: 'zai',
+                    error: 'Z.AI API key not found or invalid format',
+                    hint: 'Z.AI API key format: 32-char hex + "." + 16-char alphanumeric',
+                    mockResponse: {
+                        taskName: "api_test_RES",
+                        timestamp: new Date().toISOString(),
+                        data: {
+                            id: `resp_${generateId()}`,
+                            object: "response",
+                            created_at: Math.floor(Date.now() / 1000),
+                            status: "completed",
+                            model: payload.model || 'glm-4.5',
+                            provider: 'zai',
+                            output: [{
+                                id: `msg_${generateId()}`,
+                                type: "message",
+                                status: "completed",
+                                content: [{
+                                    type: "output_text",
+                                    text: 'This is a mock response. Set a valid Z.AI API key to get real responses.'
+                                }],
+                                role: "assistant"
+                            }],
+                            usage: {
+                                input_tokens: 10,
+                                output_tokens: 15,
+                                total_tokens: 25
+                            }
+                        }
+                    },
+                    originalPayload: payload
+                });
+            }
+        } catch (error) {
+            res.status(500).json({
+                success: false,
+                provider: 'zai',
+                error: error.message,
+                originalPayload: req.body
+            });
+        }
+    });
+
+    // Health check endpoint
+    app.get('/api/health', (req, res) => {
+        res.json({ status: 'ok', timestamp: new Date().toISOString() });
+    });
+
+    // Fallback to index.html for SPA routing (production mode)
+    app.use((req, res) => {
+        const indexPath = path.join(__dirname, 'out', 'index.html');
+        if (fs.existsSync(indexPath)) {
+            res.sendFile(indexPath);
+        } else {
+            res.status(404).send(`
+                <html>
+                    <head>
+                        <title>Frontend Not Built</title>
+                        <style>
+                            body { font-family: Arial, sans-serif; margin: 40px; background: #f5f5f5; }
+                            .container { max-width: 600px; margin: 0 auto; background: white; padding: 40px; border-radius: 8px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); }
+                            h1 { color: #e74c3c; }
+                            pre { background: #f8f8f8; padding: 15px; border-radius: 4px; overflow-x: auto; }
+                        </style>
+                    </head>
+                    <body>
+                        <div class="container">
+                            <h1>⚠️ Frontend Not Built</h1>
+                            <p>The Next.js frontend has not been built yet.</p>
+
+                            <h2>To build the frontend:</h2>
+                            <pre>cd payload_viewer && npm install && npm run build</pre>
+
+                            <h2>Or use the start script:</h2>
+                            <pre>cd payload_viewer && ./start.sh</pre>
+
+                            <p>After building, refresh this page.</p>
+                        </div>
+                    </body>
+                </html>
+            `);
+        }
+    });
+
+    return new Promise((resolve, reject) => {
+        try {
+            const server = app.listen(port, () => {
+                console.log(`🌐 Payload viewer available at: http://localhost:${port}`);
+                resolve(server);
+            });
+
+            server.on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    console.log(`⚠️  Port ${port} is already in use. Trying port ${port + 1}...`);
+                    server.close();
+                    // Try next port
+                    const nextServer = app.listen(port + 1, () => {
+                        console.log(`🌐 Payload viewer available at: http://localhost:${port + 1}`);
+                        resolve(nextServer);
+                    });
+                } else {
+                    reject(err);
+                }
+            });
+        } catch (error) {
+            reject(error);
+        }
+    });
+}
+
+// Start the server if this file is run directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const port = parseInt(process.argv[2], 10) || 3000;
+    startWebServer(port).catch(err => {
+        console.error('Failed to start server:', err);
+        process.exit(1);
+    });
+}
+
+export { startWebServer };