@hoangsonw/forge 0.1.0

package/dist/ui/server.js

@@ -0,0 +1,815 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startUiServer = void 0;
+/**
+ * Forge UI server. Serves the dashboard, streams live events per project,
+ * and exposes the CLI's capabilities over HTTP + WebSocket. The runtime
+ * runs in-process so every CLI capability is reachable without shelling
+ * out; this keeps UI-driven tasks under the same permission and sandbox
+ * rules as CLI-driven tasks.
+ */
+const http = __importStar(require("http"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const url_1 = require("url");
+const ws_1 = require("ws");
+const index_db_1 = require("../persistence/index-db");
+const tasks_1 = require("../persistence/tasks");
+const sessions_1 = require("../persistence/sessions");
+const loader_1 = require("../config/loader");
+const paths_1 = require("../config/paths");
+const control_1 = require("../daemon/control");
+const provider_1 = require("../models/provider");
+const logger_1 = require("../logging/logger");
+const redact_1 = require("../security/redact");
+const cost_1 = require("../models/cost");
+const loader_2 = require("../skills/loader");
+const marketplace_1 = require("../skills/marketplace");
+const registry_1 = require("../mcp/registry");
+const search_1 = require("../web/search");
+const fetch_1 = require("../web/fetch");
+const cold_1 = require("../memory/cold");
+const task_runner_1 = require("./task-runner");
+const chat_1 = require("./chat");
+// ---------- helpers ----------
+const sendJson = (res, status, body) => {
+    const payload = JSON.stringify((0, redact_1.redact)(body));
+    res.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'content-length': Buffer.byteLength(payload),
+        'access-control-allow-origin': '*',
+        'access-control-allow-headers': 'content-type',
+        'access-control-allow-methods': 'GET, POST, DELETE, OPTIONS',
+    });
+    res.end(payload);
+};
+// `errorBody()` lives in ./server-errors so unit tests can import it
+// without requiring the entire server (sqlite, ws, etc).
+const server_errors_1 = require("./server-errors");
+const sendStatic = (res, filePath) => {
+    try {
+        const body = fs.readFileSync(filePath);
+        const ext = path.extname(filePath).toLowerCase();
+        const contentType = ext === '.html'
+            ? 'text/html; charset=utf-8'
+            : ext === '.js'
+                ? 'application/javascript; charset=utf-8'
+                : ext === '.css'
+                    ? 'text/css; charset=utf-8'
+                    : ext === '.svg'
+                        ? 'image/svg+xml'
+                        : ext === '.json'
+                            ? 'application/json'
+                            : 'application/octet-stream';
+        res.writeHead(200, { 'content-type': contentType, 'cache-control': 'no-cache' });
+        res.end(body);
+    }
+    catch {
+        res.writeHead(404);
+        res.end('not found');
+    }
+};
+const readBody = (req, limit = 256 * 1024) => new Promise((resolve, reject) => {
+    let total = 0;
+    const chunks = [];
+    req.on('data', (chunk) => {
+        total += chunk.length;
+        if (total > limit) {
+            reject(new Error('body too large'));
+            return;
+        }
+        chunks.push(chunk);
+    });
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    req.on('error', reject);
+});
+const parseJson = async (req) => {
+    const raw = await readBody(req);
+    if (!raw.trim())
+        return {};
+    return JSON.parse(raw);
+};
+// ---------- routes ----------
+const router = async (req, res, publicDir) => {
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204, {
+            'access-control-allow-origin': '*',
+            'access-control-allow-methods': 'GET, POST, DELETE, OPTIONS',
+            'access-control-allow-headers': 'content-type',
+        });
+        res.end();
+        return;
+    }
+    const u = new url_1.URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+    const p = u.pathname;
+    // ---- Health ----
+    if (p === '/healthz') {
+        return sendJson(res, 200, { status: 'ok', uptime: process.uptime() });
+    }
+    // ---- Status / projects / config ----
+    if (p === '/api/status') {
+        const cfg = (0, loader_1.loadGlobalConfig)();
+        const d = (0, control_1.daemonStatus)();
+        const providers = await Promise.all((0, provider_1.listProviders)().map(async (prov) => ({
+            name: prov.name,
+            available: await prov.isAvailable().catch(() => false),
+        })));
+        return sendJson(res, 200, {
+            provider: cfg.provider,
+            defaultMode: cfg.defaultMode,
+            channel: cfg.update.channel,
+            daemon: d,
+            providers,
+            cwd: process.cwd(),
+            version: (() => {
+                try {
+                    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf8'));
+                    return pkg.version ?? null;
+                }
+                catch {
+                    return null;
+                }
+            })(),
+        });
+    }
+    if (p === '/api/projects') {
+        return sendJson(res, 200, (0, index_db_1.listProjects)());
+    }
+    if (p === '/api/config' && req.method === 'GET') {
+        return sendJson(res, 200, (0, loader_1.loadGlobalConfig)());
+    }
+    if (p === '/api/config' && req.method === 'POST') {
+        try {
+            const body = await parseJson(req);
+            if (!body.key)
+                return sendJson(res, 400, { error: 'key required' });
+            const updated = (0, loader_1.updateGlobalConfig)((cfg) => {
+                const clone = JSON.parse(JSON.stringify(cfg));
+                setNested(clone, body.key, body.value);
+                return clone;
+            });
+            return sendJson(res, 200, updated);
+        }
+        catch (e) {
+            {
+                const { status, body } = (0, server_errors_1.errorBody)(e);
+                return sendJson(res, status, body);
+            }
+        }
+    }
+    // ---- Tasks (index) ----
+    if (p === '/api/tasks' && req.method === 'GET') {
+        const projectId = u.searchParams.get('project') ?? undefined;
+        const query = u.searchParams.get('q');
+        const limit = Number(u.searchParams.get('limit') ?? 50);
+        const rows = query ? (0, index_db_1.searchTasks)(query, limit) : (0, index_db_1.listTasks)(projectId, limit);
+        return sendJson(res, 200, rows);
+    }
+    // ---- Running UI tasks (must come BEFORE the generic /api/tasks/:id regex) ----
+    if (p === '/api/tasks/run' && req.method === 'POST') {
+        try {
+            const body = await parseJson(req);
+            if (!body.prompt?.trim())
+                return sendJson(res, 400, { error: 'prompt required' });
+            const reply = (0, task_runner_1.startUiTask)({
+                prompt: body.prompt,
+                mode: body.mode,
+                cwd: body.cwd,
+                autoApprove: body.autoApprove,
+                flags: body.flags,
+                title: body.title,
+            });
+            return sendJson(res, 202, reply);
+        }
+        catch (e) {
+            {
+                const { status, body } = (0, server_errors_1.errorBody)(e);
+                return sendJson(res, status, body);
+            }
+        }
+    }
+    if (p === '/api/tasks/active' && req.method === 'GET') {
+        return sendJson(res, 200, { active: (0, task_runner_1.listActive)(), pending: (0, task_runner_1.listPendingPrompts)() });
+    }
+    const cancelMatch = /^\/api\/tasks\/([a-f0-9]+)\/cancel$/.exec(p);
+    if (cancelMatch && req.method === 'POST') {
+        const ok = (0, task_runner_1.cancelTask)(cancelMatch[1]);
+        return sendJson(res, ok ? 200 : 404, { cancelled: ok });
+    }
+    if (p === '/api/prompts/respond' && req.method === 'POST') {
+        try {
+            const body = await parseJson(req);
+            const ok = (0, task_runner_1.respond)(body.promptId, body.value);
+            return sendJson(res, ok ? 200 : 404, { resolved: ok });
+        }
+        catch (e) {
+            {
+                const { status, body } = (0, server_errors_1.errorBody)(e);
+                return sendJson(res, status, body);
+            }
+        }
+    }
+    // Historical task detail — last to avoid catching /active, /run, /<id>/cancel.
+    const taskMatch = /^\/api\/tasks\/([a-z0-9_]+)$/.exec(p);
+    if (taskMatch && req.method === 'GET') {
+        const projectPath = u.searchParams.get('projectPath') ?? (0, loader_1.findProjectRoot)() ?? process.cwd();
+        const task = (0, tasks_1.loadTask)(projectPath, taskMatch[1]);
+        if (!task)
+            return sendJson(res, 404, { error: 'task not found' });
+        return sendJson(res, 200, task);
+    }
+    // ---- Sessions ----
+    const sessionMatch = /^\/api\/sessions\/([a-z0-9_]+)$/.exec(p);
+    if (sessionMatch) {
+        const projectPath = u.searchParams.get('projectPath');
+        if (!projectPath)
+            return sendJson(res, 400, { error: 'projectPath required' });
+        const entries = await (0, sessions_1.loadSession)(projectPath, sessionMatch[1]);
+        return sendJson(res, 200, entries);
+    }
+    // ---- Chat / Conversations (unified; REPL and Web share the same store) ----
+    if (p === '/api/chat/sessions' && req.method === 'GET') {
+        const projectPath = u.searchParams.get('projectPath') ?? (0, loader_1.findProjectRoot)() ?? process.cwd();
+        return sendJson(res, 200, (0, chat_1.listChatSessions)(projectPath));
+    }
+    if (p === '/api/chat/sessions' && req.method === 'POST') {
+        try {
+            const body = await parseJson(req);
+            const projectPath = body.projectPath ?? (0, loader_1.findProjectRoot)() ?? process.cwd();
+            const session = await (0, chat_1.createChatSession)({
+                projectPath,
+                title: body.title,
+                mode: body.mode,
+                source: body.source ?? 'chat',
+            });
+            return sendJson(res, 201, session);
+        }
+        catch (e) {
+            {
+                const { status, body } = (0, server_errors_1.errorBody)(e);
+                return sendJson(res, status, body);
+            }
+        }
+    }
+    // Accept both chat-*, repl-*, and conv-* ids so the UI can display + edit
+    // any conversation irrespective of which surface created it.
+    const chatSessionMatch = /^\/api\/chat\/sessions\/((?:chat|repl|conv)-[a-z0-9_]+)$/.exec(p);
+    if (chatSessionMatch && req.method === 'GET') {
+        const projectPath = u.searchParams.get('projectPath') ?? (0, loader_1.findProjectRoot)() ?? process.cwd();
+        const session = (0, chat_1.getChatSession)(projectPath, chatSessionMatch[1]);
+        if (!session)
+            return sendJson(res, 404, { error: 'conversation not found' });
+        return sendJson(res, 200, session);
+    }
+    if (chatSessionMatch && req.method === 'DELETE') {
+        const projectPath = u.searchParams.get('projectPath') ?? (0, loader_1.findProjectRoot)() ?? process.cwd();
+        const ok = (0, chat_1.deleteChatSession)(projectPath, chatSessionMatch[1]);
+        return sendJson(res, ok ? 200 : 404, { deleted: ok });
+    }
+    if (chatSessionMatch && req.method === 'PATCH') {
+        try {
+            const body = await parseJson(req);
+            if (!body.title)
+                return sendJson(res, 400, { error: 'title required' });
+            const projectPath = body.projectPath ?? (0, loader_1.findProjectRoot)() ?? process.cwd();
+            const s = await (0, chat_1.renameChatSession)(projectPath, chatSessionMatch[1], body.title);
+            if (!s)
+                return sendJson(res, 404, { error: 'conversation not found' });
+            return sendJson(res, 200, s);
+        }
+        catch (e) {
+            {
+                const { status, body } = (0, server_errors_1.errorBody)(e);
+                return sendJson(res, status, body);
+            }
+        }
+    }
+    const chatTurnMatch = /^\/api\/chat\/sessions\/((?:chat|repl|conv)-[a-z0-9_]+)\/turns$/.exec(p);
+    if (chatTurnMatch && req.method === 'POST') {
+        try {
+            const body = await parseJson(req);
+            if (!body.input?.trim())
+                return sendJson(res, 400, { error: 'input required' });
+            const projectPath = body.projectPath ?? (0, loader_1.findProjectRoot)() ?? process.cwd();
+            const reply = await (0, chat_1.addTurn)({
+                projectPath,
+                conversationId: chatTurnMatch[1],
+                input: body.input,
+                mode: body.mode,
+                autoApprove: body.autoApprove,
+                flags: body.flags,
+            });
+            return sendJson(res, 202, reply);
+        }
+        catch (e) {
+            {
+                const { status, body } = (0, server_errors_1.errorBody)(e);
+                return sendJson(res, status, body);
+            }
+        }
+    }
+    // ---- Models ----
+    if (p === '/api/models') {
+        const out = [];
+        for (const prov of (0, provider_1.listProviders)()) {
+            try {
+                const available = await prov.isAvailable();
+                const models = available ? await prov.listModels() : [];
+                out.push({ provider: prov.name, available, models });
+            }
+            catch (err) {
+                out.push({ provider: prov.name, available: false, models: [], error: String(err) });
+            }
+        }
+        return sendJson(res, 200, out);
+    }
+    // ---- Events ----
+    if (p === '/api/events') {
+        const project = u.searchParams.get('projectPath');
+        if (!project)
+            return sendJson(res, 400, { error: 'projectPath required' });
+        const resolved = resolveEventFile(project);
+        if (!resolved || !fs.existsSync(resolved))
+            return sendJson(res, 200, []);
+        const limit = Number(u.searchParams.get('limit') ?? 200);
+        try {
+            const lines = fs.readFileSync(resolved, 'utf8').split('\n').filter(Boolean).slice(-limit);
+            return sendJson(res, 200, lines
+                .map((l) => {
+                try {
+                    return JSON.parse(l);
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter(Boolean));
+        }
+        catch (err) {
+            logger_1.log.warn('events read failed', { err: String(err) });
+            return sendJson(res, 200, []);
+        }
+    }
+    // ---- Cost ----
+    if (p === '/api/cost') {
+        const projectId = u.searchParams.get('projectId') ?? undefined;
+        return sendJson(res, 200, { totals: (0, cost_1.totals)(projectId), recent: (0, cost_1.recent)(50) });
+    }
+    // ---- Learning ----
+    if (p === '/api/learning') {
+        const rows = (0, index_db_1.getDb)()
+            .prepare('SELECT pattern, context, fix, confidence, success_count, failure_count, updated_at FROM learning_patterns ORDER BY confidence DESC LIMIT 50')
+            .all();
+        return sendJson(res, 200, rows);
+    }
+    // ---- Memory ----
+    if (p === '/api/memory/index' && req.method === 'POST') {
+        try {
+            const body = await parseJson(req);
+            const projectPath = body.projectPath ?? (0, loader_1.findProjectRoot)() ?? process.cwd();
+            const stats = (0, cold_1.indexProject)(projectPath);
+            return sendJson(res, 200, { projectPath, ...stats });
+        }
+        catch (e) {
+            {
+                const { status, body } = (0, server_errors_1.errorBody)(e);
+                return sendJson(res, status, body);
+            }
+        }
+    }
+    if (p === '/api/memory/search') {
+        const query = u.searchParams.get('q');
+        const projectPath = u.searchParams.get('projectPath') ?? (0, loader_1.findProjectRoot)() ?? process.cwd();
+        if (!query)
+            return sendJson(res, 400, { error: 'q required' });
+        const results = (0, cold_1.search)(projectPath, query, 20);
+        return sendJson(res, 200, results);
+    }
+    // ---- Skills ----
+    if (p === '/api/skills' && req.method === 'GET') {
+        const root = (0, loader_1.findProjectRoot)() ?? undefined;
+        return sendJson(res, 200, (0, loader_2.loadSkills)(root));
+    }
+    if (p === '/api/skills/search') {
+        const q = u.searchParams.get('q') ?? '';
+        try {
+            return sendJson(res, 200, await (0, marketplace_1.searchRegistry)(q));
+        }
+        catch (e) {
+            return sendJson(res, 500, { error: String(e) });
+        }
+    }
+    if (p === '/api/skills/install' && req.method === 'POST') {
+        try {
+            const body = await parseJson(req);
+            const out = await (0, marketplace_1.installFromUrl)(body.name, body.url, { overwrite: true });
+            return sendJson(res, 200, out);
+        }
+        catch (e) {
+            {
+                const { status, body } = (0, server_errors_1.errorBody)(e);
+                return sendJson(res, status, body);
+            }
+        }
+    }
+    // ---- MCP ----
+    if (p === '/api/mcp' && req.method === 'GET') {
+        return sendJson(res, 200, (0, registry_1.listConnections)());
+    }
+    if (p === '/api/mcp' && req.method === 'POST') {
+        try {
+            const body = await parseJson(req);
+            (0, registry_1.addConnection)(body);
+            return sendJson(res, 201, { ok: true });
+        }
+        catch (e) {
+            {
+                const { status, body } = (0, server_errors_1.errorBody)(e);
+                return sendJson(res, status, body);
+            }
+        }
+    }
+    const mcpIdMatch = /^\/api\/mcp\/([^/]+)$/.exec(p);
+    if (mcpIdMatch && req.method === 'DELETE') {
+        (0, registry_1.removeConnection)(mcpIdMatch[1]);
+        return sendJson(res, 204, {});
+    }
+    // ---- Web ----
+    if (p === '/api/web/search') {
+        const query = u.searchParams.get('q');
+        if (!query)
+            return sendJson(res, 400, { error: 'q required' });
+        try {
+            const results = await (0, search_1.webSearch)({ query, limit: 10 });
+            return sendJson(res, 200, results);
+        }
+        catch (e) {
+            return sendJson(res, 500, { error: String(e) });
+        }
+    }
+    if (p === '/api/web/fetch' && req.method === 'POST') {
+        try {
+            const body = await parseJson(req);
+            if (!body.url)
+                return sendJson(res, 400, { error: 'url required' });
+            const result = await (0, fetch_1.webFetch)({ url: body.url, maxChars: 6_000 });
+            return sendJson(res, 200, result);
+        }
+        catch (e) {
+            {
+                const { status, body } = (0, server_errors_1.errorBody)(e);
+                return sendJson(res, status, body);
+            }
+        }
+    }
+    // ---- Doctor ----
+    if (p === '/api/doctor') {
+        const results = [];
+        const addCheck = (name, ok, detail) => results.push({ name, ok, detail });
+        addCheck('forge home', fs.existsSync(paths_1.paths.home), paths_1.paths.home);
+        try {
+            (0, index_db_1.getDb)().prepare('SELECT 1').get();
+            addCheck('sqlite index', true, paths_1.paths.globalIndex);
+        }
+        catch (e) {
+            addCheck('sqlite index', false, String(e));
+        }
+        try {
+            const cfg = (0, loader_1.loadGlobalConfig)();
+            addCheck('config valid', true, `provider=${cfg.provider} mode=${cfg.defaultMode}`);
+        }
+        catch (e) {
+            addCheck('config valid', false, String(e));
+        }
+        const prov = [];
+        for (const provObj of (0, provider_1.listProviders)()) {
+            prov.push(`${provObj.name}:${(await provObj.isAvailable().catch(() => false)) ? 'up' : 'down'}`);
+        }
+        addCheck('providers', prov.some((r) => r.endsWith(':up')), prov.join(' '));
+        return sendJson(res, 200, results);
+    }
+    // ---- Static ----
+    const staticPath = p === '/' ? '/index.html' : p;
+    const full = path.join(publicDir, staticPath);
+    const normalized = path.resolve(full);
+    if (!normalized.startsWith(path.resolve(publicDir))) {
+        res.writeHead(403);
+        res.end('forbidden');
+        return;
+    }
+    if (fs.existsSync(normalized) && fs.statSync(normalized).isFile()) {
+        sendStatic(res, normalized);
+        return;
+    }
+    sendStatic(res, path.join(publicDir, 'index.html'));
+};
+// ---------- helpers ----------
+const setNested = (obj, keyPath, value) => {
+    const parts = keyPath.split('.');
+    let cur = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        if (typeof cur[parts[i]] !== 'object' || cur[parts[i]] === null)
+            cur[parts[i]] = {};
+        cur = cur[parts[i]];
+    }
+    cur[parts[parts.length - 1]] = value;
+};
+// ---------- Event-file resolution ----------
+//
+// Events are written under ~/.forge/projects/<projectHash>/logs/events.jsonl
+// (see src/persistence/events.ts). The UI caller usually sends the absolute
+// project path, so we translate that to the stored location. We also support
+// the legacy `<projectPath>/.forge/logs/events.jsonl` layout, and the shared
+// per-project dir under `<projectPath>/logs/events.jsonl` only if it actually
+// exists — never assuming.
+const resolveEventFile = (projectPath) => {
+    const candidates = [
+        path.join((0, paths_1.projectSubdirs)(projectPath).logs, 'events.jsonl'),
+        path.join(projectPath, '.forge', 'logs', 'events.jsonl'),
+        path.join(projectPath, 'logs', 'events.jsonl'),
+    ];
+    for (const c of candidates) {
+        if (fs.existsSync(c))
+            return c;
+    }
+    return null;
+};
+// Resolve AND create the per-project events.jsonl so `fs.watch` never throws
+// ENOENT. Touching a zero-byte file is cheap and idempotent.
+const ensureEventFile = (projectPath) => {
+    const existing = resolveEventFile(projectPath);
+    if (existing)
+        return existing;
+    const sub = (0, paths_1.ensureProjectDir)(projectPath);
+    const target = path.join(sub.logs, 'events.jsonl');
+    if (!fs.existsSync(target))
+        fs.writeFileSync(target, '', 'utf8');
+    return target;
+};
+// ---------- Process-wide crash guards ----------
+//
+// The UI server is meant to stay up under imperfect conditions (files that
+// appear and vanish, peers that disconnect mid-send, provider network
+// hiccups). Without these, an unhandled rejection anywhere in the loop would
+// crash the whole dashboard.
+let guardsInstalled = false;
+let bridgeInstalled = false;
+const installProcessGuards = () => {
+    if (guardsInstalled)
+        return;
+    guardsInstalled = true;
+    process.on('uncaughtException', (err) => {
+        logger_1.log.error('uncaughtException (server kept alive)', {
+            err: String(err),
+            stack: err?.stack,
+        });
+    });
+    process.on('unhandledRejection', (reason) => {
+        logger_1.log.error('unhandledRejection (server kept alive)', { reason: String(reason) });
+    });
+};
+const startUiServer = (opts = {}) => {
+    const port = opts.port ?? Number(process.env.FORGE_UI_PORT ?? 7823);
+    const bind = opts.bind ?? '127.0.0.1';
+    const publicDir = opts.publicDir ?? path.join(__dirname, 'public');
+    installProcessGuards();
+    // Bridge task results back to chat sessions so turns get their summaries.
+    // Registered once per process — if `startUiServer` is called again (e.g.
+    // restart), subsequent calls skip this hook so we don't get duplicate
+    // writes per resolved task.
+    if (!bridgeInstalled) {
+        bridgeInstalled = true;
+        (0, task_runner_1.onTaskResolved)((r) => {
+            // chat.attachResultForTask is a no-op for tasks not associated with a
+            // chat turn — safe to call unconditionally.
+            (0, chat_1.attachResultForTask)(r.taskId, {
+                success: r.success,
+                summary: r.summary,
+                filesChanged: r.filesChanged,
+                durationMs: r.durationMs,
+                costUsd: r.costUsd,
+            }, r.status);
+        });
+    }
+    return new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+            router(req, res, publicDir).catch((err) => {
+                logger_1.log.error('ui route failed', { err: String(err) });
+                try {
+                    sendJson(res, 500, { error: String(err) });
+                }
+                catch {
+                    /* socket may be dead */
+                }
+            });
+        });
+        server.on('clientError', (err, socket) => {
+            logger_1.log.debug('http clientError', { err: String(err) });
+            try {
+                socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
+            }
+            catch {
+                /* ignore */
+            }
+        });
+        // WebSocket channels: project event stream AND task streams.
+        const wss = new ws_1.WebSocketServer({ server });
+        wss.on('error', (err) => logger_1.log.warn('ws server error', { err: String(err) }));
+        const watchers = new Map();
+        wss.on('connection', (socket, req) => {
+            const u = new url_1.URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+            const taskMatch = /^\/ws\/tasks\/([a-f0-9]+)$/.exec(u.pathname);
+            if (taskMatch) {
+                const ok = (0, task_runner_1.subscribe)(taskMatch[1], socket);
+                if (!ok) {
+                    socket.close(1008, 'unknown task');
+                    return;
+                }
+                return;
+            }
+            // Conversation live-sync channel. Browser tabs subscribe to hear about
+            // newly appended turns (from any writer — this tab, another tab, a CLI
+            // REPL on the same host, a task runner's result broadcast, etc.).
+            const convMatch = /^\/ws\/conversations\/((?:chat|repl|conv)-[a-z0-9_]+)$/.exec(u.pathname);
+            if (convMatch) {
+                const projectPath = u.searchParams.get('projectPath');
+                if (!projectPath) {
+                    socket.close(1008, 'projectPath required');
+                    return;
+                }
+                socket.on('error', (err) => logger_1.log.debug('ws conv socket error', { err: String(err) }));
+                const unsubscribe = (0, chat_1.subscribeConversation)(projectPath, convMatch[1], (update) => {
+                    if (socket.readyState !== socket.OPEN)
+                        return;
+                    try {
+                        socket.send(JSON.stringify({ kind: 'conversation.update', update }));
+                    }
+                    catch (err) {
+                        logger_1.log.debug('ws conv send failed', { err: String(err) });
+                    }
+                });
+                socket.on('close', () => unsubscribe());
+                return;
+            }
+            if (u.pathname !== '/ws') {
+                socket.close(1008, 'unknown channel');
+                return;
+            }
+            const projectPath = u.searchParams.get('projectPath');
+            if (!projectPath) {
+                socket.close(1008, 'projectPath required');
+                return;
+            }
+            // Always attach the socket-error handler first so a peer disconnect
+            // during send() can't bubble into an uncaught exception.
+            socket.on('error', (err) => logger_1.log.debug('ws socket error', { err: String(err) }));
+            let resolved;
+            try {
+                resolved = ensureEventFile(projectPath);
+            }
+            catch (err) {
+                logger_1.log.warn('ws: could not resolve events file', { projectPath, err: String(err) });
+                try {
+                    socket.close(1011, 'event-file-unavailable');
+                }
+                catch {
+                    /* ignore close error */
+                }
+                return;
+            }
+            let lastSize = 0;
+            try {
+                lastSize = fs.statSync(resolved).size;
+            }
+            catch {
+                /* created empty above; size is 0 */
+            }
+            let watcher = null;
+            try {
+                watcher = fs.watch(resolved, () => {
+                    try {
+                        const stat = fs.statSync(resolved);
+                        if (stat.size <= lastSize)
+                            return;
+                        const fd = fs.openSync(resolved, 'r');
+                        const buf = Buffer.alloc(stat.size - lastSize);
+                        fs.readSync(fd, buf, 0, buf.length, lastSize);
+                        fs.closeSync(fd);
+                        lastSize = stat.size;
+                        if (socket.readyState !== socket.OPEN)
+                            return;
+                        for (const line of buf.toString('utf8').split('\n').filter(Boolean)) {
+                            try {
+                                socket.send(line);
+                            }
+                            catch (err) {
+                                logger_1.log.debug('ws send failed', { err: String(err) });
+                            }
+                        }
+                    }
+                    catch (err) {
+                        logger_1.log.debug('ws watcher tick error', { err: String(err) });
+                    }
+                });
+                watcher.on('error', (err) => {
+                    logger_1.log.debug('ws watcher error event', { err: String(err) });
+                    try {
+                        watcher?.close();
+                    }
+                    catch {
+                        /* ignore close error */
+                    }
+                    watchers.delete(String(socket));
+                });
+            }
+            catch (err) {
+                // fs.watch itself can throw on some platforms (e.g. rapid file churn).
+                logger_1.log.warn('fs.watch failed', { resolved, err: String(err) });
+                try {
+                    socket.close(1011, 'watch-failed');
+                }
+                catch {
+                    /* ignore close error */
+                }
+                return;
+            }
+            watchers.set(String(socket), watcher);
+            socket.on('close', () => {
+                const w = watchers.get(String(socket));
+                if (w) {
+                    try {
+                        w.close();
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                    watchers.delete(String(socket));
+                }
+            });
+        });
+        server.listen(port, bind, () => {
+            logger_1.log.info('ui server listening', { url: `http://${bind}:${port}` });
+            resolve({
+                port,
+                async stop() {
+                    // Close task-event fs watchers (project event stream).
+                    for (const w of watchers.values()) {
+                        try {
+                            w.close();
+                        }
+                        catch {
+                            /* ignore */
+                        }
+                    }
+                    // Close every conversation watcher + drop broadcasters so the
+                    // process can exit without lingering handles.
+                    (0, chat_1.closeAllConversationWatchers)();
+                    wss.close();
+                    await new Promise((r) => server.close(() => r()));
+                },
+            });
+        });
+        server.on('error', reject);
+    });
+};
+exports.startUiServer = startUiServer;
+if (require.main === module) {
+    (0, exports.startUiServer)().catch((err) => {
+        logger_1.log.error('failed to start ui server', { err: String(err) });
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=server.js.map