atena-cli 0.1.0

package/dist/core/server.js

@@ -0,0 +1,776 @@
+// Server Mode for Eden CLI
+// Uses only native Node.js http module — zero extra dependencies
+import { createServer as createHttpServer } from 'node:http';
+import { URL } from 'node:url';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { analyticsEngine } from './analytics.js';
+import { authManager } from './auth.js';
+import { eventHub } from './events.js';
+// ── helpers ──────────────────────────────────────────────────────────
+function json(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload),
+    });
+    res.end(payload);
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString()));
+        req.on('error', reject);
+    });
+}
+function parseBasicAuth(req) {
+    const header = req.headers.authorization;
+    if (!header || !header.startsWith('Basic '))
+        return null;
+    const decoded = Buffer.from(header.slice(6), 'base64').toString();
+    const idx = decoded.indexOf(':');
+    if (idx < 0)
+        return null;
+    return { name: decoded.slice(0, idx), pass: decoded.slice(idx + 1) };
+}
+function parseBearerToken(req) {
+    const header = req.headers.authorization;
+    if (!header || !header.startsWith('Bearer '))
+        return null;
+    return header.slice(7);
+}
+function addCorsHeaders(res) {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+}
+// SSE helper for streaming
+function sse(res, data) {
+    res.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+function startSse(res) {
+    res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'Access-Control-Allow-Origin': '*',
+    });
+}
+// ── server class ─────────────────────────────────────────────────────
+export class EdenServer {
+    httpServer;
+    agent;
+    options;
+    sessions = new Map();
+    constructor(agent, options) {
+        this.agent = agent;
+        this.options = options;
+        this.httpServer = createHttpServer((req, res) => this.handleRequest(req, res));
+    }
+    // ── request router ─────────────────────────────────────────────────
+    async handleRequest(req, res) {
+        // CORS preflight
+        if (this.options.enableCors)
+            addCorsHeaders(res);
+        if (req.method === 'OPTIONS') {
+            json(res, 204, null);
+            return;
+        }
+        const url = new URL(req.url || '/', `http://${this.options.hostname}`);
+        // Parse path first
+        let reqPath = url.pathname;
+        if (reqPath !== '/' && reqPath.endsWith('/')) {
+            reqPath = reqPath.slice(0, -1);
+        }
+        const method = req.method ?? 'GET';
+        const normalizedPath = reqPath.startsWith('/api') ? reqPath.slice(4) : reqPath;
+        // Check auth token for protected routes (header or query param for SSE)
+        let token = parseBearerToken(req);
+        if (!token) {
+            token = url.searchParams.get('token');
+        }
+        const isAuthenticated = token ? authManager.validateToken(token).valid : false;
+        // Public routes that don't require auth
+        const publicRoutes = ['/health', '/login', '/register', '/auth/status'];
+        const isPublicRoute = publicRoutes.some(route => normalizedPath === route || normalizedPath.startsWith(route));
+        // Auth guard for protected routes
+        if (!isPublicRoute && !isAuthenticated) {
+            json(res, 401, { error: 'Unauthorized', message: 'Please login first' });
+            return;
+        }
+        if (!this.options.quiet) {
+            console.log(`[${new Date().toLocaleTimeString()}] ${method} ${reqPath}`);
+        }
+        try {
+            // POST /register
+            if (method === 'POST' && normalizedPath === '/register') {
+                const body = JSON.parse(await readBody(req));
+                if (!body.username || !body.password) {
+                    json(res, 400, { error: 'Username and password required' });
+                    return;
+                }
+                const result = await authManager.register(body.username, body.password);
+                if (result.success) {
+                    json(res, 201, { success: true, message: 'User registered successfully' });
+                }
+                else {
+                    json(res, 400, { error: result.error });
+                }
+                return;
+            }
+            // POST /login
+            if (method === 'POST' && normalizedPath === '/login') {
+                const body = JSON.parse(await readBody(req));
+                if (!body.username || !body.password) {
+                    json(res, 400, { error: 'Username and password required' });
+                    return;
+                }
+                const result = await authManager.login(body.username, body.password);
+                if (result.success) {
+                    json(res, 200, { success: true, token: result.token });
+                }
+                else {
+                    json(res, 401, { error: result.error });
+                }
+                return;
+            }
+            // POST /logout
+            if (method === 'POST' && normalizedPath === '/logout') {
+                if (token) {
+                    await authManager.logout(token);
+                }
+                json(res, 200, { success: true, message: 'Logged out successfully' });
+                return;
+            }
+            // GET /auth/status
+            if (method === 'GET' && normalizedPath === '/auth/status') {
+                const validation = token ? authManager.validateToken(token) : { valid: false };
+                json(res, 200, {
+                    authenticated: validation.valid,
+                    user: validation.user ? { username: validation.user.username } : null,
+                    hasUsers: authManager.hasUsers()
+                });
+                return;
+            }
+            // GET /agents
+            if (method === 'GET' && normalizedPath === '/agents') {
+                const agentList = this.agent.getAgentManager().listAgents();
+                json(res, 200, { agents: agentList });
+                return;
+            }
+            // POST /agents
+            if (method === 'POST' && normalizedPath === '/agents') {
+                const body = JSON.parse(await readBody(req));
+                if (!body.id || !body.name || !body.systemPrompt) {
+                    json(res, 400, { error: 'id, name, and systemPrompt are required' });
+                    return;
+                }
+                // Check if agent already exists
+                if (this.agent.getAgentManager().hasAgent(body.id)) {
+                    json(res, 200, { status: 'exists', message: 'Agent already exists', agent: this.agent.getAgentManager().getAgent(body.id) });
+                    return;
+                }
+                await this.agent.getAgentManager().registerAgent(body);
+                json(res, 201, { status: 'registered', agent: body });
+                return;
+            }
+            // GET /model-profiles - List all available model profiles
+            if (method === 'GET' && normalizedPath === '/model-profiles') {
+                const { listAllProfiles } = await import('./model-profiles.js');
+                json(res, 200, { profiles: listAllProfiles() });
+                return;
+            }
+            // GET /agents/:id/model-profile - Get agent's model profile
+            const agentModelMatch = normalizedPath.match(/^\/agents\/([^/]+)\/model-profile$/);
+            if (method === 'GET' && agentModelMatch) {
+                const agentId = agentModelMatch[1];
+                const profileInfo = this.agent.getAgentManager().getAgentModelProfile(agentId);
+                if (!profileInfo) {
+                    json(res, 404, { error: 'Agent not found' });
+                    return;
+                }
+                json(res, 200, profileInfo);
+                return;
+            }
+            // POST /agents/:id/model-profile - Set agent's model profile
+            if (method === 'POST' && agentModelMatch) {
+                const agentId = agentModelMatch[1];
+                const body = JSON.parse(await readBody(req));
+                if (!body.profileId) {
+                    json(res, 400, { error: 'profileId is required' });
+                    return;
+                }
+                const success = this.agent.getAgentManager().setAgentModelProfile(agentId, body.profileId);
+                if (!success) {
+                    json(res, 404, { error: 'Agent not found' });
+                    return;
+                }
+                json(res, 200, { success: true, profileId: body.profileId });
+                return;
+            }
+            // GET /agents/:id/rag-config - Get agent's RAG config
+            const agentRagMatch = normalizedPath.match(/^\/agents\/([^/]+)\/rag-config$/);
+            if (method === 'GET' && agentRagMatch) {
+                const agentId = agentRagMatch[1];
+                const agent = this.agent.getAgentManager().getAgent(agentId);
+                if (!agent) {
+                    json(res, 404, { error: 'Agent not found' });
+                    return;
+                }
+                json(res, 200, {
+                    enabled: agent.ragConfig?.enabled ?? true,
+                    customInstructions: agent.ragConfig?.customInstructions || null
+                });
+                return;
+            }
+            // POST /agents/:id/rag-config - Update agent's RAG config
+            if (method === 'POST' && agentRagMatch) {
+                const agentId = agentRagMatch[1];
+                const body = JSON.parse(await readBody(req));
+                const success = this.agent.getAgentManager().updateAgentRagConfig(agentId, body);
+                if (!success) {
+                    json(res, 404, { error: 'Agent not found' });
+                    return;
+                }
+                json(res, 200, { success: true });
+                return;
+            }
+            // GET /notifications
+            if (method === 'GET' && normalizedPath === '/notifications') {
+                json(res, 200, { notifications: this.agent.getNotifications() });
+                return;
+            }
+            // POST /approve
+            if (method === 'POST' && normalizedPath === '/approve') {
+                const body = JSON.parse(await readBody(req));
+                const { id, approved } = body;
+                const success = this.agent.resolveApproval(id, approved);
+                json(res, 200, { success });
+                return;
+            }
+            // GET /health
+            if (method === 'GET' && (normalizedPath === '/health' || normalizedPath === '')) {
+                json(res, 200, {
+                    status: 'ok',
+                    version: '3.0.0',
+                    uptime: process.uptime(),
+                    features: ['agents', 'sessions', 'permissions', 'mcp', 'orchestration', 'sandbox'],
+                });
+                return;
+            }
+            // GET /workspaces
+            if (method === 'GET' && normalizedPath === '/workspaces') {
+                try {
+                    const wFile = path.join(os.homedir(), '.eden', 'workspaces.json');
+                    const data = await fs.readFile(wFile, 'utf8');
+                    json(res, 200, { workspaces: JSON.parse(data) });
+                }
+                catch {
+                    json(res, 200, { workspaces: [] });
+                }
+                return;
+            }
+            // GET /fs/home
+            if (method === 'GET' && normalizedPath === '/fs/home') {
+                json(res, 200, { home: os.homedir() });
+                return;
+            }
+            // GET /files - Universal File Hub
+            if (method === 'GET' && normalizedPath === '/files') {
+                const root = url.searchParams.get('root') || this.agent.getCwd();
+                try {
+                    const entries = await fs.readdir(root, { withFileTypes: true });
+                    const list = entries.map(e => ({
+                        name: e.name,
+                        type: e.isDirectory() ? 'directory' : 'file',
+                        path: path.join(root, e.name)
+                    }));
+                    json(res, 200, { currentPath: root, files: list });
+                }
+                catch (e) {
+                    json(res, 500, { error: 'Failed to list files' });
+                }
+                return;
+            }
+            // GET /fs/list
+            if (method === 'GET' && normalizedPath === '/fs/list') {
+                const p = url.searchParams.get('path') || os.homedir();
+                try {
+                    const entries = await fs.readdir(p, { withFileTypes: true });
+                    const dirs = entries
+                        .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+                        .map(e => ({ name: e.name, path: path.join(p, e.name) }));
+                    json(res, 200, { currentPath: p, directories: dirs });
+                }
+                catch (e) {
+                    json(res, 500, { error: 'Could not read directory' });
+                }
+                return;
+            }
+            // POST /workspaces
+            if (method === 'POST' && normalizedPath === '/workspaces') {
+                const body = JSON.parse(await readBody(req));
+                if (!body.path) {
+                    json(res, 400, { error: 'path required' });
+                    return;
+                }
+                const wfile = path.join(os.homedir(), '.eden', 'workspaces.json');
+                let current = [];
+                try {
+                    current = JSON.parse(await fs.readFile(wfile, 'utf8'));
+                }
+                catch { }
+                if (!current.includes(body.path)) {
+                    current.unshift(body.path);
+                    await fs.mkdir(path.join(os.homedir(), '.eden'), { recursive: true });
+                    await fs.writeFile(wfile, JSON.stringify(current, null, 2));
+                }
+                json(res, 200, { status: 'added', workspaces: current });
+                return;
+            }
+            // POST /files/upload - Simple File Placement
+            if (method === 'POST' && normalizedPath === '/files/upload') {
+                const body = JSON.parse(await readBody(req));
+                if (!body.filename || !body.content) {
+                    json(res, 400, { error: 'filename and content required' });
+                    return;
+                }
+                const filePath = path.join(this.agent.getCwd(), body.filename);
+                await fs.writeFile(filePath, body.content);
+                json(res, 201, { status: 'uploaded', path: filePath });
+                return;
+            }
+            // GET /workflows
+            if (method === 'GET' && normalizedPath === '/workflows') {
+                try {
+                    const flowDir = path.join(process.cwd(), '.eden', 'workflows');
+                    const files = await fs.readdir(flowDir);
+                    const flows = files.filter(f => f.endsWith('.md')).map(f => f.replace('.md', ''));
+                    json(res, 200, { workflows: flows });
+                }
+                catch {
+                    json(res, 200, { workflows: [] });
+                }
+                return;
+            }
+            // POST /workflows - Create new workflow
+            if (method === 'POST' && normalizedPath === '/workflows') {
+                const body = JSON.parse(await readBody(req));
+                if (!body.name || !body.content) {
+                    json(res, 400, { error: 'name and content required' });
+                    return;
+                }
+                try {
+                    const filePath = path.join(process.cwd(), '.eden', 'workflows', `${body.name.replace(/\s+/g, '_')}.md`);
+                    await fs.mkdir(path.dirname(filePath), { recursive: true });
+                    await fs.writeFile(filePath, body.content);
+                    json(res, 201, { status: 'created', name: body.name });
+                }
+                catch (e) {
+                    json(res, 500, { error: 'Failed to save workflow' });
+                }
+                return;
+            }
+            // POST /workflows/execute
+            if (method === 'POST' && normalizedPath === '/workflows/execute') {
+                const body = JSON.parse(await readBody(req));
+                if (!body.name) {
+                    json(res, 400, { error: 'workflow name required' });
+                    return;
+                }
+                // Execute in background
+                // We use a fixed or session-based ID if possible, but the agent is a singleton.
+                // We ensure it logs to its own transcript.
+                this.agent.runWorkflow(body.name).catch(e => console.error('Workflow execution error:', e));
+                json(res, 202, { status: 'triggered', workflow: body.name, sessionId: 'eden_session' });
+                return;
+            }
+            // DELETE /workspaces
+            if (method === 'DELETE' && normalizedPath === '/workspaces') {
+                const body = JSON.parse(await readBody(req));
+                if (!body.path) {
+                    json(res, 400, { error: 'path required' });
+                    return;
+                }
+                const wfile = path.join(os.homedir(), '.eden', 'workspaces.json');
+                let current = [];
+                try {
+                    current = JSON.parse(await fs.readFile(wfile, 'utf8'));
+                }
+                catch { }
+                current = current.filter(p => p !== body.path);
+                await fs.writeFile(wfile, JSON.stringify(current, null, 2));
+                json(res, 200, { status: 'removed', workspaces: current });
+                return;
+            }
+            // POST /orchestrate
+            if (method === 'POST' && normalizedPath === '/orchestrate') {
+                const body = JSON.parse(await readBody(req));
+                if (!body.tasks || !Array.isArray(body.tasks)) {
+                    json(res, 400, { error: 'tasks array required' });
+                    return;
+                }
+                json(res, 202, { status: 'orchestrating', tasksCount: body.tasks.length });
+                (async () => {
+                    const { tools } = await import('./tools/index.js');
+                    const orchestrateTool = tools.find((t) => t.definition.name === 'delegate_tasks');
+                    if (orchestrateTool) {
+                        try {
+                            await orchestrateTool.handler({ tasks: body.tasks });
+                        }
+                        catch (e) {
+                            console.error('Orchestration error:', e);
+                        }
+                    }
+                })();
+                return;
+            }
+            // POST /orchestrator/plan - Create a new orchestrated task
+            if (method === 'POST' && normalizedPath === '/orchestrator/plan') {
+                try {
+                    const body = JSON.parse(await readBody(req));
+                    if (!body.prompt) {
+                        json(res, 400, { error: 'prompt is required' });
+                        return;
+                    }
+                    const { TaskOrchestrator } = await import('./orchestrator.js');
+                    const orchestrator = new TaskOrchestrator(this.agent, this.agent['options'].cwd);
+                    await orchestrator.initialize();
+                    const task = await orchestrator.planTask(body.prompt);
+                    json(res, 200, {
+                        success: true,
+                        task,
+                        message: `Created task with ${task.subtasks.length} subtasks`
+                    });
+                }
+                catch (error) {
+                    json(res, 500, { error: String(error) });
+                }
+                return;
+            }
+            // POST /orchestrator/execute - Execute a planned task
+            if (method === 'POST' && normalizedPath === '/orchestrator/execute') {
+                try {
+                    const body = JSON.parse(await readBody(req));
+                    if (!body.taskId) {
+                        json(res, 400, { error: 'taskId is required' });
+                        return;
+                    }
+                    const { TaskOrchestrator } = await import('./orchestrator.js');
+                    const orchestrator = new TaskOrchestrator(this.agent, this.agent['options'].cwd);
+                    await orchestrator.initialize();
+                    const task = await orchestrator.loadTask(body.taskId);
+                    if (!task) {
+                        json(res, 404, { error: 'Task not found' });
+                        return;
+                    }
+                    // Execute in background
+                    json(res, 202, { status: 'executing', taskId: body.taskId });
+                    (async () => {
+                        try {
+                            await orchestrator.executeAll();
+                        }
+                        catch (e) {
+                            console.error('Orchestrator execution error:', e);
+                        }
+                    })();
+                }
+                catch (error) {
+                    json(res, 500, { error: String(error) });
+                }
+                return;
+            }
+            // GET /orchestrator/progress - Get task progress
+            if (method === 'GET' && normalizedPath === '/orchestrator/progress') {
+                try {
+                    const url = new URL(req.url || '/', `http://${req.headers.host}`);
+                    const taskId = url.searchParams.get('taskId');
+                    if (!taskId) {
+                        json(res, 400, { error: 'taskId query parameter is required' });
+                        return;
+                    }
+                    const { TaskOrchestrator } = await import('./orchestrator.js');
+                    const orchestrator = new TaskOrchestrator(this.agent, this.agent['options'].cwd);
+                    const task = await orchestrator.loadTask(taskId);
+                    if (!task) {
+                        json(res, 404, { error: 'Task not found' });
+                        return;
+                    }
+                    const progress = orchestrator.getProgress();
+                    json(res, 200, {
+                        task,
+                        progress,
+                        logs: [] // TODO: Implement log streaming
+                    });
+                }
+                catch (error) {
+                    json(res, 500, { error: String(error) });
+                }
+                return;
+            }
+            // GET /permissions
+            if (method === 'GET' && normalizedPath === '/permissions') {
+                const perms = this.agent['permissionManager'].getPermissions();
+                json(res, 200, perms);
+                return;
+            }
+            // POST /permissions
+            if (method === 'POST' && normalizedPath === '/permissions') {
+                const body = JSON.parse(await readBody(req));
+                this.agent['permissionManager'].setPermissions(body);
+                json(res, 200, { status: 'updated', permissions: body });
+                return;
+            }
+            // GET /config
+            if (method === 'GET' && normalizedPath === '/config') {
+                json(res, 200, {
+                    ollamaUrl: this.agent['options'].ollamaUrl,
+                    model: this.agent['options'].model,
+                    cwd: this.agent['options'].cwd,
+                    telegramToken: this.agent['options'].telegramToken,
+                    dryRun: this.agent['sandboxManager']['options'].dryRun,
+                    useDocker: this.agent['sandboxManager']['options'].useDocker
+                });
+                return;
+            }
+            // POST /config
+            if (method === 'POST' && normalizedPath === '/config') {
+                const body = JSON.parse(await readBody(req));
+                if (body.model)
+                    this.agent['options'].model = body.model;
+                if (body.ollamaUrl)
+                    this.agent['options'].ollamaUrl = body.ollamaUrl;
+                if (body.telegramToken !== undefined) {
+                    this.agent['options'].telegramToken = body.telegramToken;
+                    if (body.telegramToken) {
+                        this.agent.getTelegramManager().start(body.telegramToken);
+                    }
+                    else {
+                        this.agent.getTelegramManager().stop();
+                    }
+                }
+                if (body.dryRun !== undefined) {
+                    this.agent.getSandboxManager().setDryRun(body.dryRun);
+                }
+                if (body.useDocker !== undefined) {
+                    this.agent.getSandboxManager().setUseDocker(body.useDocker);
+                }
+                json(res, 200, { status: 'updated', config: body });
+                return;
+            }
+            // POST /chat — create session OR send message (compatible with web client)
+            if (method === 'POST' && normalizedPath === '/chat') {
+                const body = JSON.parse(await readBody(req));
+                // If message is provided, treat as direct message send (web client style)
+                if (body.message) {
+                    const sid = body.sessionId || 'eden_session';
+                    // Ensure session exists
+                    if (!this.sessions.has(sid)) {
+                        this.sessions.set(sid, { id: sid, messages: [], createdAt: new Date().toISOString() });
+                    }
+                    // Change agent CWD if workspace provided
+                    if (body.workspace) {
+                        this.agent.setCwd(body.workspace);
+                    }
+                    // Trigger agent workflow asynchronously (fire and forget for streaming)
+                    (async () => {
+                        try {
+                            await this.agent.runSingleTurn(body.message);
+                        }
+                        catch (err) {
+                            console.error('Agent error:', err);
+                        }
+                    })();
+                    // Return immediately with session info
+                    json(res, 200, {
+                        sessionId: sid,
+                        status: 'processing',
+                        timestamp: new Date().toISOString()
+                    });
+                    return;
+                }
+                // Otherwise create new session
+                const sid = body.sessionId || `http_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+                this.sessions.set(sid, { id: sid, messages: [], createdAt: new Date().toISOString() });
+                json(res, 200, { sessionId: sid, status: 'created' });
+                return;
+            }
+            // POST /chat/:id/message
+            const msgMatch = normalizedPath.match(/^\/chat\/([^/]+)\/message$/);
+            if (method === 'POST' && msgMatch) {
+                const sid = msgMatch[1];
+                const session = this.sessions.get(sid);
+                if (!session) {
+                    json(res, 404, { error: 'Session not found' });
+                    return;
+                }
+                const body = JSON.parse(await readBody(req));
+                if (!body.message) {
+                    json(res, 400, { error: 'message is required' });
+                    return;
+                }
+                // Change agent CWD if workspace provided
+                if (body.workspace) {
+                    this.agent.setCwd(body.workspace);
+                }
+                // Trigger agent workflow
+                await this.agent.runSingleTurn(body.message);
+                // Grab transcript
+                const transcript = this.agent.getTranscript();
+                json(res, 200, {
+                    sessionId: sid,
+                    transcript: transcript, // Returns the full conversation history blocks
+                    timestamp: new Date().toISOString()
+                });
+                return;
+            }
+            // GET /chat/:id/history
+            const histMatch = normalizedPath.match(/^\/chat\/([^/]+)\/history$/);
+            if (method === 'GET' && histMatch) {
+                const sid = histMatch[1];
+                // Auto-create session if it doesn't exist (for web client compatibility)
+                if (!this.sessions.has(sid)) {
+                    this.sessions.set(sid, { id: sid, messages: [], createdAt: new Date().toISOString() });
+                }
+                const session = this.sessions.get(sid);
+                // Return the agent's transcript (shared across all sessions)
+                json(res, 200, { sessionId: session.id, transcript: this.agent.getTranscript() });
+                return;
+            }
+            // GET /chat/:id/stream - SSE streaming endpoint
+            const streamMatch = normalizedPath.match(/^\/chat\/([^/]+)\/stream$/);
+            if (method === 'GET' && streamMatch) {
+                const sid = streamMatch[1];
+                startSse(res);
+                // Send initial connection message
+                sse(res, { type: 'connected', sessionId: sid });
+                // Listen for real-time events from EventHub
+                const eventHandler = (event) => {
+                    if (event.type === 'transcript_entry') {
+                        sse(res, { type: 'message', data: event.data });
+                    }
+                    else if (event.type === 'tool_call' || event.type === 'tool_result') {
+                        sse(res, { type: 'message', data: event.data });
+                    }
+                    else if (event.type === 'stream_start' || event.type === 'stream_chunk' || event.type === 'stream_end') {
+                        // Forward streaming events for real-time character display
+                        sse(res, { type: event.type, data: event.data });
+                    }
+                };
+                eventHub.onEvent(eventHandler);
+                // Clean up on client disconnect
+                res.on('close', () => {
+                    eventHub.removeListener('eden_event', eventHandler);
+                });
+                return;
+            }
+            // DELETE /chat/:id
+            const delMatch = normalizedPath.match(/^\/chat\/([^/]+)$/);
+            if (method === 'DELETE' && delMatch) {
+                this.sessions.delete(delMatch[1]);
+                json(res, 200, { status: 'deleted', sessionId: delMatch[1] });
+                return;
+            }
+            // GET /stats
+            if (method === 'GET' && normalizedPath === '/stats') {
+                const days = Number(url.searchParams.get('days') || 7);
+                json(res, 200, { days, totalSessions: this.sessions.size, totalTokens: 0, totalCost: 0 });
+                return;
+            }
+            // GET /analytics
+            if (method === 'GET' && normalizedPath === '/analytics') {
+                json(res, 200, analyticsEngine.getStats());
+                return;
+            }
+            // GET /sessions
+            if (method === 'GET' && normalizedPath === '/sessions') {
+                const list = Array.from(this.sessions.values()).map(s => ({
+                    id: s.id, messageCount: s.messages.length, createdAt: s.createdAt,
+                }));
+                json(res, 200, { sessions: list });
+                return;
+            }
+            // POST /sessions - Save session
+            if (method === 'POST' && normalizedPath === '/sessions') {
+                const body = JSON.parse(await readBody(req));
+                this.sessions.set(body.id, {
+                    id: body.id,
+                    messages: body.messages || [],
+                    createdAt: body.createdAt || new Date().toISOString()
+                });
+                json(res, 200, { status: 'saved', sessionId: body.id });
+                return;
+            }
+            // GET /sessions/all (Persistent)
+            if (method === 'GET' && normalizedPath === '/sessions/all') {
+                const list = await this.agent.listPersistentSessions();
+                json(res, 200, { sessions: list });
+                return;
+            }
+            // GET /tasks
+            if (method === 'GET' && normalizedPath === '/tasks') {
+                json(res, 200, { tasks: this.agent.getActiveTasks() });
+                return;
+            }
+            // GET /search?q=...
+            if (method === 'GET' && normalizedPath === '/search') {
+                const query = url.searchParams.get('q') || '';
+                const results = this.agent.getCodeIndexer().search(query);
+                json(res, 200, results);
+                return;
+            }
+            // GET /swarm/workers
+            if (method === 'GET' && normalizedPath === '/swarm/workers') {
+                json(res, 200, { workers: this.agent['swarmManager'].listWorkers() });
+                return;
+            }
+            // 404
+            json(res, 404, { error: 'Not found', method, path: reqPath });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            json(res, 500, { error: message });
+        }
+    }
+    // ── lifecycle ──────────────────────────────────────────────────────
+    async start() {
+        return new Promise((resolve, reject) => {
+            this.httpServer.listen(this.options.port, this.options.hostname, () => {
+                const base = `http://${this.options.hostname}:${this.options.port}`;
+                console.log(`\n🚀 Eden Server v3.0.0`);
+                console.log(`   ${base}`);
+                console.log(this.options.password
+                    ? `   Auth: Enabled (user: ${this.options.username || 'eden'})`
+                    : `   Auth: Disabled`);
+                console.log(`\n   Endpoints:`);
+                console.log(`   GET  /health             Health check`);
+                console.log(`   GET  /agents             List agents`);
+                console.log(`   GET  /permissions        Current permissions`);
+                console.log(`   POST /chat               Create session`);
+                console.log(`   POST /chat/:id/message   Send message`);
+                console.log(`   GET  /chat/:id/history   Session history`);
+                console.log(`   DEL  /chat/:id           Delete session`);
+                console.log(`   GET  /sessions           List sessions`);
+                console.log(`   GET  /stats              Usage stats`);
+                console.log('');
+                resolve();
+            });
+            this.httpServer.on('error', reject);
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            this.sessions.clear();
+            this.httpServer.close(() => {
+                console.log('Server stopped');
+                resolve();
+            });
+        });
+    }
+}
+export function createEdenServer(agent, options) {
+    return new EdenServer(agent, options);
+}
+//# sourceMappingURL=server.js.map