leedab 0.2.5 → 0.3.0

package/dist/dashboard/routes.js

@@ -1,777 +0,0 @@
-import { execFile, spawn } from "node:child_process";
-import { readFile, writeFile, mkdir, readdir, stat } from "node:fs/promises";
-import { resolve } from "node:path";
-import { promisify } from "node:util";
-import { userInfo } from "node:os";
-import { resolveOpenClawBin, openclawEnv } from "../openclaw.js";
-import { addEntry, removeEntry, listEntries } from "../vault.js";
-import { readAuditLog, logAudit } from "../audit.js";
-import { getAnalytics } from "../analytics.js";
-import { loadTeam, addMember, removeMember, updateRole, } from "../team.js";
-import { loadLicense } from "../license.js";
-import { setMemberPermissions, } from "../team/permissions.js";
-import { syncAllowlists } from "../team/syncAllowlists.js";
-import { resolveMember } from "../agent/resolveMember.js";
-import { WORKFLOWS, getWorkflow } from "../workflows/registry.js";
-import { STATE_DIR } from "../paths.js";
-const execFileAsync = promisify(execFile);
-async function restartGatewayQuietly(stateDir) {
-    try {
-        const bin = resolveOpenClawBin();
-        const env = openclawEnv(stateDir);
-        await execFileAsync(bin, ["gateway", "health"], { env, timeout: 3000 });
-        await execFileAsync(bin, ["gateway", "restart"], { env, timeout: 10000 });
-    }
-    catch {
-        // Gateway not running, no restart needed
-    }
-}
-export function createRoutes(config) {
-    const bin = resolveOpenClawBin();
-    const stateDir = STATE_DIR;
-    return {
-        /**
-         * POST /api/chat — send a message to the agent, get a response
-         */
-        "POST /api/chat": async (req, res) => {
-            const body = await readBody(req);
-            const { message, session } = JSON.parse(body);
-            if (!message) {
-                json(res, { error: "message is required" }, 400);
-                return;
-            }
-            // Permission enforcement lives in the prompt preamble. The dashboard
-            // chat runs as the local admin / install owner, so the preamble here
-            // is informational ("assisting <admin>"). The same builder is the
-            // single gate used by channel handlers when we wire them up.
-            const preamble = await buildPermissionPreamble("dashboard", userInfo().username);
-            const agentMessage = preamble ? `${preamble}\n\n${message}` : message;
-            try {
-                const args = [
-                    "agent",
-                    "--message", agentMessage,
-                    "--session-id", session ?? "console",
-                    "--json",
-                ];
-                const { stdout, stderr } = await execFileAsync(bin, args, {
-                    env: openclawEnv(stateDir),
-                    timeout: 120000,
-                });
-                try {
-                    const result = JSON.parse(stdout);
-                    // Extract text from various response shapes
-                    const reply = result.result?.payloads?.[0]?.text ??
-                        result.reply ??
-                        result.text ??
-                        result.content ??
-                        stdout.trim();
-                    const thoughts = await readLatestThoughts(stateDir, session ?? "console");
-                    json(res, { reply, thoughts, session: session ?? "console" });
-                }
-                catch {
-                    json(res, {
-                        reply: stdout.trim() || stderr.trim() || "No response",
-                        session: session ?? "console",
-                    });
-                }
-            }
-            catch (err) {
-                json(res, { error: err.message }, 500);
-            }
-        },
-        /**
-         * GET /api/chat/history — get conversation history from JSONL logs
-         */
-        "GET /api/chat/history": async (_req, res, url) => {
-            const session = url.searchParams.get("session") ?? "console";
-            try {
-                const sessionsDir = resolve(stateDir, "agents", "main", "sessions");
-                const jsonlPath = resolve(sessionsDir, `${session}.jsonl`);
-                const raw = await readFile(jsonlPath, "utf-8");
-                const messages = [];
-                let pendingThoughts = [];
-                for (const line of raw.split("\n")) {
-                    if (!line.trim())
-                        continue;
-                    try {
-                        const entry = JSON.parse(line);
-                        if (entry.type !== "message")
-                            continue;
-                        const msg = entry.message;
-                        if (!msg || (msg.role !== "user" && msg.role !== "assistant"))
-                            continue;
-                        let text = "";
-                        const theseThoughts = [];
-                        if (Array.isArray(msg.content)) {
-                            for (const b of msg.content) {
-                                if (b?.type === "text" && typeof b.text === "string") {
-                                    text += (text ? "\n" : "") + b.text;
-                                }
-                                else if (b?.type === "thinking" && typeof b.thinking === "string") {
-                                    theseThoughts.push(b.thinking);
-                                }
-                            }
-                        }
-                        else if (typeof msg.content === "string") {
-                            text = msg.content;
-                        }
-                        // Strip all OpenClaw "(untrusted metadata)" blocks and timestamp prefix
-                        text = text.replace(/^(\w[\w\s]*\(untrusted metadata\):\n```json\n[\s\S]*?\n```\n\n)+/, "");
-                        text = text.replace(/^\[[\w]{3} \d{4}-\d{2}-\d{2} \d{2}:\d{2} \w+\] /, "");
-                        if (msg.role === "assistant") {
-                            // Accumulate thoughts across tool-use turns until we see text
-                            pendingThoughts.push(...theseThoughts);
-                            if (text) {
-                                messages.push({
-                                    role: msg.role,
-                                    text,
-                                    thoughts: pendingThoughts.length ? pendingThoughts : undefined,
-                                    timestamp: entry.timestamp,
-                                });
-                                pendingThoughts = [];
-                            }
-                        }
-                        else if (text) {
-                            messages.push({ role: msg.role, text, timestamp: entry.timestamp });
-                            pendingThoughts = [];
-                        }
-                    }
-                    catch { }
-                }
-                json(res, messages);
-            }
-            catch {
-                json(res, []);
-            }
-        },
-        /**
-         * GET /api/whoami — current OS user's first name + configured agent name
-         */
-        "GET /api/whoami": async (_req, res) => {
-            let firstName = userInfo().username;
-            try {
-                const { stdout } = await execFileAsync("id", ["-F"], { timeout: 2000 });
-                const fullName = stdout.trim();
-                if (fullName)
-                    firstName = fullName.split(/\s+/)[0];
-            }
-            catch { }
-            json(res, { name: firstName, agent: config.agent?.name ?? "LeedAB" });
-        },
-        /**
-         * GET /api/status — channel health status
-         */
-        "GET /api/status": async (_req, res) => {
-            let secrets = {};
-            try {
-                const raw = await readFile(resolve(stateDir, "secrets.json"), "utf-8");
-                secrets = JSON.parse(raw);
-            }
-            catch { }
-            const status = {
-                whatsapp: {
-                    connected: !!secrets.whatsapp?.connected || !!secrets.whatsapp?.accessToken,
-                    label: "WhatsApp",
-                },
-                telegram: {
-                    connected: !!secrets.telegram?.token,
-                    label: "Telegram",
-                },
-                teams: {
-                    connected: !!secrets.teams?.appSecret,
-                    label: "Microsoft Teams",
-                },
-            };
-            json(res, status);
-        },
-        /**
-         * POST /api/whatsapp/connect — register channel and start QR pairing
-         */
-        "POST /api/whatsapp/connect": async (_req, res) => {
-            try {
-                // Register channel if not already added
-                await execFileAsync(bin, ["channels", "add", "--channel", "whatsapp"], {
-                    env: openclawEnv(stateDir),
-                }).catch(() => { });
-                // Spawn login and capture output (including QR)
-                const login = spawn(bin, ["channels", "login", "--channel", "whatsapp"], {
-                    env: {
-                        ...openclawEnv(stateDir),
-                        NO_COLOR: "1",
-                    },
-                });
-                let output = "";
-                const qrReady = new Promise((resolve, reject) => {
-                    const timeout = setTimeout(() => {
-                        resolve(output);
-                    }, 10000);
-                    const onData = (chunk) => {
-                        output += chunk.toString();
-                        if (output.includes("▄▄██")) {
-                            clearTimeout(timeout);
-                            resolve(output);
-                        }
-                    };
-                    login.stdout?.on("data", onData);
-                    login.stderr?.on("data", onData);
-                    login.on("error", reject);
-                });
-                const qrOutput = await qrReady;
-                // Mark connected when login completes
-                login.on("close", async (code) => {
-                    if (code === 0) {
-                        await mkdir(stateDir, { recursive: true });
-                        let secrets = {};
-                        try {
-                            const raw = await readFile(resolve(stateDir, "secrets.json"), "utf-8");
-                            secrets = JSON.parse(raw);
-                        }
-                        catch { }
-                        secrets.whatsapp = { connected: true };
-                        await writeFile(resolve(stateDir, "secrets.json"), JSON.stringify(secrets, null, 2) + "\n");
-                    }
-                });
-                json(res, { status: "pairing", qr: qrOutput });
-            }
-            catch (err) {
-                json(res, { error: err.message }, 500);
-            }
-        },
-        /**
-         * GET /api/sessions — list all conversation sessions
-         */
-        "GET /api/sessions": async (_req, res) => {
-            try {
-                const sessionsDir = resolve(stateDir, "agents", "main", "sessions");
-                // Get indexed sessions from openclaw, keyed by sessionId
-                const indexed = new Map();
-                try {
-                    const { stdout } = await execFileAsync(bin, ["sessions", "--json"], { env: openclawEnv(stateDir), timeout: 10000 });
-                    const parsed = JSON.parse(stdout);
-                    for (const s of parsed.sessions ?? (Array.isArray(parsed) ? parsed : [])) {
-                        if (s.sessionId)
-                            indexed.set(s.sessionId, s);
-                    }
-                }
-                catch { }
-                // Walk JSONL files on disk — this is the source of truth
-                const results = [];
-                const files = await readdir(sessionsDir);
-                for (const f of files) {
-                    if (!f.endsWith(".jsonl"))
-                        continue;
-                    const name = f.replace(/\.jsonl$/, "");
-                    const entry = indexed.get(name);
-                    if (entry) {
-                        results.push(entry);
-                    }
-                    else {
-                        // Unindexed file (e.g. console.jsonl) — build minimal metadata
-                        try {
-                            const fstat = await stat(resolve(sessionsDir, f));
-                            results.push({
-                                key: `agent:main:${name}`,
-                                sessionId: name,
-                                updatedAt: fstat.mtimeMs,
-                                chatType: "direct",
-                            });
-                        }
-                        catch { }
-                    }
-                }
-                // Enrich each session with sender name and first message summary
-                await Promise.all(results.map(async (s) => {
-                    try {
-                        const filePath = resolve(sessionsDir, `${s.sessionId}.jsonl`);
-                        const raw = await readFile(filePath, "utf-8");
-                        const firstMsg = raw.split("\n").find((line) => {
-                            if (!line.trim())
-                                return false;
-                            try {
-                                const obj = JSON.parse(line);
-                                return obj.type === "message" && obj.message?.role === "user";
-                            }
-                            catch {
-                                return false;
-                            }
-                        });
-                        if (!firstMsg)
-                            return;
-                        const parsed = JSON.parse(firstMsg);
-                        const text = parsed.message?.content?.[0]?.text ?? "";
-                        // Extract sender + clean summary using openclaw's metadata format.
-                        // Metadata blocks are sentinel lines followed by ```json ... ```
-                        const { senderName, cleanText } = parseSessionFirstMessage(text);
-                        if (senderName)
-                            s.senderName = senderName;
-                        if (cleanText)
-                            s.summary = cleanText.slice(0, 120);
-                    }
-                    catch { }
-                }));
-                // Sort newest first
-                results.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
-                json(res, results);
-            }
-            catch {
-                json(res, []);
-            }
-        },
-        /**
-         * GET /api/audit — recent audit log entries
-         */
-        "GET /api/audit": async (_req, res, url) => {
-            const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
-            const channel = url.searchParams.get("channel") ?? undefined;
-            const sinceParam = url.searchParams.get("since");
-            const since = sinceParam ? new Date(sinceParam) : undefined;
-            const entries = await readAuditLog({ limit, channel, since });
-            json(res, entries);
-        },
-        /**
-         * GET /api/analytics — usage analytics summary
-         */
-        "GET /api/analytics": async (_req, res, url) => {
-            const days = parseInt(url.searchParams.get("days") ?? "30", 10);
-            const summary = await getAnalytics(days);
-            json(res, summary);
-        },
-        /**
-         * GET /api/vault — list stored credentials (no passwords)
-         */
-        "GET /api/vault": async (_req, res) => {
-            const entries = await listEntries();
-            json(res, entries);
-        },
-        /**
-         * POST /api/vault — add a credential to the vault
-         */
-        "POST /api/vault": async (req, res) => {
-            const body = await readBody(req);
-            const { service, url, username, password, notes } = JSON.parse(body);
-            if (!service || typeof service !== "string") {
-                json(res, { error: "service name is required" }, 400);
-                return;
-            }
-            await addEntry(service.trim(), {
-                url: url || undefined,
-                username: username || undefined,
-                password: password || undefined,
-                notes: notes || undefined,
-            });
-            json(res, { ok: true, service: service.trim() });
-        },
-        /**
-         * POST /api/telegram/connect — validate token and save
-         */
-        "POST /api/telegram/connect": async (req, res) => {
-            const body = await readBody(req);
-            const { token } = JSON.parse(body);
-            if (!token || typeof token !== "string") {
-                json(res, { error: "token is required" }, 400);
-                return;
-            }
-            // Validate token via Telegram API
-            try {
-                const tgRes = await fetch(`https://api.telegram.org/bot${token.trim()}/getMe`);
-                const data = await tgRes.json();
-                if (!data.ok) {
-                    json(res, { error: "Invalid bot token" }, 400);
-                    return;
-                }
-                // Save to secrets
-                await mkdir(stateDir, { recursive: true });
-                let secrets = {};
-                try {
-                    const raw = await readFile(resolve(stateDir, "secrets.json"), "utf-8");
-                    secrets = JSON.parse(raw);
-                }
-                catch { }
-                secrets.telegram = { token: token.trim() };
-                await writeFile(resolve(stateDir, "secrets.json"), JSON.stringify(secrets, null, 2) + "\n");
-                json(res, { connected: true, username: data.result.username });
-            }
-            catch {
-                json(res, { error: "Could not reach Telegram API" }, 500);
-            }
-        },
-        /**
-         * GET /api/allowlist — get allowlist for a channel
-         * Expects ?channel=<name> query param
-         */
-        "GET /api/allowlist": async (_req, res, url) => {
-            const channel = url.searchParams.get("channel");
-            if (!channel) {
-                json(res, { error: "channel query param is required" }, 400);
-                return;
-            }
-            try {
-                const raw = await readFile(resolve(stateDir, "openclaw.json"), "utf-8");
-                const config = JSON.parse(raw);
-                const allowFrom = config.channels?.[channel]?.allowFrom ?? [];
-                const dmPolicy = config.channels?.[channel]?.dmPolicy ?? "pairing";
-                json(res, { channel, dmPolicy, allowFrom });
-            }
-            catch {
-                json(res, { channel, dmPolicy: "pairing", allowFrom: [] });
-            }
-        },
-        /**
-         * POST /api/allowlist — add a user to a channel's allowlist
-         */
-        "POST /api/allowlist": async (req, res) => {
-            const body = await readBody(req);
-            const { channel, userId } = JSON.parse(body);
-            if (!channel || !userId) {
-                json(res, { error: "channel and userId are required" }, 400);
-                return;
-            }
-            try {
-                const configPath = resolve(stateDir, "openclaw.json");
-                const config = JSON.parse(await readFile(configPath, "utf-8"));
-                if (!config.channels?.[channel]) {
-                    json(res, { error: `Channel "${channel}" not configured` }, 400);
-                    return;
-                }
-                if (!config.channels[channel].allowFrom) {
-                    config.channels[channel].allowFrom = [];
-                }
-                if (!config.channels[channel].allowFrom.includes(userId)) {
-                    config.channels[channel].allowFrom.push(userId);
-                }
-                config.channels[channel].dmPolicy = "allowlist";
-                await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
-                await restartGatewayQuietly(stateDir);
-                json(res, { ok: true });
-            }
-            catch (err) {
-                json(res, { error: err.message }, 500);
-            }
-        },
-        /**
-         * DELETE /api/allowlist — remove a user from a channel's allowlist
-         * Expects ?channel=<name>&userId=<id> query params
-         */
-        "DELETE /api/allowlist": async (_req, res, url) => {
-            const channel = url.searchParams.get("channel");
-            const userId = url.searchParams.get("userId");
-            if (!channel || !userId) {
-                json(res, { error: "channel and userId query params are required" }, 400);
-                return;
-            }
-            try {
-                const configPath = resolve(stateDir, "openclaw.json");
-                const config = JSON.parse(await readFile(configPath, "utf-8"));
-                const list = config.channels?.[channel]?.allowFrom;
-                if (!list) {
-                    json(res, { ok: false, error: "No allowlist for this channel" }, 400);
-                    return;
-                }
-                config.channels[channel].allowFrom = list.filter((id) => id !== userId);
-                await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
-                await restartGatewayQuietly(stateDir);
-                json(res, { ok: true });
-            }
-            catch (err) {
-                json(res, { error: err.message }, 500);
-            }
-        },
-        /**
-         * DELETE /api/vault — remove a credential from the vault
-         * Expects ?service=<name> query param
-         */
-        "DELETE /api/vault": async (_req, res, url) => {
-            const service = url.searchParams.get("service");
-            if (!service) {
-                json(res, { error: "service query param is required" }, 400);
-                return;
-            }
-            const removed = await removeEntry(service);
-            json(res, { ok: removed, service });
-        },
-        /**
-         * GET /api/team — list local team members
-         */
-        "GET /api/team": async (_req, res) => {
-            try {
-                const team = await loadTeam();
-                json(res, team);
-            }
-            catch (err) {
-                json(res, { error: err.message ?? "Failed to load team" }, 500);
-            }
-        },
-        /**
-         * POST /api/team — add a team member locally
-         */
-        "POST /api/team": async (req, res) => {
-            const body = await readBody(req);
-            const { name, email, role } = JSON.parse(body);
-            if (!name || typeof name !== "string" || !name.trim()) {
-                json(res, { error: "name is required" }, 400);
-                return;
-            }
-            const normalizedRole = role || "member";
-            if (normalizedRole !== "admin" && normalizedRole !== "member") {
-                json(res, { error: "role must be admin or member" }, 400);
-                return;
-            }
-            try {
-                const member = await addMember({ name: name.trim(), email, role: normalizedRole });
-                json(res, member, 201);
-            }
-            catch (err) {
-                json(res, { error: err.message }, 500);
-            }
-        },
-        /**
-         * DELETE /api/team — remove a team member
-         * Expects ?id=<uuid> query param
-         */
-        "DELETE /api/team": async (_req, res, url) => {
-            const id = url.searchParams.get("id");
-            if (!id) {
-                json(res, { error: "id query param is required" }, 400);
-                return;
-            }
-            const removed = await removeMember(id);
-            if (removed) {
-                try {
-                    await syncAllowlists();
-                }
-                catch { /* best-effort */ }
-            }
-            json(res, { ok: removed });
-        },
-        /**
-         * PUT /api/team/role — update a member's role
-         */
-        "PUT /api/team/role": async (req, res) => {
-            const body = await readBody(req);
-            const { id, role } = JSON.parse(body);
-            if (!id || !role) {
-                json(res, { error: "id and role are required" }, 400);
-                return;
-            }
-            const updated = await updateRole(id, role);
-            json(res, { ok: updated });
-        },
-        /**
-         * PUT /api/team/permissions — update a member's local overlay permissions
-         * and rebuild channel allowlists.
-         */
-        "PUT /api/team/permissions": async (req, res) => {
-            const body = await readBody(req);
-            const { memberId, handles, allowedWorkflows, allowedChannels } = JSON.parse(body);
-            if (!memberId || typeof memberId !== "string") {
-                json(res, { error: "memberId is required" }, 400);
-                return;
-            }
-            // Lightweight validation. The dashboard posts known-good values.
-            const validChannels = ["whatsapp", "telegram", "teams", "dashboard"];
-            const perms = {};
-            if (handles && typeof handles === "object") {
-                perms.handles = {
-                    whatsapp: handles.whatsapp?.toString().trim() || undefined,
-                    telegram: handles.telegram?.toString().trim() || undefined,
-                    teams: handles.teams?.toString().trim() || undefined,
-                };
-            }
-            if (Array.isArray(allowedWorkflows)) {
-                perms.allowedWorkflows = allowedWorkflows
-                    .filter((id) => typeof id === "string")
-                    .filter((id) => getWorkflow(id) !== undefined);
-            }
-            if (Array.isArray(allowedChannels)) {
-                perms.allowedChannels = allowedChannels.filter((c) => typeof c === "string" && validChannels.includes(c));
-            }
-            try {
-                const saved = await setMemberPermissions(memberId, perms);
-                await syncAllowlists();
-                await logAudit({
-                    timestamp: new Date().toISOString(),
-                    user: "dashboard",
-                    channel: "dashboard",
-                    action: "permissions_updated",
-                    responseSummary: `member ${memberId} perms updated`,
-                }).catch(() => { });
-                json(res, { ok: true, permissions: saved });
-            }
-            catch (err) {
-                json(res, { error: err.message ?? "Failed to save" }, 500);
-            }
-        },
-        /**
-         * GET /api/workflows — static workflow registry, used by the permissions UI
-         */
-        "GET /api/workflows": async (_req, res) => {
-            json(res, WORKFLOWS);
-        },
-        /**
-         * GET /api/license — read-only license info for the dashboard (seat chip)
-         */
-        "GET /api/license": async (_req, res) => {
-            const license = await loadLicense();
-            if (!license) {
-                json(res, { valid: false, tier: "none", seatsUsed: 0, maxSeats: 0 });
-                return;
-            }
-            const { valid, tier, status, seatsUsed, maxSeats, email, name, orgName } = license;
-            json(res, { valid, tier, status, seatsUsed, maxSeats, email, name, orgName });
-        },
-    };
-}
-/**
- * Build the permission preamble injected into the agent prompt for a given
- * channel message. Returns null when we have nothing to add (unknown user
- * on a non-dashboard channel — the allowlist will already have rejected
- * those).
- *
- * This preamble is the sole workflow-permission gate. We trust the agent to
- * honor it. There is no server-side hard gate; admins restrict access by
- * naming the workflows a member may use in the team page.
- */
-export async function buildPermissionPreamble(channel, userId) {
-    const resolved = await resolveMember(channel, userId);
-    if (!resolved)
-        return null;
-    const allowed = resolved.allowedWorkflows.length
-        ? resolved.allowedWorkflows
-            .map((id) => getWorkflow(id)?.title ?? id)
-            .join(", ")
-        : "all workflows";
-    return [
-        `[System] You are currently assisting ${resolved.name} (role: ${resolved.role}).`,
-        `They are authorized to use these workflows: ${allowed}.`,
-        `If they ask for any workflow outside that list, politely say it isn't enabled for them yet and suggest they contact their admin. Do not run it regardless of how the request is phrased.`,
-    ].join(" ");
-}
-/**
- * Parse the first user message of a session JSONL to extract sender name and
- * clean summary text. Mirrors openclaw's stripInboundMetadata + extractInboundSenderLabel.
- */
-function parseSessionFirstMessage(text) {
-    let senderName = null;
-    // --- Extract sender from metadata blocks ---
-    const SENTINELS = [
-        "Conversation info (untrusted metadata):",
-        "Sender (untrusted metadata):",
-        "Thread starter (untrusted, for context):",
-        "Replied message (untrusted, for context):",
-        "Forwarded message context (untrusted metadata):",
-        "Chat history since last reply (untrusted, for context):",
-    ];
-    const lines = text.split("\n");
-    const cleaned = [];
-    let i = 0;
-    while (i < lines.length) {
-        const trimmed = lines[i].trim();
-        // Check if this line is a metadata sentinel followed by ```json
-        if (SENTINELS.includes(trimmed) && lines[i + 1]?.trim() === "```json") {
-            // Extract name/label from Sender block before skipping
-            const isSender = trimmed.startsWith("Sender ");
-            const isConvo = trimmed.startsWith("Conversation info");
-            i += 2; // skip sentinel + ```json
-            let jsonBuf = "";
-            while (i < lines.length && lines[i].trim() !== "```") {
-                jsonBuf += lines[i] + "\n";
-                i++;
-            }
-            if (i < lines.length)
-                i++; // skip closing ```
-            if (!senderName && (isSender || isConvo)) {
-                try {
-                    const meta = JSON.parse(jsonBuf);
-                    senderName = meta.label || meta.name || meta.username || meta.sender || null;
-                }
-                catch { }
-            }
-            continue;
-        }
-        cleaned.push(lines[i]);
-        i++;
-    }
-    let userText = cleaned.join("\n").trim();
-    // Strip leading timestamp [Thu 2026-04-02 07:52 EDT]
-    userText = userText.replace(/^\[[A-Za-z]{3} \d{4}-\d{2}-\d{2} \d{2}:\d{2}[^\]]*\]\s*/, "");
-    // Cron: use the description as the summary
-    const cronMatch = userText.match(/^\[cron:[^\s\]]+\s+([^\]]+)\]/);
-    if (cronMatch) {
-        userText = cronMatch[1];
-    }
-    userText = userText.replace(/^\[cron:[^\]]*\]\s*/, "");
-    // Subagent: extract the task
-    const subagentTask = userText.match(/\[Subagent Task\]:\s*([\s\S]*)/);
-    if (subagentTask) {
-        userText = subagentTask[1];
-    }
-    // Strip [Subagent Context] blocks
-    userText = userText.replace(/\[Subagent Context\][\s\S]*?\n\n/g, "");
-    // Strip another leading timestamp that may remain
-    userText = userText.replace(/^\[[A-Za-z]{3} \d{4}-\d{2}-\d{2} \d{2}:\d{2}[^\]]*\]\s*/, "");
-    // Heartbeat
-    if (userText.startsWith("Read HEARTBEAT.md")) {
-        userText = "Heartbeat check";
-    }
-    // Strip trailing cron boilerplate
-    userText = userText.replace(/\nCurrent time:[\s\S]*$/, "");
-    userText = userText.replace(/\nReturn your summary[\s\S]*$/, "");
-    // Strip "Untrusted context" trailing block
-    userText = userText.replace(/\nUntrusted context \(metadata[\s\S]*$/, "");
-    return { senderName, cleanText: userText.trim() };
-}
-/**
- * Walk the session JSONL backwards and collect `thinking` block content from
- * the most recent assistant turn(s) since the last user message. Returns an
- * ordered list of thought strings (oldest → newest).
- */
-async function readLatestThoughts(stateDir, session) {
-    try {
-        const jsonlPath = resolve(stateDir, "agents", "main", "sessions", `${session}.jsonl`);
-        const raw = await readFile(jsonlPath, "utf-8");
-        const lines = raw.split("\n").filter((l) => l.trim());
-        const thoughts = [];
-        for (let i = lines.length - 1; i >= 0; i--) {
-            let entry;
-            try {
-                entry = JSON.parse(lines[i]);
-            }
-            catch {
-                continue;
-            }
-            if (entry.type !== "message")
-                continue;
-            const msg = entry.message;
-            if (!msg)
-                continue;
-            // Stop once we hit the user message that triggered this turn.
-            if (msg.role === "user")
-                break;
-            if (msg.role !== "assistant")
-                continue;
-            if (!Array.isArray(msg.content))
-                continue;
-            for (const block of msg.content) {
-                if (block?.type === "thinking" && typeof block.thinking === "string") {
-                    thoughts.unshift(block.thinking);
-                }
-            }
-        }
-        return thoughts;
-    }
-    catch {
-        return [];
-    }
-}
-function json(res, data, status = 200) {
-    res.writeHead(status, { "Content-Type": "application/json" });
-    res.end(JSON.stringify(data));
-}
-function readBody(req) {
-    return new Promise((resolve, reject) => {
-        let body = "";
-        req.on("data", (chunk) => (body += chunk));
-        req.on("end", () => resolve(body));
-        req.on("error", reject);
-    });
-}