@creativeintelligence/abbie 0.1.5 → 0.1.7

package/dist/lib/web/server.js

@@ -1,697 +0,0 @@
-/**
- * Web server for agents web UI.
- * Uses Hono for HTTP routing and Bun for WebSocket.
- */
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, sep as pathSep, resolve as resolvePath } from "node:path";
-import { Hono } from "hono";
-import { serveStatic } from "hono/bun";
-import { cors } from "hono/cors";
-import { getActiveSessionManager } from "../active-sessions.js";
-import { createAnalyticsRoutes, getAnalyticsMiddleware, initWebAnalytics } from "./analytics.js";
-import * as tmux from "./tmux-bridge.js";
-// Global state for WebSocket clients
-const clients = new Set();
-const terminalStreams = new Map();
-/**
- * Start streaming terminal output to a client.
- */
-async function startTerminalStream(client, window, pane, session) {
-    console.log("[terminal] startTerminalStream called", { window, pane, session });
-    // Stop existing stream if any
-    stopTerminalStream(client);
-    let lastContent = "";
-    const _lastLength = 0;
-    // Fast polling for real-time feel (50ms = 20fps)
-    const interval = setInterval(async () => {
-        try {
-            const content = await tmux.capturePane(window, pane, { lines: 500, session });
-            // Only send if content changed - always send full content since terminal
-            // output is not append-only (typing changes content in place)
-            if (content !== lastContent) {
-                client.ws.send(JSON.stringify({
-                    type: "terminal:content",
-                    data: { content, full: true },
-                    timestamp: Date.now(),
-                }));
-                lastContent = content;
-            }
-        }
-        catch {
-            // Pane might have closed
-        }
-    }, 50);
-    terminalStreams.set(client, { window, pane, session, interval, lastContent });
-    // Send initial content immediately
-    try {
-        console.log("[terminal] capturing initial content for", { window, pane });
-        const content = await tmux.capturePane(window, pane, { lines: 500, session });
-        console.log("[terminal] captured", content.length, "bytes, sending...");
-        client.ws.send(JSON.stringify({
-            type: "terminal:content",
-            data: { content, full: true },
-            timestamp: Date.now(),
-        }));
-        const stream = terminalStreams.get(client);
-        if (stream) {
-            stream.lastContent = content;
-        }
-    }
-    catch (err) {
-        console.error("[terminal] initial capture error:", err);
-    }
-}
-/**
- * Stop terminal streaming for a client.
- */
-function stopTerminalStream(client) {
-    const stream = terminalStreams.get(client);
-    if (stream) {
-        clearInterval(stream.interval);
-        terminalStreams.delete(client);
-    }
-}
-/**
- * Send input to terminal.
- */
-async function sendTerminalInput(client, keys) {
-    const stream = terminalStreams.get(client);
-    if (!stream) {
-        console.warn("[terminal:input] No stream found for client - input dropped");
-        return;
-    }
-    // Log what we're sending (escape special chars for visibility)
-    const escaped = keys
-        .replace(/\r/g, "\\r")
-        .replace(/\n/g, "\\n")
-        .replaceAll("\u007f", "\\x7f")
-        .replaceAll("\u001b", "\\e");
-    console.log("[terminal:input]", {
-        window: stream.window,
-        pane: stream.pane,
-        keys: escaped,
-        raw: keys,
-    });
-    try {
-        // Don't use literal mode - we need tmux to interpret control sequences
-        // xterm sends \r for Enter, \x7f for backspace, escape sequences for arrows
-        await tmux.sendKeys(stream.window, stream.pane, keys, {
-            session: stream.session,
-            literal: false,
-        });
-    }
-    catch (err) {
-        console.error("[terminal:input] tmux.sendKeys error:", err);
-    }
-}
-/**
- * Broadcast a message to all subscribed clients.
- */
-function broadcast(channel, data) {
-    const message = JSON.stringify({ type: channel, data, timestamp: Date.now() });
-    for (const client of clients) {
-        if (client.subscriptions.has(channel) || client.subscriptions.has("*")) {
-            try {
-                client.ws.send(message);
-            }
-            catch {
-                // Client disconnected
-                clients.delete(client);
-            }
-        }
-    }
-}
-/**
- * Create the Hono app with all routes.
- */
-function createApp(options) {
-    const app = new Hono();
-    // CORS for local development
-    app.use("*", cors({
-        origin: ["http://localhost:5173", "http://localhost:3847", "http://127.0.0.1:5173"],
-        credentials: true,
-    }));
-    // Analytics middleware (tracks API calls to PostHog)
-    app.use("/api/*", getAnalyticsMiddleware());
-    // Analytics API routes
-    const analyticsRoutes = createAnalyticsRoutes(Hono);
-    if (analyticsRoutes) {
-        app.route("/api/analytics", analyticsRoutes);
-    }
-    // Health check
-    app.get("/api/health", (c) => c.json({ ok: true, timestamp: Date.now() }));
-    // ============ SESSIONS API ============
-    app.get("/api/sessions", (c) => {
-        const manager = getActiveSessionManager();
-        const status = c.req.query("status");
-        const project = c.req.query("project");
-        const limit = parseInt(c.req.query("limit") || "50", 10);
-        let sessions = manager.list({ status, project });
-        sessions = sessions.slice(0, limit);
-        return c.json({ sessions, total: sessions.length });
-    });
-    app.get("/api/sessions/:id", (c) => {
-        const id = c.req.param("id");
-        const manager = getActiveSessionManager();
-        const session = manager.get(id);
-        if (!session) {
-            return c.json({ error: "Session not found" }, 404);
-        }
-        return c.json({ session });
-    });
-    app.post("/api/sessions/:id/stop", async (c) => {
-        const id = c.req.param("id");
-        const body = await c.req.json().catch(() => ({}));
-        const signal = body.force === true ? "SIGKILL" : "SIGTERM";
-        const manager = getActiveSessionManager();
-        const stopped = manager.stop(id, signal);
-        if (!stopped) {
-            return c.json({ error: "Failed to stop session" }, 500);
-        }
-        broadcast("sessions", { action: "stopped", session_id: id });
-        return c.json({ success: true, session_id: id });
-    });
-    // ============ EVENTS API ============
-    app.get("/api/events", (c) => {
-        const eventsDir = join(homedir(), ".agents", "events");
-        const limit = parseInt(c.req.query("limit") || "100", 10);
-        if (!existsSync(eventsDir)) {
-            return c.json({ events: [] });
-        }
-        const files = readdirSync(eventsDir)
-            .filter((f) => f.endsWith(".json"))
-            .sort()
-            .reverse()
-            .slice(0, limit);
-        const events = files
-            .map((f) => {
-            try {
-                const content = readFileSync(join(eventsDir, f), "utf-8");
-                return JSON.parse(content);
-            }
-            catch {
-                return null;
-            }
-        })
-            .filter(Boolean);
-        return c.json({ events });
-    });
-    // ============ TMUX API ============
-    app.get("/api/tmux/status", async (c) => {
-        const running = await tmux.isRunning();
-        return c.json({ running });
-    });
-    app.get("/api/tmux/sessions", async (c) => {
-        const sessions = await tmux.listSessions();
-        return c.json({ sessions });
-    });
-    app.get("/api/tmux/windows", async (c) => {
-        const session = c.req.query("session");
-        const windows = await tmux.listWindows(session);
-        return c.json({ windows });
-    });
-    app.get("/api/tmux/windows/:window/panes", async (c) => {
-        const window = c.req.param("window");
-        const session = c.req.query("session");
-        const panes = await tmux.listPanes(window, session);
-        return c.json({ panes });
-    });
-    app.get("/api/tmux/capture/:window", async (c) => {
-        const window = c.req.param("window");
-        const pane = parseInt(c.req.query("pane") || "0", 10);
-        const lines = parseInt(c.req.query("lines") || "100", 10);
-        const session = c.req.query("session");
-        const content = await tmux.capturePane(window, pane, { lines, session });
-        return c.json({ content, window, pane });
-    });
-    app.post("/api/tmux/send/:window", async (c) => {
-        const window = c.req.param("window");
-        const body = await c.req.json();
-        const { pane = 0, keys, literal = false, session } = body;
-        if (!keys) {
-            return c.json({ error: "keys required" }, 400);
-        }
-        await tmux.sendKeys(window, pane, keys, { session, literal });
-        return c.json({ success: true });
-    });
-    app.post("/api/tmux/select/:window", async (c) => {
-        const window = c.req.param("window");
-        const body = await c.req.json().catch(() => ({}));
-        const { pane, session } = body;
-        await tmux.selectWindow(window, session);
-        if (pane !== undefined) {
-            await tmux.selectPane(window, pane, session);
-        }
-        return c.json({ success: true });
-    });
-    app.post("/api/tmux/new-window", async (c) => {
-        const body = await c.req.json();
-        const { name, cwd, session, command } = body;
-        await tmux.newWindow({ name, cwd, session, command });
-        broadcast("tmux", { action: "window-created", name });
-        return c.json({ success: true });
-    });
-    app.post("/api/tmux/windows/reorder", async (c) => {
-        const body = await c.req.json().catch(() => ({}));
-        const session = body.session;
-        const order = Array.isArray(body.order) ? body.order : null;
-        if (order && order.length > 0) {
-            const windows = await tmux.listWindows(session);
-            const currentIds = new Set(windows.map((w) => w.id));
-            const indices = [...windows.map((w) => w.index)].sort((a, b) => a - b);
-            const idToIndex = new Map();
-            const indexToId = new Map();
-            for (const w of windows) {
-                idToIndex.set(w.id, w.index);
-                indexToId.set(w.index, w.id);
-            }
-            // Keep only windows that exist in this session, and append any missing ones in current tmux order.
-            const desired = order.filter((id) => currentIds.has(id));
-            for (const w of windows) {
-                if (!desired.includes(w.id))
-                    desired.push(w.id);
-            }
-            for (let i = 0; i < desired.length; i++) {
-                const targetIndex = indices[i];
-                const desiredId = desired[i];
-                const currentIndex = idToIndex.get(desiredId);
-                if (currentIndex === undefined)
-                    continue;
-                if (currentIndex === targetIndex)
-                    continue;
-                const displacedId = indexToId.get(targetIndex);
-                await tmux.swapWindows(currentIndex, targetIndex, session);
-                idToIndex.set(desiredId, targetIndex);
-                indexToId.set(targetIndex, desiredId);
-                if (displacedId !== undefined) {
-                    idToIndex.set(displacedId, currentIndex);
-                    indexToId.set(currentIndex, displacedId);
-                }
-            }
-            return c.json({ success: true });
-        }
-        const windows = await tmux.listWindows(session);
-        const sourceId = body.sourceId;
-        const targetId = body.targetId;
-        if (!sourceId || !targetId) {
-            return c.json({ error: "order[] or sourceId+targetId required" }, 400);
-        }
-        const source = windows.find((w) => w.id === sourceId);
-        const target = windows.find((w) => w.id === targetId);
-        if (!source || !target) {
-            return c.json({ error: "Window not found" }, 404);
-        }
-        await tmux.swapWindows(source.index, target.index, session);
-        return c.json({ success: true });
-    });
-    // ============ PROMPTS API ============
-    app.get("/api/prompts", (c) => {
-        const promptsDir = join(homedir(), ".agents", "prompts");
-        const limit = parseInt(c.req.query("limit") || "50", 10);
-        if (!existsSync(promptsDir)) {
-            return c.json({ prompts: [] });
-        }
-        const files = readdirSync(promptsDir)
-            .filter((f) => f.endsWith(".md"))
-            .map((f) => {
-            const path = join(promptsDir, f);
-            const stats = statSync(path);
-            return {
-                name: f,
-                path,
-                size: stats.size,
-                modified: stats.mtime.toISOString(),
-            };
-        })
-            .sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime())
-            .slice(0, limit);
-        return c.json({ prompts: files });
-    });
-    app.get("/api/prompts/:name", (c) => {
-        const name = c.req.param("name");
-        const promptsDir = join(homedir(), ".agents", "prompts");
-        const path = join(promptsDir, name);
-        if (!existsSync(path)) {
-            return c.json({ error: "Prompt not found" }, 404);
-        }
-        const content = readFileSync(path, "utf-8");
-        return c.json({ name, content });
-    });
-    // ============ PROJECTS API ============
-    app.get("/api/projects", (c) => {
-        const projectsPath = join(homedir(), ".agents", "projects.json");
-        if (!existsSync(projectsPath)) {
-            return c.json({ projects: {}, defaultEmoji: "📁" });
-        }
-        try {
-            const content = readFileSync(projectsPath, "utf-8");
-            const data = JSON.parse(content);
-            return c.json(data);
-        }
-        catch {
-            return c.json({ projects: {}, defaultEmoji: "📁" });
-        }
-    });
-    // ============ PROJECT FILES API ============
-    async function getProjectRoot(project) {
-        const panes = await tmux.listPanes(project);
-        const root = panes.find((p) => p.active)?.currentPath ?? panes[0]?.currentPath ?? null;
-        return root ? resolvePath(root) : null;
-    }
-    function resolveWithinRoot(root, relativePath) {
-        const normalizedRoot = resolvePath(root);
-        const target = resolvePath(normalizedRoot, relativePath || ".");
-        const inRoot = target === normalizedRoot || target.startsWith(normalizedRoot + pathSep);
-        return inRoot ? target : null;
-    }
-    app.get("/api/projects/:project/root", async (c) => {
-        const project = c.req.param("project");
-        try {
-            const root = await getProjectRoot(project);
-            return c.json({ project, root });
-        }
-        catch {
-            return c.json({ project, root: null });
-        }
-    });
-    app.get("/api/projects/:project/fs", async (c) => {
-        const project = c.req.param("project");
-        const rel = c.req.query("path") || ".";
-        const root = await getProjectRoot(project);
-        if (!root) {
-            return c.json({ error: "Project root not found" }, 404);
-        }
-        const absolute = resolveWithinRoot(root, rel);
-        if (!absolute) {
-            return c.json({ error: "Path outside project root" }, 400);
-        }
-        if (!existsSync(absolute)) {
-            return c.json({ error: "Path not found" }, 404);
-        }
-        const stats = statSync(absolute);
-        if (!stats.isDirectory()) {
-            return c.json({ error: "Path is not a directory" }, 400);
-        }
-        const entries = readdirSync(absolute, { withFileTypes: true }).map((d) => {
-            const entryPath = join(absolute, d.name);
-            let entryStats = null;
-            try {
-                entryStats = statSync(entryPath);
-            }
-            catch {
-                // ignore
-            }
-            return {
-                name: d.name,
-                type: d.isDirectory() ? "dir" : d.isSymbolicLink() ? "symlink" : "file",
-                size: entryStats?.isFile() ? entryStats.size : null,
-                modified: entryStats ? entryStats.mtime.toISOString() : null,
-            };
-        });
-        // Directories first, then alpha
-        entries.sort((a, b) => {
-            if (a.type === b.type)
-                return a.name.localeCompare(b.name);
-            if (a.type === "dir")
-                return -1;
-            if (b.type === "dir")
-                return 1;
-            return a.type.localeCompare(b.type);
-        });
-        return c.json({ project, root, path: rel, entries });
-    });
-    app.get("/api/projects/:project/file", async (c) => {
-        const project = c.req.param("project");
-        const rel = c.req.query("path");
-        if (!rel)
-            return c.json({ error: "path required" }, 400);
-        const root = await getProjectRoot(project);
-        if (!root) {
-            return c.json({ error: "Project root not found" }, 404);
-        }
-        const absolute = resolveWithinRoot(root, rel);
-        if (!absolute) {
-            return c.json({ error: "Path outside project root" }, 400);
-        }
-        if (!existsSync(absolute)) {
-            return c.json({ error: "File not found" }, 404);
-        }
-        const stats = statSync(absolute);
-        if (!stats.isFile()) {
-            return c.json({ error: "Path is not a file" }, 400);
-        }
-        // Avoid sending huge files to the browser
-        const MAX_BYTES = 500_000;
-        if (stats.size > MAX_BYTES) {
-            return c.json({ error: "File too large" }, 413);
-        }
-        const content = readFileSync(absolute, "utf-8");
-        return c.json({ project, root, path: rel, content });
-    });
-    // ============ PLANS API ============
-    app.get("/api/projects/:project/plans", (c) => {
-        const project = c.req.param("project");
-        const plansRoot = join(homedir(), ".agents", "plans", project);
-        if (!existsSync(plansRoot)) {
-            return c.json({ project, plans: [] });
-        }
-        const plans = readdirSync(plansRoot, { withFileTypes: true })
-            .filter((d) => d.isDirectory())
-            .map((d) => {
-            const slug = d.name;
-            const planPath = join(plansRoot, slug, "plan.md");
-            const hasPlan = existsSync(planPath);
-            let title = slug;
-            let modified = null;
-            if (hasPlan) {
-                try {
-                    const content = readFileSync(planPath, "utf-8");
-                    const firstLine = content.split("\n")[0] ?? "";
-                    title = firstLine.replace(/^#\s*/, "").trim() || slug;
-                    modified = statSync(planPath).mtime.toISOString();
-                }
-                catch {
-                    // ignore
-                }
-            }
-            return {
-                slug,
-                title,
-                hasPlan,
-                modified,
-            };
-        })
-            .sort((a, b) => (b.modified ?? "").localeCompare(a.modified ?? ""));
-        return c.json({ project, plans });
-    });
-    app.get("/api/projects/:project/plans/:slug", (c) => {
-        const project = c.req.param("project");
-        const slug = c.req.param("slug");
-        const planPath = join(homedir(), ".agents", "plans", project, slug, "plan.md");
-        if (!existsSync(planPath)) {
-            return c.json({ error: "Plan not found" }, 404);
-        }
-        const content = readFileSync(planPath, "utf-8");
-        return c.json({ project, slug, content });
-    });
-    // ============ STATE API ============
-    app.get("/api/state", async (c) => {
-        const manager = getActiveSessionManager();
-        const sessions = manager.list();
-        const tmuxRunning = await tmux.isRunning();
-        const tmuxWindows = tmuxRunning ? await tmux.listWindows() : [];
-        return c.json({
-            sessions: {
-                total: sessions.length,
-                running: sessions.filter((s) => s.status === "running").length,
-                items: sessions,
-            },
-            tmux: {
-                running: tmuxRunning,
-                windows: tmuxWindows,
-            },
-            timestamp: Date.now(),
-        });
-    });
-    // ============ STATIC FILES ============
-    if (options.staticDir && existsSync(options.staticDir)) {
-        app.use("/*", serveStatic({ root: options.staticDir }));
-    }
-    // Fallback for SPA routing
-    app.get("*", (c) => {
-        if (options.staticDir) {
-            const indexPath = join(options.staticDir, "index.html");
-            if (existsSync(indexPath)) {
-                const html = readFileSync(indexPath, "utf-8");
-                return c.html(html);
-            }
-        }
-        return c.json({ error: "Not found" }, 404);
-    });
-    return app;
-}
-/**
- * Create and start the web server.
- */
-export async function createServer(options) {
-    // Initialize web analytics (non-blocking, no-op if unavailable)
-    await initWebAnalytics();
-    const app = createApp(options);
-    const server = Bun.serve({
-        port: options.port,
-        hostname: options.host,
-        fetch(req, server) {
-            const url = new URL(req.url);
-            // Handle WebSocket upgrade
-            if (url.pathname === "/ws") {
-                const upgraded = server.upgrade(req);
-                if (upgraded) {
-                    return undefined;
-                }
-                return new Response("WebSocket upgrade failed", { status: 400 });
-            }
-            // Handle regular HTTP requests with Hono
-            return app.fetch(req);
-        },
-        websocket: {
-            open(ws) {
-                const client = { ws, subscriptions: new Set(["*"]) };
-                clients.add(client);
-                ws.send(JSON.stringify({ type: "connected", timestamp: Date.now() }));
-            },
-            message(ws, message) {
-                const client = Array.from(clients).find((c) => c.ws === ws);
-                if (!client)
-                    return;
-                try {
-                    const data = JSON.parse(message.toString());
-                    if (data.type === "subscribe") {
-                        client.subscriptions.add(data.channel);
-                        ws.send(JSON.stringify({ type: "subscribed", channel: data.channel }));
-                    }
-                    else if (data.type === "unsubscribe") {
-                        client.subscriptions.delete(data.channel);
-                        ws.send(JSON.stringify({ type: "unsubscribed", channel: data.channel }));
-                    }
-                    else if (data.type === "ping") {
-                        ws.send(JSON.stringify({ type: "pong", timestamp: Date.now() }));
-                    }
-                    else if (data.type === "terminal:subscribe") {
-                        // Start streaming terminal output
-                        const { window, pane = 0, session } = data;
-                        console.log("[ws] terminal:subscribe received", { window, pane, session });
-                        startTerminalStream(client, window, pane, session);
-                        // Get current pane dimensions so client can sync
-                        tmux
-                            .getPaneDimensions(window, pane, session)
-                            .then((dims) => {
-                            console.log("[ws] sending terminal:subscribed with dims:", dims);
-                            ws.send(JSON.stringify({ type: "terminal:subscribed", window, pane, dims }));
-                        })
-                            .catch(() => {
-                            console.log("[ws] sending terminal:subscribed (no dims)");
-                            ws.send(JSON.stringify({ type: "terminal:subscribed", window, pane }));
-                        });
-                    }
-                    else if (data.type === "terminal:unsubscribe") {
-                        stopTerminalStream(client);
-                        ws.send(JSON.stringify({ type: "terminal:unsubscribed" }));
-                    }
-                    else if (data.type === "terminal:input") {
-                        // Send input to terminal
-                        console.log("[ws] terminal:input received, keys length:", data.keys?.length);
-                        sendTerminalInput(client, data.keys);
-                    }
-                    else if (data.type === "terminal:resize") {
-                        // Resize the tmux pane to match xterm dimensions
-                        const stream = terminalStreams.get(client);
-                        if (stream && data.cols && data.rows) {
-                            tmux
-                                .resizePane(stream.window, stream.pane, data.cols, data.rows, stream.session)
-                                .then(async () => {
-                                console.log("[terminal:resize]", {
-                                    window: stream.window,
-                                    pane: stream.pane,
-                                    cols: data.cols,
-                                    rows: data.rows,
-                                });
-                                // After resize, wait briefly for tmux to redraw then force a fresh capture
-                                // This ensures content is formatted for the new dimensions
-                                await new Promise((resolve) => setTimeout(resolve, 50));
-                                try {
-                                    const content = await tmux.capturePane(stream.window, stream.pane, {
-                                        lines: 500,
-                                        session: stream.session,
-                                    });
-                                    stream.lastContent = content;
-                                    ws.send(JSON.stringify({
-                                        type: "terminal:content",
-                                        data: { content, full: true },
-                                        timestamp: Date.now(),
-                                    }));
-                                }
-                                catch (captureErr) {
-                                    console.error("[terminal:resize] post-resize capture error:", captureErr);
-                                }
-                            })
-                                .catch((err) => {
-                                console.error("[terminal:resize] error:", err);
-                            });
-                        }
-                        ws.send(JSON.stringify({ type: "terminal:resized", cols: data.cols, rows: data.rows }));
-                    }
-                }
-                catch (err) {
-                    console.error("[ws] message handler error:", err);
-                }
-            },
-            close(ws) {
-                const client = Array.from(clients).find((c) => c.ws === ws);
-                if (client) {
-                    stopTerminalStream(client);
-                    clients.delete(client);
-                }
-            },
-        },
-    });
-    // Start session watcher for real-time updates
-    startSessionWatcher();
-    return server;
-}
-/**
- * Watch for session changes and broadcast updates.
- */
-function startSessionWatcher() {
-    const manager = getActiveSessionManager();
-    let lastSessions = new Map();
-    // Initialize
-    for (const session of manager.list()) {
-        lastSessions.set(session.session_id, session);
-    }
-    // Poll every 2 seconds
-    setInterval(() => {
-        const currentSessions = manager.list();
-        const currentMap = new Map();
-        for (const session of currentSessions) {
-            currentMap.set(session.session_id, session);
-            const prev = lastSessions.get(session.session_id);
-            if (!prev) {
-                // New session
-                broadcast("sessions", { action: "created", session });
-            }
-            else if (prev.status !== session.status) {
-                // Status changed
-                broadcast("sessions", { action: "updated", session });
-            }
-        }
-        // Check for removed sessions
-        for (const [id] of lastSessions) {
-            if (!currentMap.has(id)) {
-                broadcast("sessions", { action: "removed", session_id: id });
-            }
-        }
-        lastSessions = currentMap;
-    }, 2000);
-}
-export { broadcast };