lua-cli 3.7.2 → 3.7.4

package/dist/utils/dev-server.js

@@ -1,736 +0,0 @@
-/**
- * Dev Server Utilities
- * Handles HTTP server, WebSocket connections, and all HTTP endpoints for dev mode
- */
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { createServer } from 'http';
-import { WebSocketServer } from 'ws';
-import { readYamlConfig } from './files.js';
-import { skillHandler } from '../primitives/index.js';
-import { executeTool, createBroadcastConsole, loadEnvironmentVariables } from './sandbox.js';
-import { getSandboxSkillId } from './sandbox-storage.js';
-import { sendChatMessage } from './dev-api.js';
-import { CORS_HEADERS, HTTP_STATUS, DEV_DEFAULTS } from '../config/dev.constants.js';
-import { BASE_URLS } from '../config/constants.js';
-import ProductApi from '../api/products.api.service.js';
-import BasketApi from '../api/basket.api.service.js';
-import OrderApi from '../api/order.api.service.js';
-import CustomDataApi from '../api/custom.data.api.service.js';
-import { setAgentPersona } from '../compiler/index.js';
-import { loadManifest, getPrimitivesByKind, loadArtifact, getAgentPersona } from './artifact-loader.js';
-import { PrimitiveKind } from '../compiler/types.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-/**
- * Creates and starts the dev web server with chat interface and tool testing.
- *
- * @param apiKey - User's API key
- * @param agentId - Agent ID
- * @param skillId - Skill ID
- * @param sandboxId - Sandbox skill ID
- * @param port - Port to run server on
- * @param yamlConfig - YAML config with skills and processors
- * @returns Server instance with WebSocket and broadcast function
- */
-export function createChatServer(apiKey, agentId, skillId, sandboxId, port, yamlConfig) {
-    const server = createServer((req, res) => {
-        // Enable CORS
-        Object.entries(CORS_HEADERS).forEach(([key, value]) => {
-            res.setHeader(key, value);
-        });
-        if (req.method === 'OPTIONS') {
-            res.writeHead(HTTP_STATUS.OK);
-            res.end();
-            return;
-        }
-        // Route handlers
-        if (req.method === 'POST' && req.url === '/chat') {
-            handleChatEndpoint(req, res, apiKey, agentId, skillId, sandboxId, yamlConfig);
-            return;
-        }
-        if (req.method === 'GET' && req.url === '/persona') {
-            handleGetPersonaEndpoint(req, res);
-            return;
-        }
-        if (req.method === 'POST' && req.url === '/persona') {
-            handlePostPersonaEndpoint(req, res);
-            return;
-        }
-        if (req.method === 'GET' && req.url === '/api/config') {
-            handleGetConfigEndpoint(req, res);
-            return;
-        }
-        if (req.method === 'GET' && req.url === '/api/skills') {
-            handleGetSkillsEndpoint(req, res);
-            return;
-        }
-        if (req.method === 'GET' && req.url === '/env') {
-            handleGetEnvEndpoint(req, res);
-            return;
-        }
-        if (req.method === 'POST' && req.url === '/env') {
-            handlePostEnvEndpoint(req, res);
-            return;
-        }
-        if (req.method === 'GET' && req.url === '/tools') {
-            handleGetToolsEndpoint(req, res);
-            return;
-        }
-        if (req.method === 'POST' && req.url === '/tools/test') {
-            handleToolTestEndpoint(req, res, apiKey, agentId, wss);
-            return;
-        }
-        // Products routes
-        if (req.url?.startsWith('/api/products')) {
-            handleProductsEndpoint(req, res, apiKey, agentId);
-            return;
-        }
-        // Baskets routes
-        if (req.url?.startsWith('/api/baskets')) {
-            handleBasketsEndpoint(req, res, apiKey, agentId);
-            return;
-        }
-        // Orders routes
-        if (req.url?.startsWith('/api/orders')) {
-            handleOrdersEndpoint(req, res, apiKey, agentId);
-            return;
-        }
-        // Custom Data routes
-        if (req.url?.startsWith('/api/custom-data')) {
-            handleCustomDataEndpoint(req, res, apiKey, agentId);
-            return;
-        }
-        if (req.method === 'GET' && req.url === '/') {
-            handleIndexEndpoint(req, res, apiKey, agentId, skillId, sandboxId);
-            return;
-        }
-        if (req.method === 'GET' && req.url === '/app.js') {
-            handleStaticFile(req, res, 'app.js', 'application/javascript');
-            return;
-        }
-        if (req.method === 'GET' && req.url === '/app.css') {
-            handleStaticFile(req, res, 'app.css', 'text/css');
-            return;
-        }
-        if (req.method === 'GET' && req.url === '/tools-page.css') {
-            handleStaticFile(req, res, 'tools-page.css', 'text/css');
-            return;
-        }
-        res.writeHead(HTTP_STATUS.NOT_FOUND);
-        res.end('Not Found');
-    });
-    // Create WebSocket server for log streaming
-    const wss = new WebSocketServer({ server });
-    wss.on('connection', (ws) => {
-        ws.on('close', () => {
-            // Client disconnected
-        });
-        ws.on('error', (error) => {
-            console.error('WebSocket error:', error);
-        });
-        // Send initial connection message
-        ws.send(JSON.stringify({
-            type: 'log',
-            subType: 'info',
-            message: 'Connected to CLI dev server',
-            timestamp: new Date().toISOString()
-        }));
-    });
-    server.listen(port, () => {
-        // Server started
-    });
-    // Function to broadcast logs to all connected clients
-    const broadcastLog = (message, subType = 'info') => {
-        const logMessage = {
-            type: 'log',
-            subType,
-            message,
-            timestamp: new Date().toISOString(),
-            id: Date.now().toString()
-        };
-        wss.clients.forEach((client) => {
-            if (client.readyState === 1) { // WebSocket.OPEN
-                client.send(JSON.stringify(logMessage));
-            }
-        });
-    };
-    return { server, wss, broadcastLog };
-}
-// ============================================================================
-// ENDPOINT HANDLERS
-// ============================================================================
-/**
- * Handles POST /chat - Send chat messages
- */
-function handleChatEndpoint(req, res, apiKey, agentId, skillId, sandboxId, yamlConfig) {
-    let body = '';
-    req.on('data', (chunk) => {
-        body += chunk.toString();
-    });
-    req.on('end', async () => {
-        try {
-            const { message, persona } = JSON.parse(body);
-            const response = await sendChatMessage(apiKey, agentId, skillId, sandboxId, message, persona, yamlConfig);
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                success: response !== null,
-                text: response || 'Error sending message',
-                error: response === null ? 'Failed to send message' : null
-            }));
-        }
-        catch (error) {
-            res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: false, error: 'Invalid request' }));
-        }
-    });
-}
-/**
- * Handles GET /persona - Get current persona
- */
-function handleGetPersonaEndpoint(req, res) {
-    try {
-        const persona = getAgentPersona() ?? '';
-        res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-            success: true,
-            persona: persona
-        }));
-    }
-    catch (error) {
-        res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: 'Failed to read persona' }));
-    }
-}
-/**
- * Handles POST /persona - Update persona
- */
-function handlePostPersonaEndpoint(req, res) {
-    let body = '';
-    req.on('data', (chunk) => {
-        body += chunk.toString();
-    });
-    req.on('end', async () => {
-        try {
-            const { persona } = JSON.parse(body);
-            setAgentPersona(persona);
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                success: true,
-                message: 'Persona updated successfully'
-            }));
-        }
-        catch (error) {
-            res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: false, error: 'Failed to update persona' }));
-        }
-    });
-}
-/**
- * Handles GET /api/config - Get agent configuration
- */
-function handleGetConfigEndpoint(req, res) {
-    try {
-        const config = readYamlConfig();
-        res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-            agent: {
-                agentId: config?.agent?.agentId || '',
-                orgId: config?.agent?.orgId || ''
-            }
-        }));
-    }
-    catch (error) {
-        console.error('Error reading config:', error);
-        res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Failed to read configuration' }));
-    }
-}
-/**
- * Handles GET /api/skills - Get all skills information from manifest
- */
-function handleGetSkillsEndpoint(req, res) {
-    (async () => {
-        try {
-            const skillsData = [];
-            const config = readYamlConfig();
-            const yamlSkills = skillHandler.getFromYaml(config);
-            // Try to read from manifest
-            try {
-                const manifest = loadManifest();
-                const skills = getPrimitivesByKind(manifest, PrimitiveKind.SKILL);
-                for (const skill of skills) {
-                    const yamlSkill = yamlSkills.find((s) => s.name === skill.name);
-                    const sandboxId = await getSandboxSkillId(skill.name);
-                    skillsData.push({
-                        name: skill.name || DEV_DEFAULTS.SKILL_NAME,
-                        description: skill.description || DEV_DEFAULTS.DESCRIPTION,
-                        context: skill.context || '',
-                        version: yamlSkill?.version || DEV_DEFAULTS.VERSION,
-                        skillId: yamlSkill?.skillId || '',
-                        sandboxId: sandboxId || '',
-                        tools: skill.tools || []
-                    });
-                }
-            }
-            catch {
-                // Fallback: Read from YAML config only (not compiled yet)
-                const toolsDir = path.join(process.cwd(), 'src', 'tools');
-                let toolNames = [];
-                if (fs.existsSync(toolsDir)) {
-                    const toolFiles = fs.readdirSync(toolsDir)
-                        .filter((file) => file.endsWith('.ts'))
-                        .map((file) => file.replace('.ts', ''));
-                    toolNames = toolFiles;
-                }
-                for (const skill of yamlSkills) {
-                    const sandboxId = await getSandboxSkillId(skill.name);
-                    skillsData.push({
-                        name: skill.name || DEV_DEFAULTS.SKILL_NAME,
-                        description: DEV_DEFAULTS.NOT_COMPILED_DESCRIPTION,
-                        context: DEV_DEFAULTS.NOT_COMPILED_CONTEXT,
-                        version: skill.version || DEV_DEFAULTS.VERSION,
-                        skillId: skill.skillId || '',
-                        sandboxId: sandboxId || '',
-                        tools: toolNames // All tools for now since not compiled
-                    });
-                }
-            }
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                success: true,
-                skills: skillsData
-            }));
-        }
-        catch (error) {
-            console.error('Error reading skills:', error);
-            res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                success: false,
-                error: 'Failed to read skills configuration'
-            }));
-        }
-    })();
-}
-/**
- * Handles GET /env - Get environment variables
- */
-function handleGetEnvEndpoint(req, res) {
-    try {
-        const envPath = path.join(process.cwd(), '.env');
-        let envContent = '';
-        if (fs.existsSync(envPath)) {
-            envContent = fs.readFileSync(envPath, 'utf8');
-        }
-        res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-            success: true,
-            content: envContent
-        }));
-    }
-    catch (error) {
-        res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: 'Failed to read .env file' }));
-    }
-}
-/**
- * Handles POST /env - Update environment variables
- */
-function handlePostEnvEndpoint(req, res) {
-    let body = '';
-    req.on('data', (chunk) => {
-        body += chunk.toString();
-    });
-    req.on('end', async () => {
-        try {
-            const { content } = JSON.parse(body);
-            const envPath = path.join(process.cwd(), '.env');
-            // Write the .env file
-            fs.writeFileSync(envPath, content || '', 'utf8');
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                success: true,
-                message: 'Environment variables updated successfully'
-            }));
-        }
-        catch (error) {
-            res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: false, error: 'Failed to update .env file' }));
-        }
-    });
-}
-/**
- * Handles GET /tools - Get all tools from manifest
- */
-function handleGetToolsEndpoint(req, res) {
-    try {
-        const manifest = loadManifest();
-        const toolPrimitives = getPrimitivesByKind(manifest, PrimitiveKind.TOOL);
-        // Convert to tools object format expected by the UI
-        const tools = {};
-        for (const tool of toolPrimitives) {
-            tools[tool.name] = {
-                name: tool.name,
-                description: tool.description,
-            };
-        }
-        res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-            success: true,
-            tools: tools
-        }));
-    }
-    catch (error) {
-        res.writeHead(HTTP_STATUS.NOT_FOUND, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: 'Manifest not found. Run lua compile first.' }));
-    }
-}
-/**
- * Handles POST /tools/test - Test a tool
- */
-function handleToolTestEndpoint(req, res, apiKey, agentId, wss) {
-    let body = '';
-    req.on('data', (chunk) => {
-        body += chunk.toString();
-    });
-    req.on('end', async () => {
-        try {
-            const { toolName, inputs } = JSON.parse(body);
-            // Load tool from manifest
-            let manifest;
-            try {
-                manifest = loadManifest();
-            }
-            catch {
-                res.writeHead(HTTP_STATUS.NOT_FOUND, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ success: false, error: 'Manifest not found. Run lua compile first.' }));
-                return;
-            }
-            const tools = getPrimitivesByKind(manifest, PrimitiveKind.TOOL);
-            const tool = tools.find(t => t.name === toolName);
-            if (!tool) {
-                res.writeHead(HTTP_STATUS.NOT_FOUND, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ success: false, error: 'Tool not found' }));
-                return;
-            }
-            // Load environment variables from all sources (.env + yaml)
-            const envVars = loadEnvironmentVariables();
-            // Load tool code from artifact (already uncompressed)
-            const toolCode = loadArtifact(tool, process.cwd());
-            // Broadcast tool test start
-            wss.clients.forEach((client) => {
-                if (client.readyState === 1) {
-                    client.send(JSON.stringify({
-                        type: 'log',
-                        subType: 'info',
-                        message: `🧪 Testing tool: ${toolName}`,
-                        timestamp: new Date().toISOString(),
-                        id: Date.now().toString()
-                    }));
-                }
-            });
-            // Create custom console that captures output and sends via WebSocket
-            const customConsole = createBroadcastConsole((logData) => {
-                wss.clients.forEach((client) => {
-                    if (client.readyState === 1) { // WebSocket.OPEN
-                        client.send(JSON.stringify(logData));
-                    }
-                });
-            });
-            // Execute the tool using the common utility
-            const result = await executeTool({
-                toolCode,
-                inputs,
-                apiKey,
-                agentId,
-                channel: 'dev',
-                customConsole
-            });
-            // Broadcast tool test completion
-            wss.clients.forEach((client) => {
-                if (client.readyState === 1) {
-                    client.send(JSON.stringify({
-                        type: 'log',
-                        subType: 'info',
-                        message: `✅ Tool test completed: ${toolName}`,
-                        timestamp: new Date().toISOString(),
-                        id: (Date.now() + 1).toString()
-                    }));
-                }
-            });
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                success: true,
-                result: result
-            }));
-        }
-        catch (error) {
-            res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                success: false,
-                error: error.message || 'Tool execution failed'
-            }));
-        }
-    });
-}
-/**
- * Handles GET / - Serve main HTML page
- */
-function handleIndexEndpoint(req, res, apiKey, agentId, skillId, sandboxId) {
-    // Read the React app HTML template from dist directory
-    const htmlTemplate = fs.readFileSync(path.join(__dirname, '..', 'web', 'index.html'), 'utf8');
-    // Replace placeholders with actual values
-    const html = htmlTemplate
-        .replace('{{API_KEY}}', apiKey)
-        .replace('{{AGENT_ID}}', agentId)
-        .replace('{{SKILL_ID}}', skillId)
-        .replace('{{SANDBOX_ID}}', sandboxId);
-    res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'text/html' });
-    res.end(html);
-}
-/**
- * Handles static file serving (JS, CSS)
- */
-function handleStaticFile(req, res, filename, contentType) {
-    try {
-        const content = fs.readFileSync(path.join(__dirname, '..', 'web', filename), 'utf8');
-        res.writeHead(HTTP_STATUS.OK, { 'Content-Type': contentType });
-        res.end(content);
-    }
-    catch (error) {
-        res.writeHead(HTTP_STATUS.NOT_FOUND, { 'Content-Type': 'text/plain' });
-        res.end(`${filename} not found`);
-    }
-}
-/**
- * Handler for products API using ProductApi service
- */
-async function handleProductsEndpoint(req, res, apiKey, agentId) {
-    const productApi = new ProductApi(BASE_URLS.API, apiKey, agentId);
-    try {
-        let result;
-        if (req.method === 'GET') {
-            if (req.url.includes('/search')) {
-                const searchQuery = new URL(req.url, 'http://localhost').searchParams.get('searchQuery') || '';
-                result = await productApi.search(searchQuery);
-            }
-            else if (req.url.match(/\/api\/products\/[^/]+$/)) {
-                const productId = req.url.split('/').pop();
-                result = await productApi.getById(productId);
-            }
-            else {
-                const url = new URL(req.url, 'http://localhost');
-                const page = parseInt(url.searchParams.get('page') || '1');
-                const limit = parseInt(url.searchParams.get('limit') || '20');
-                result = await productApi.get(page, limit);
-            }
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true, data: result }));
-        }
-        else if (req.method === 'POST') {
-            const body = await new Promise((resolve) => {
-                let data = '';
-                req.on('data', (chunk) => { data += chunk; });
-                req.on('end', () => resolve(data));
-            });
-            const productData = JSON.parse(body);
-            result = await productApi.create(productData);
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true, data: { product: result } }));
-        }
-        else if (req.method === 'PUT') {
-            const body = await new Promise((resolve) => {
-                let data = '';
-                req.on('data', (chunk) => { data += chunk; });
-                req.on('end', () => resolve(data));
-            });
-            const productData = JSON.parse(body);
-            result = await productApi.update(productData, productData.id);
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true, data: result }));
-        }
-        else if (req.method === 'DELETE') {
-            const productId = req.url.split('/').pop();
-            result = await productApi.delete(productId);
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true, data: result }));
-        }
-    }
-    catch (error) {
-        res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: error.message || 'API error' }));
-    }
-}
-/**
- * Handler for baskets API using BasketApi service
- */
-async function handleBasketsEndpoint(req, res, apiKey, agentId) {
-    const basketApi = new BasketApi(BASE_URLS.API, apiKey, agentId);
-    try {
-        let result;
-        if (req.method === 'GET') {
-            if (req.url.match(/\/api\/baskets\/[^/]+$/)) {
-                const basketId = req.url.split('/').pop();
-                result = await basketApi.getById(basketId);
-            }
-            else {
-                const url = new URL(req.url, 'http://localhost');
-                const statusParam = url.searchParams.get('status');
-                result = await basketApi.get(statusParam);
-            }
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true, data: result }));
-        }
-        else if (req.method === 'POST') {
-            const body = await new Promise((resolve) => {
-                let data = '';
-                req.on('data', (chunk) => { data += chunk; });
-                req.on('end', () => resolve(data));
-            });
-            const basketData = JSON.parse(body);
-            result = await basketApi.create(basketData);
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true, data: result }));
-        }
-        else if (req.method === 'DELETE') {
-            const basketId = req.url.split('/').pop();
-            // Baskets don't have a direct delete in the API, use clear instead
-            result = await basketApi.clear(basketId);
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true, data: result }));
-        }
-    }
-    catch (error) {
-        res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: error.message || 'API error' }));
-    }
-}
-/**
- * Handler for orders API using OrderApi service
- */
-async function handleOrdersEndpoint(req, res, apiKey, agentId) {
-    const orderApi = new OrderApi(BASE_URLS.API, apiKey, agentId);
-    try {
-        let result;
-        if (req.method === 'GET') {
-            if (req.url.match(/\/api\/orders\/[^/]+$/)) {
-                const orderId = req.url.split('/').pop();
-                result = await orderApi.getById(orderId);
-            }
-            else {
-                const url = new URL(req.url, 'http://localhost');
-                const statusParam = url.searchParams.get('status');
-                result = await orderApi.get(statusParam);
-            }
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true, data: result }));
-        }
-        else if (req.method === 'POST') {
-            const body = await new Promise((resolve) => {
-                let data = '';
-                req.on('data', (chunk) => { data += chunk; });
-                req.on('end', () => resolve(data));
-            });
-            const orderData = JSON.parse(body);
-            result = await orderApi.create(orderData);
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true, data: result }));
-        }
-        else if (req.method === 'PUT') {
-            if (req.url.includes('/status')) {
-                const orderId = req.url.split('/')[3];
-                const body = await new Promise((resolve) => {
-                    let data = '';
-                    req.on('data', (chunk) => { data += chunk; });
-                    req.on('end', () => resolve(data));
-                });
-                const { status } = JSON.parse(body);
-                result = await orderApi.updateStatus(status, orderId);
-            }
-            else {
-                const body = await new Promise((resolve) => {
-                    let data = '';
-                    req.on('data', (chunk) => { data += chunk; });
-                    req.on('end', () => resolve(data));
-                });
-                const orderData = JSON.parse(body);
-                const orderId = req.url.split('/').pop();
-                result = await orderApi.updateData(orderData, orderId);
-            }
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true, data: result }));
-        }
-    }
-    catch (error) {
-        res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: error.message || 'API error' }));
-    }
-}
-/**
- * Handler for custom data API using CustomDataApi service
- */
-async function handleCustomDataEndpoint(req, res, apiKey, agentId) {
-    const customDataApi = new CustomDataApi(BASE_URLS.API, apiKey, agentId);
-    try {
-        let result;
-        const pathParts = req.url.split('/');
-        const collectionName = pathParts[3]; // /api/custom-data/{collection}
-        if (req.method === 'GET') {
-            if (req.url.includes('/search')) {
-                const url = new URL(req.url, 'http://localhost');
-                const searchText = url.searchParams.get('searchText') || '';
-                const limit = parseInt(url.searchParams.get('limit') || '10');
-                const scoreThreshold = parseFloat(url.searchParams.get('scoreThreshold') || '0.7');
-                result = await customDataApi.search(collectionName, searchText, limit, scoreThreshold);
-            }
-            else if (pathParts.length > 4) {
-                const entryId = pathParts[4];
-                result = await customDataApi.getEntry(collectionName, entryId);
-            }
-            else {
-                const url = new URL(req.url, 'http://localhost');
-                const filter = url.searchParams.get('filter') ? JSON.parse(url.searchParams.get('filter')) : undefined;
-                const page = parseInt(url.searchParams.get('page') || '1');
-                const limit = parseInt(url.searchParams.get('limit') || '10');
-                result = await customDataApi.get(collectionName, filter, page, limit);
-            }
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true, data: result }));
-        }
-        else if (req.method === 'POST') {
-            const body = await new Promise((resolve) => {
-                let data = '';
-                req.on('data', (chunk) => { data += chunk; });
-                req.on('end', () => resolve(data));
-            });
-            const { data, searchText } = JSON.parse(body);
-            result = await customDataApi.create(collectionName, data, searchText);
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true, data: result }));
-        }
-        else if (req.method === 'PUT') {
-            const entryId = pathParts[4];
-            const body = await new Promise((resolve) => {
-                let data = '';
-                req.on('data', (chunk) => { data += chunk; });
-                req.on('end', () => resolve(data));
-            });
-            const updateData = JSON.parse(body);
-            result = await customDataApi.update(collectionName, entryId, updateData.data, updateData.searchText);
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true, data: result }));
-        }
-        else if (req.method === 'DELETE') {
-            const entryId = pathParts[4];
-            result = await customDataApi.delete(collectionName, entryId);
-            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true, data: result }));
-        }
-    }
-    catch (error) {
-        res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ success: false, error: error.message || 'API error' }));
-    }
-}
-//# sourceMappingURL=dev-server.js.map