clodds 1.1.0

package/dist/api/server.js

@@ -0,0 +1,852 @@
+"use strict";
+/**
+ * Standalone Compute API Server v1
+ *
+ * Features:
+ * - All compute services (LLM, code, web, data, storage)
+ * - SQLite persistence (survives restarts)
+ * - Rate limiting (per-wallet and per-IP)
+ * - Multi-chain payment verification (Base, Ethereum, Polygon)
+ * - Input validation and size limits
+ * - Configurable CORS
+ * - API versioning (/v1/...)
+ * - Metrics endpoint
+ * - WebSocket for real-time job updates
+ *
+ * Run: CLODDS_TREASURY_WALLET=0x... node dist/api/server.js
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_1 = require("http");
+const crypto_1 = require("crypto");
+const ws_1 = require("ws");
+const compute_1 = require("./compute");
+const llm_1 = require("./compute/llm");
+const code_1 = require("./compute/code");
+const web_1 = require("./compute/web");
+const data_1 = require("./compute/data");
+const storage_1 = require("./compute/storage");
+const trade_1 = require("./compute/trade");
+// =============================================================================
+// CONFIGURATION
+// =============================================================================
+const PORT = parseInt(process.env.CLODDS_API_PORT || '3456', 10);
+const TREASURY = process.env.CLODDS_TREASURY_WALLET;
+const MAX_BODY_SIZE = parseInt(process.env.CLODDS_MAX_BODY_SIZE || '10485760', 10); // 10MB
+const CORS_ORIGINS = process.env.CLODDS_CORS_ORIGINS?.split(',') || ['*'];
+const API_VERSION = 'v1';
+if (!TREASURY) {
+    console.error('ERROR: CLODDS_TREASURY_WALLET env var not set');
+    process.exit(1);
+}
+console.log(`Starting Clodds Compute API ${API_VERSION}...`);
+console.log(`Treasury: ${TREASURY}`);
+console.log(`Port: ${PORT}`);
+console.log(`Max body size: ${MAX_BODY_SIZE} bytes`);
+console.log(`CORS origins: ${CORS_ORIGINS.join(', ')}`);
+// =============================================================================
+// INITIALIZE SERVICES
+// =============================================================================
+const gateway = (0, compute_1.createComputeGateway)({ treasuryWallet: TREASURY }, compute_1.COMPUTE_PRICING);
+// Initialize and register all service handlers
+const llm = (0, llm_1.createLLMService)();
+const code = (0, code_1.createCodeRunner)();
+const web = (0, web_1.createWebScraper)();
+const data = (0, data_1.createDataService)();
+const storage = (0, storage_1.createStorageService)();
+const trade = (0, trade_1.createTradeExecutor)({
+    dryRun: process.env.TRADE_DRY_RUN !== 'false',
+    polymarket: process.env.POLY_API_KEY ? {
+        address: process.env.POLY_ADDRESS || '',
+        apiKey: process.env.POLY_API_KEY,
+        apiSecret: process.env.POLY_API_SECRET || '',
+        passphrase: process.env.POLY_API_PASSPHRASE || '',
+    } : undefined,
+});
+// Register handlers with gateway
+gateway.registerHandler('llm', (req) => llm.execute(req));
+gateway.registerHandler('code', (req) => code.execute(req));
+gateway.registerHandler('web', (req) => web.execute(req));
+gateway.registerHandler('data', (req) => data.execute(req));
+gateway.registerHandler('storage', (req) => storage.execute(req));
+gateway.registerHandler('trade', (req) => trade.execute(req));
+// =============================================================================
+// HELPERS
+// =============================================================================
+function getCorsHeaders(origin) {
+    const allowedOrigin = CORS_ORIGINS.includes('*')
+        ? '*'
+        : CORS_ORIGINS.includes(origin || '')
+            ? origin
+            : CORS_ORIGINS[0];
+    return {
+        'Access-Control-Allow-Origin': allowedOrigin,
+        'Access-Control-Allow-Methods': 'GET, POST, DELETE, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-Wallet-Address, X-Request-Id',
+        'Access-Control-Max-Age': '86400',
+    };
+}
+function json(res, status, data, origin) {
+    res.writeHead(status, {
+        'Content-Type': 'application/json',
+        'X-Powered-By': 'Clodds Compute',
+        'X-API-Version': API_VERSION,
+        ...getCorsHeaders(origin),
+    });
+    res.end(JSON.stringify(data));
+}
+function error(res, status, message, origin) {
+    json(res, status, { error: message }, origin);
+}
+async function parseBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        let size = 0;
+        req.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > MAX_BODY_SIZE) {
+                reject(new Error(`Body too large. Max: ${MAX_BODY_SIZE} bytes`));
+                req.destroy();
+                return;
+            }
+            body += chunk.toString();
+        });
+        req.on('end', () => {
+            try {
+                resolve(body ? JSON.parse(body) : {});
+            }
+            catch {
+                reject(new Error('Invalid JSON'));
+            }
+        });
+        req.on('error', reject);
+    });
+}
+function getClientIp(req) {
+    const forwarded = req.headers['x-forwarded-for'];
+    if (typeof forwarded === 'string') {
+        return forwarded.split(',')[0].trim();
+    }
+    return req.socket.remoteAddress || '0.0.0.0';
+}
+function validateWallet(wallet) {
+    if (typeof wallet !== 'string')
+        return null;
+    if (!/^0x[a-fA-F0-9]{40}$/.test(wallet))
+        return null;
+    return wallet.toLowerCase();
+}
+function validatePaymentProof(proof) {
+    if (!proof || typeof proof !== 'object')
+        return null;
+    const p = proof;
+    if (typeof p.txHash !== 'string' || !/^0x[a-fA-F0-9]{64}$/.test(p.txHash))
+        return null;
+    if (typeof p.network !== 'string')
+        return null;
+    if (typeof p.amountUsd !== 'number' || p.amountUsd <= 0)
+        return null;
+    return {
+        txHash: p.txHash,
+        network: p.network,
+        amountUsd: p.amountUsd,
+        token: p.token || 'USDC',
+        timestamp: p.timestamp || Date.now(),
+    };
+}
+/**
+ * Get wallet from Authorization header (Bearer token) or request body
+ * Returns wallet if found and valid, null otherwise
+ */
+function getWalletFromAuth(req) {
+    const auth = req.headers['authorization'];
+    if (!auth || !auth.startsWith('Bearer ')) {
+        return null;
+    }
+    const apiKey = auth.slice(7);
+    if (!apiKey.startsWith('clodds_')) {
+        return null;
+    }
+    return gateway.getApiKeyWallet(apiKey);
+}
+const routes = [
+    // Health check
+    {
+        method: 'GET',
+        pattern: /^\/(?:v1\/)?health$/,
+        handler: async (req, res) => {
+            const metrics = gateway.getMetrics();
+            json(res, 200, {
+                status: 'ok',
+                service: 'clodds-compute',
+                version: API_VERSION,
+                uptime: metrics.uptime,
+                activeJobs: metrics.activeJobs,
+            }, req.headers.origin);
+        },
+    },
+    // Root - API info
+    {
+        method: 'GET',
+        pattern: /^\/$/,
+        handler: async (req, res) => {
+            json(res, 200, {
+                name: 'Clodds Compute API',
+                version: API_VERSION,
+                docs: 'https://github.com/alsk1992/CloddsBot/blob/main/docs/API.md',
+                endpoints: {
+                    health: '/v1/health',
+                    pricing: '/v1/pricing',
+                    balance: '/v1/balance/:wallet',
+                    deposit: '/v1/deposit',
+                    usage: '/v1/usage/:wallet',
+                    jobs: '/v1/jobs/:wallet',
+                    job: '/v1/job/:jobId',
+                    compute: '/v1/compute/:service',
+                    metrics: '/v1/metrics',
+                },
+                services: Object.keys(compute_1.COMPUTE_PRICING),
+            }, req.headers.origin);
+        },
+    },
+    // Pricing
+    {
+        method: 'GET',
+        pattern: /^\/(?:v1\/)?pricing$/,
+        handler: async (req, res) => {
+            json(res, 200, compute_1.COMPUTE_PRICING, req.headers.origin);
+        },
+    },
+    // Cost estimation
+    {
+        method: 'POST',
+        pattern: /^\/(?:v1\/)?estimate$/,
+        handler: async (req, res) => {
+            const body = await parseBody(req);
+            const service = body.service;
+            if (!service || !compute_1.COMPUTE_PRICING[service]) {
+                return error(res, 400, `Invalid or missing service. Available: ${Object.keys(compute_1.COMPUTE_PRICING).join(', ')}`, req.headers.origin);
+            }
+            const estimate = gateway.estimateCost(service, body.payload || body);
+            json(res, 200, estimate, req.headers.origin);
+        },
+    },
+    // Metrics
+    {
+        method: 'GET',
+        pattern: /^\/(?:v1\/)?metrics$/,
+        handler: async (req, res) => {
+            const metrics = gateway.getMetrics();
+            json(res, 200, metrics, req.headers.origin);
+        },
+    },
+    // Admin Metrics (protected)
+    {
+        method: 'GET',
+        pattern: /^\/(?:v1\/)?admin\/metrics$/,
+        handler: async (req, res) => {
+            // Require admin token
+            const adminToken = process.env.CLODDS_ADMIN_TOKEN;
+            if (!adminToken) {
+                return error(res, 503, 'Admin endpoint not configured', req.headers.origin);
+            }
+            const auth = req.headers['authorization'];
+            const providedToken = auth?.startsWith('Bearer ') ? auth.slice(7) : null;
+            if (!providedToken ||
+                providedToken.length !== adminToken.length ||
+                !(0, crypto_1.timingSafeEqual)(Buffer.from(providedToken), Buffer.from(adminToken))) {
+                return error(res, 401, 'Invalid or missing admin token', req.headers.origin);
+            }
+            const adminMetrics = gateway.getAdminMetrics();
+            const cacheStats = llm.getCacheStats();
+            json(res, 200, {
+                ...adminMetrics,
+                llmCache: cacheStats,
+            }, req.headers.origin);
+        },
+    },
+    // LLM Cache Stats
+    {
+        method: 'GET',
+        pattern: /^\/(?:v1\/)?cache\/stats$/,
+        handler: async (req, res) => {
+            const stats = llm.getCacheStats();
+            json(res, 200, stats, req.headers.origin);
+        },
+    },
+    // Clear LLM Cache
+    {
+        method: 'DELETE',
+        pattern: /^\/(?:v1\/)?cache$/,
+        handler: async (req, res) => {
+            llm.clearCache();
+            json(res, 200, { success: true, message: 'LLM cache cleared' }, req.headers.origin);
+        },
+    },
+    // Get balance
+    {
+        method: 'GET',
+        pattern: /^\/(?:v1\/)?balance\/([^/]+)$/,
+        handler: async (req, res, match) => {
+            const wallet = validateWallet(match[1]);
+            if (!wallet) {
+                return error(res, 400, 'Invalid wallet address', req.headers.origin);
+            }
+            const balance = await gateway.getBalance(wallet);
+            json(res, 200, balance, req.headers.origin);
+        },
+    },
+    // Deposit credits
+    {
+        method: 'POST',
+        pattern: /^\/(?:v1\/)?deposit$/,
+        handler: async (req, res) => {
+            const body = await parseBody(req);
+            const wallet = validateWallet(body.wallet);
+            if (!wallet) {
+                return error(res, 400, 'Invalid wallet address', req.headers.origin);
+            }
+            const proof = validatePaymentProof(body.paymentProof);
+            if (!proof) {
+                return error(res, 400, 'Invalid payment proof', req.headers.origin);
+            }
+            const result = await gateway.depositCredits(wallet, proof);
+            json(res, result.success ? 200 : 400, result, req.headers.origin);
+        },
+    },
+    // Get usage stats
+    {
+        method: 'GET',
+        pattern: /^\/(?:v1\/)?usage\/([^/]+)$/,
+        handler: async (req, res, match) => {
+            const wallet = validateWallet(match[1]);
+            if (!wallet) {
+                return error(res, 400, 'Invalid wallet address', req.headers.origin);
+            }
+            const url = new URL(req.url || '/', `http://localhost:${PORT}`);
+            const period = (url.searchParams.get('period') || 'all');
+            const usage = await gateway.getUsage(wallet, period);
+            json(res, 200, usage, req.headers.origin);
+        },
+    },
+    // Get spending limits
+    {
+        method: 'GET',
+        pattern: /^\/(?:v1\/)?limits\/([^/]+)$/,
+        handler: async (req, res, match) => {
+            const wallet = validateWallet(match[1]);
+            if (!wallet) {
+                return error(res, 400, 'Invalid wallet address', req.headers.origin);
+            }
+            const limits = await gateway.getSpendingLimits(wallet);
+            json(res, 200, limits, req.headers.origin);
+        },
+    },
+    // Set spending limits
+    {
+        method: 'POST',
+        pattern: /^\/(?:v1\/)?limits\/([^/]+)$/,
+        handler: async (req, res, match) => {
+            const wallet = validateWallet(match[1]);
+            if (!wallet) {
+                return error(res, 400, 'Invalid wallet address', req.headers.origin);
+            }
+            const body = await parseBody(req);
+            // Validate limits
+            const dailyLimit = typeof body.dailyLimit === 'number' ? body.dailyLimit : (body.dailyLimit === null ? null : undefined);
+            const monthlyLimit = typeof body.monthlyLimit === 'number' ? body.monthlyLimit : (body.monthlyLimit === null ? null : undefined);
+            if (dailyLimit === undefined && monthlyLimit === undefined) {
+                return error(res, 400, 'Must provide dailyLimit and/or monthlyLimit (number or null)', req.headers.origin);
+            }
+            await gateway.setSpendingLimits(wallet, {
+                dailyLimit: dailyLimit,
+                monthlyLimit: monthlyLimit,
+            });
+            const limits = await gateway.getSpendingLimits(wallet);
+            json(res, 200, limits, req.headers.origin);
+        },
+    },
+    // Create API key
+    {
+        method: 'POST',
+        pattern: /^\/(?:v1\/)?apikeys$/,
+        handler: async (req, res) => {
+            const body = await parseBody(req);
+            const wallet = validateWallet(body.wallet);
+            if (!wallet) {
+                return error(res, 400, 'Invalid wallet address', req.headers.origin);
+            }
+            const name = typeof body.name === 'string' ? body.name : 'Default';
+            if (name.length > 50) {
+                return error(res, 400, 'Name must be 50 characters or less', req.headers.origin);
+            }
+            const result = await gateway.createApiKey(wallet, name);
+            json(res, 201, result, req.headers.origin);
+        },
+    },
+    // List API keys for wallet
+    {
+        method: 'GET',
+        pattern: /^\/(?:v1\/)?apikeys\/([^/]+)$/,
+        handler: async (req, res, match) => {
+            const wallet = validateWallet(match[1]);
+            if (!wallet) {
+                return error(res, 400, 'Invalid wallet address', req.headers.origin);
+            }
+            const apiKeys = gateway.listApiKeys(wallet);
+            json(res, 200, { apiKeys, count: apiKeys.length }, req.headers.origin);
+        },
+    },
+    // Revoke API key
+    {
+        method: 'DELETE',
+        pattern: /^\/(?:v1\/)?apikeys\/([^/]+)\/([^/]+)$/,
+        handler: async (req, res, match) => {
+            const wallet = validateWallet(match[1]);
+            if (!wallet) {
+                return error(res, 400, 'Invalid wallet address', req.headers.origin);
+            }
+            const apiKey = match[2];
+            if (!apiKey.startsWith('clodds_')) {
+                return error(res, 400, 'Invalid API key format', req.headers.origin);
+            }
+            const success = gateway.revokeApiKey(wallet, apiKey);
+            if (success) {
+                json(res, 200, { success: true, message: 'API key revoked' }, req.headers.origin);
+            }
+            else {
+                error(res, 404, 'API key not found or not owned by this wallet', req.headers.origin);
+            }
+        },
+    },
+    // List jobs for wallet
+    {
+        method: 'GET',
+        pattern: /^\/(?:v1\/)?jobs\/([^/]+)$/,
+        handler: async (req, res, match) => {
+            const wallet = validateWallet(match[1]);
+            if (!wallet) {
+                return error(res, 400, 'Invalid wallet address', req.headers.origin);
+            }
+            const url = new URL(req.url || '/', `http://localhost:${PORT}`);
+            const limit = parseInt(url.searchParams.get('limit') || '50', 10);
+            const jobs = await gateway.getJobsByWallet(wallet, Math.min(limit, 100));
+            json(res, 200, { jobs, count: jobs.length }, req.headers.origin);
+        },
+    },
+    // Get job status
+    {
+        method: 'GET',
+        pattern: /^\/(?:v1\/)?job\/([^/]+)$/,
+        handler: async (req, res, match) => {
+            const jobId = match[1];
+            const wallet = req.headers['x-wallet-address'];
+            const job = await gateway.getJob(jobId, wallet ? validateWallet(wallet) || undefined : undefined);
+            if (!job) {
+                return error(res, 404, 'Job not found', req.headers.origin);
+            }
+            json(res, 200, job, req.headers.origin);
+        },
+    },
+    // Cancel job
+    {
+        method: 'DELETE',
+        pattern: /^\/(?:v1\/)?job\/([^/]+)$/,
+        handler: async (req, res, match) => {
+            const jobId = match[1];
+            const wallet = req.headers['x-wallet-address'];
+            if (!wallet) {
+                return error(res, 400, 'X-Wallet-Address header required', req.headers.origin);
+            }
+            const validWallet = validateWallet(wallet);
+            if (!validWallet) {
+                return error(res, 400, 'Invalid wallet address', req.headers.origin);
+            }
+            const cancelled = await gateway.cancelJob(jobId, validWallet);
+            if (!cancelled) {
+                return error(res, 400, 'Cannot cancel job (not found, not owned, or not pending)', req.headers.origin);
+            }
+            json(res, 200, { success: true, jobId }, req.headers.origin);
+        },
+    },
+    // Submit compute request
+    {
+        method: 'POST',
+        pattern: /^\/(?:v1\/)?compute\/([^/]+)$/,
+        handler: async (req, res, match) => {
+            const service = match[1];
+            if (!compute_1.COMPUTE_PRICING[service]) {
+                return error(res, 400, `Unknown service: ${service}`, req.headers.origin);
+            }
+            const body = await parseBody(req);
+            // Support both Bearer token and wallet in body
+            const wallet = getWalletFromAuth(req) || validateWallet(body.wallet);
+            if (!wallet) {
+                return error(res, 400, 'Invalid wallet address. Provide wallet in body or use Bearer token.', req.headers.origin);
+            }
+            // Rate limiting
+            const ip = getClientIp(req);
+            const rateLimit = gateway.checkRateLimit(wallet, ip);
+            if (!rateLimit.allowed) {
+                res.setHeader('Retry-After', rateLimit.retryAfter?.toString() || '60');
+                return error(res, 429, 'Rate limit exceeded', req.headers.origin);
+            }
+            // Validate priority if provided
+            const validPriorities = ['low', 'normal', 'high', 'urgent'];
+            const priority = (typeof body.priority === 'string' && validPriorities.includes(body.priority))
+                ? body.priority
+                : 'normal';
+            // Build compute request
+            const computeReq = {
+                id: body.requestId || `req_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+                service,
+                wallet,
+                payload: body.payload || body,
+                paymentProof: body.paymentProof ? validatePaymentProof(body.paymentProof) || undefined : undefined,
+                callbackUrl: typeof body.callbackUrl === 'string' ? body.callbackUrl : undefined,
+                priority,
+                meta: typeof body.meta === 'object' ? body.meta : undefined,
+            };
+            const result = await gateway.submit(computeReq);
+            // Add rate limit headers
+            res.setHeader('X-RateLimit-Remaining', rateLimit.remaining?.toString() || '0');
+            json(res, result.status === 'failed' ? 400 : 202, result, req.headers.origin);
+        },
+    },
+    // Batch compute request
+    {
+        method: 'POST',
+        pattern: /^\/(?:v1\/)?batch$/,
+        handler: async (req, res) => {
+            const body = await parseBody(req);
+            const requests = body.requests;
+            if (!Array.isArray(requests) || requests.length === 0) {
+                return error(res, 400, 'requests must be a non-empty array', req.headers.origin);
+            }
+            if (requests.length > 10) {
+                return error(res, 400, 'Maximum 10 requests per batch', req.headers.origin);
+            }
+            // Validate wallet (Bearer token or body)
+            const wallet = getWalletFromAuth(req) || validateWallet(body.wallet);
+            if (!wallet) {
+                return error(res, 400, 'Invalid wallet address. Provide wallet in body or use Bearer token.', req.headers.origin);
+            }
+            // Rate limiting (counts as one request)
+            const ip = getClientIp(req);
+            const rateLimit = gateway.checkRateLimit(wallet, ip);
+            if (!rateLimit.allowed) {
+                res.setHeader('Retry-After', rateLimit.retryAfter?.toString() || '60');
+                return error(res, 429, 'Rate limit exceeded', req.headers.origin);
+            }
+            // Validate all requests
+            const computeRequests = [];
+            for (let i = 0; i < requests.length; i++) {
+                const r = requests[i];
+                const service = r.service;
+                if (!service || !compute_1.COMPUTE_PRICING[service]) {
+                    return error(res, 400, `Invalid service in request ${i}: ${service}`, req.headers.origin);
+                }
+                // Validate priority if provided
+                const validPriorities = ['low', 'normal', 'high', 'urgent'];
+                const priority = (typeof r.priority === 'string' && validPriorities.includes(r.priority))
+                    ? r.priority
+                    : 'normal';
+                computeRequests.push({
+                    id: r.requestId || `req_${Date.now()}_${i}_${Math.random().toString(36).slice(2, 10)}`,
+                    service,
+                    wallet,
+                    payload: r.payload || r,
+                    priority,
+                    meta: typeof r.meta === 'object' ? r.meta : undefined,
+                });
+            }
+            // Process all requests in parallel
+            const results = await Promise.allSettled(computeRequests.map(computeReq => gateway.submit(computeReq)));
+            // Format results
+            const batchResults = results.map((result, i) => {
+                if (result.status === 'fulfilled') {
+                    return { index: i, ...result.value };
+                }
+                else {
+                    return { index: i, status: 'failed', error: result.reason?.message || 'Unknown error' };
+                }
+            });
+            const successful = batchResults.filter(r => r.status !== 'failed').length;
+            const failed = batchResults.length - successful;
+            json(res, 200, {
+                batchId: `batch_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+                total: batchResults.length,
+                successful,
+                failed,
+                results: batchResults,
+            }, req.headers.origin);
+        },
+    },
+    // Streaming LLM endpoint (SSE)
+    {
+        method: 'POST',
+        pattern: /^\/(?:v1\/)?stream\/llm$/,
+        handler: async (req, res) => {
+            const body = await parseBody(req);
+            // Support both Bearer token and wallet in body
+            const wallet = getWalletFromAuth(req) || validateWallet(body.wallet);
+            if (!wallet) {
+                return error(res, 400, 'Invalid wallet address. Provide wallet in body or use Bearer token.', req.headers.origin);
+            }
+            // Rate limiting
+            const ip = getClientIp(req);
+            const rateLimit = gateway.checkRateLimit(wallet, ip);
+            if (!rateLimit.allowed) {
+                res.setHeader('Retry-After', rateLimit.retryAfter?.toString() || '60');
+                return error(res, 429, 'Rate limit exceeded', req.headers.origin);
+            }
+            // Check balance
+            const balance = await gateway.getBalance(wallet);
+            const minBalance = 0.001;
+            if (balance.available < minBalance) {
+                return error(res, 402, `Insufficient balance. Need at least $${minBalance}`, req.headers.origin);
+            }
+            // Build compute request
+            const computeReq = {
+                id: body.requestId || `req_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+                service: 'llm',
+                wallet,
+                payload: body.payload || body,
+                meta: typeof body.meta === 'object' ? body.meta : undefined,
+            };
+            // Set up SSE headers
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                'X-Powered-By': 'Clodds Compute',
+                'X-API-Version': API_VERSION,
+                ...getCorsHeaders(req.headers.origin),
+            });
+            // Send initial event
+            res.write(`data: ${JSON.stringify({ type: 'start', requestId: computeReq.id })}\n\n`);
+            try {
+                const stream = llm.executeStream(computeReq);
+                let finalResponse = null;
+                for await (const chunk of stream) {
+                    if (chunk.type === 'text' && chunk.text) {
+                        res.write(`data: ${JSON.stringify({ type: 'text', text: chunk.text })}\n\n`);
+                    }
+                    else if (chunk.type === 'done') {
+                        res.write(`data: ${JSON.stringify({ type: 'usage', usage: chunk.usage })}\n\n`);
+                    }
+                    else if (chunk.type === 'error') {
+                        res.write(`data: ${JSON.stringify({ type: 'error', error: chunk.error })}\n\n`);
+                    }
+                    // Check if generator returned final value
+                    const next = await stream.next();
+                    if (next.done && next.value) {
+                        finalResponse = next.value;
+                    }
+                }
+                // Send done event
+                res.write(`data: ${JSON.stringify({ type: 'done', response: finalResponse })}\n\n`);
+                res.end();
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : 'Stream error';
+                res.write(`data: ${JSON.stringify({ type: 'error', error: errorMsg })}\n\n`);
+                res.end();
+            }
+        },
+    },
+];
+// =============================================================================
+// SERVER
+// =============================================================================
+const server = (0, http_1.createServer)(async (req, res) => {
+    const origin = req.headers.origin;
+    // Handle CORS preflight
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204, getCorsHeaders(origin));
+        res.end();
+        return;
+    }
+    // Parse URL
+    const url = new URL(req.url || '/', `http://localhost:${PORT}`);
+    const pathname = url.pathname;
+    // Find matching route
+    for (const route of routes) {
+        if (req.method !== route.method)
+            continue;
+        const match = pathname.match(route.pattern);
+        if (match) {
+            try {
+                await route.handler(req, res, match);
+            }
+            catch (err) {
+                console.error(`Error handling ${req.method} ${pathname}:`, err);
+                error(res, 500, err instanceof Error ? err.message : 'Internal server error', origin);
+            }
+            return;
+        }
+    }
+    // 404
+    error(res, 404, `Not found: ${pathname}`, origin);
+});
+// =============================================================================
+// WEBSOCKET SERVER - Real-time job updates
+// =============================================================================
+const wss = new ws_1.WebSocketServer({ server, path: '/v1/jobs/stream' });
+// Track subscriptions: wallet -> Set of WebSocket clients
+const walletSubscriptions = new Map();
+// Track client -> wallet mapping for cleanup
+const clientWallets = new Map();
+wss.on('connection', (ws) => {
+    console.log('WebSocket client connected');
+    ws.on('message', (data) => {
+        try {
+            const msg = JSON.parse(data.toString());
+            if (msg.type === 'subscribe' && msg.wallet) {
+                const wallet = msg.wallet.toLowerCase();
+                // Validate wallet format
+                if (!/^0x[a-fA-F0-9]{40}$/.test(msg.wallet)) {
+                    ws.send(JSON.stringify({ type: 'error', message: 'Invalid wallet address' }));
+                    return;
+                }
+                // Remove from previous subscription if any
+                const prevWallet = clientWallets.get(ws);
+                if (prevWallet && prevWallet !== wallet) {
+                    walletSubscriptions.get(prevWallet)?.delete(ws);
+                }
+                // Add to new subscription
+                if (!walletSubscriptions.has(wallet)) {
+                    walletSubscriptions.set(wallet, new Set());
+                }
+                walletSubscriptions.get(wallet).add(ws);
+                clientWallets.set(ws, wallet);
+                ws.send(JSON.stringify({ type: 'subscribed', wallet }));
+            }
+            else if (msg.type === 'unsubscribe') {
+                const wallet = clientWallets.get(ws);
+                if (wallet) {
+                    walletSubscriptions.get(wallet)?.delete(ws);
+                    clientWallets.delete(ws);
+                    ws.send(JSON.stringify({ type: 'unsubscribed' }));
+                }
+            }
+            else if (msg.type === 'ping') {
+                ws.send(JSON.stringify({ type: 'pong', timestamp: Date.now() }));
+            }
+        }
+        catch {
+            ws.send(JSON.stringify({ type: 'error', message: 'Invalid message format' }));
+        }
+    });
+    ws.on('close', () => {
+        const wallet = clientWallets.get(ws);
+        if (wallet) {
+            walletSubscriptions.get(wallet)?.delete(ws);
+            clientWallets.delete(ws);
+        }
+        console.log('WebSocket client disconnected');
+    });
+    ws.on('error', (err) => {
+        console.error('WebSocket error:', err);
+    });
+    // Send welcome message
+    ws.send(JSON.stringify({
+        type: 'connected',
+        message: 'Connected to Clodds job updates stream. Send { "type": "subscribe", "wallet": "0x..." } to subscribe.',
+    }));
+});
+// Broadcast job updates to subscribed clients
+function broadcastJobUpdate(wallet, update) {
+    const clients = walletSubscriptions.get(wallet.toLowerCase());
+    if (!clients || clients.size === 0)
+        return;
+    const message = JSON.stringify({ type: 'job_update', ...update });
+    for (const client of clients) {
+        if (client.readyState === ws_1.WebSocket.OPEN) {
+            client.send(message);
+        }
+    }
+}
+// Subscribe to gateway events and broadcast to WebSocket clients
+gateway.events.on('job:started', (data) => {
+    broadcastJobUpdate(data.wallet, {
+        event: 'started',
+        jobId: data.jobId,
+        service: data.service,
+        timestamp: Date.now(),
+    });
+});
+gateway.events.on('job:completed', (data) => {
+    gateway.getJob(data.jobId).then(job => {
+        broadcastJobUpdate(data.wallet, {
+            event: 'completed',
+            jobId: data.jobId,
+            service: data.service,
+            cost: data.cost,
+            result: job?.result,
+            usage: job?.usage,
+            timestamp: Date.now(),
+        });
+    });
+});
+gateway.events.on('job:failed', (data) => {
+    broadcastJobUpdate(data.wallet, {
+        event: 'failed',
+        jobId: data.jobId,
+        error: data.error,
+        timestamp: Date.now(),
+    });
+});
+gateway.events.on('job:cancelled', (data) => {
+    broadcastJobUpdate(data.wallet, {
+        event: 'cancelled',
+        jobId: data.jobId,
+        timestamp: Date.now(),
+    });
+});
+// Graceful shutdown
+process.on('SIGTERM', () => {
+    console.log('Shutting down...');
+    wss.close();
+    gateway.shutdown();
+    server.close(() => {
+        console.log('Server closed');
+        process.exit(0);
+    });
+});
+process.on('SIGINT', () => {
+    console.log('Shutting down...');
+    wss.close();
+    gateway.shutdown();
+    server.close(() => {
+        console.log('Server closed');
+        process.exit(0);
+    });
+});
+// Start server
+server.listen(PORT, () => {
+    console.log(`\n✓ Clodds Compute API ${API_VERSION} running on http://0.0.0.0:${PORT}`);
+    console.log(`\nEndpoints:`);
+    console.log(`  GET  /v1/health           - Health check`);
+    console.log(`  GET  /v1/pricing          - Service pricing`);
+    console.log(`  GET  /v1/metrics          - API metrics`);
+    console.log(`  GET  /v1/admin/metrics    - Admin metrics (protected)`);
+    console.log(`  GET  /v1/cache/stats      - LLM cache statistics`);
+    console.log(`  DELETE /v1/cache          - Clear LLM cache`);
+    console.log(`  GET  /v1/balance/:wallet  - Check wallet balance`);
+    console.log(`  POST /v1/deposit          - Deposit credits`);
+    console.log(`  GET  /v1/usage/:wallet    - Usage statistics`);
+    console.log(`  GET  /v1/jobs/:wallet     - List wallet's jobs`);
+    console.log(`  GET  /v1/job/:jobId       - Get job status`);
+    console.log(`  DELETE /v1/job/:jobId     - Cancel job`);
+    console.log(`  POST /v1/compute/:service - Submit compute request`);
+    console.log(`  POST /v1/batch            - Submit batch of requests`);
+    console.log(`  POST /v1/stream/llm       - Streaming LLM (SSE)`);
+    console.log(`  POST /v1/apikeys          - Create API key`);
+    console.log(`  GET  /v1/apikeys/:wallet  - List API keys`);
+    console.log(`  DELETE /v1/apikeys/:wallet/:key - Revoke API key`);
+    console.log(`  WS   /v1/jobs/stream      - Real-time job updates`);
+    console.log(`\nServices: ${Object.keys(compute_1.COMPUTE_PRICING).join(', ')}`);
+    console.log(`\nAuthentication: Bearer token (API key) or wallet in request body`);
+    console.log(`\nPayment networks: Base, Ethereum, Polygon (USDC)`);
+});
+//# sourceMappingURL=server.js.map