chapterhouse 0.9.1 → 0.10.0

package/dist/api/routes/agents.js

@@ -0,0 +1,472 @@
+import { Router } from "express";
+import { existsSync, readFileSync, statSync, writeFileSync } from "fs";
+import { join, resolve, sep } from "path";
+import { z } from "zod";
+import { agentEventBus } from "../../copilot/agent-event-bus.js";
+import { ensureDefaultAgents, getAgent, getAgentRegistry, isBuiltinAgent, loadAgents, notifyAgentSaved, parseAgentMd, parseAgentMdOrThrow, serializeAgentMd, SLUG_REGEX, } from "../../copilot/agents.js";
+import { getLastRouteResult, interruptSessionTurn, reloadPersistentAgent } from "../../copilot/orchestrator.js";
+import { getTaskLogEvents, subscribeTaskLog } from "../../copilot/task-event-log.js";
+import { getRouterConfig, updateRouterConfig } from "../../copilot/router.js";
+import { listSkills, removeSkill } from "../../copilot/skills.js";
+import { config, persistModel } from "../../config.js";
+import { AGENTS_DIR } from "../../paths.js";
+import { AgentDetailSchema, AgentListSchema, AutoConfigSchema, ChannelListSchema, ListModelsResponseSchema, ModelResponseSchema, RemoveSkillResponseSchema, SetModelResponseSchema, SkillListSchema, StatusResponseSchema, WorkerDetailSchema, WorkerListSchema, } from "../../shared/api-schemas.js";
+import { getDb, getTaskEvents } from "../../store/db.js";
+import { childLogger } from "../../util/logger.js";
+import { assertAgentEditAccess } from "../agent-edit-access.js";
+import { BadRequestError, ForbiddenError, InternalServerError, NotFoundError, parseRequest } from "../errors.js";
+import { sendJson } from "../send-json.js";
+import { formatSseData } from "../sse.js";
+import { setupSseCleanup } from "../server-runtime.js";
+import { broadcastSsePayloadToSession } from "../sse-hub.js";
+const log = childLogger("server");
+const requiredString = (message) => z.string({ error: message }).trim().min(1, message);
+const modelRequestSchema = z.object({
+    model: requiredString("Missing 'model' in request body"),
+}).strict();
+const autoRequestSchema = z.object({
+    enabled: z.boolean().optional(),
+    tierModels: z.object({
+        fast: requiredString("tierModels.fast must be a non-empty string").optional(),
+        standard: requiredString("tierModels.standard must be a non-empty string").optional(),
+        premium: requiredString("tierModels.premium must be a non-empty string").optional(),
+    }).strict().optional(),
+    cooldownMessages: z.number({ error: "cooldownMessages must be a number" })
+        .int("cooldownMessages must be an integer")
+        .min(0, "cooldownMessages must be a non-negative integer")
+        .optional(),
+}).strict();
+const agentPatchSchema = z.object({
+    name: requiredString("name must be a non-empty string").optional(),
+    description: requiredString("description must be a non-empty string").optional(),
+    model: requiredString("model must be a non-empty string").optional(),
+    systemPrompt: z.string().optional(),
+}).strict();
+function getLoadedAgents() {
+    let agents = getAgentRegistry();
+    if (agents.length === 0) {
+        ensureDefaultAgents();
+        agents = loadAgents();
+    }
+    return agents;
+}
+function getAgentLastEdited(slug) {
+    try {
+        return statSync(join(AGENTS_DIR, `${slug}.agent.md`)).mtime.toISOString();
+    }
+    catch {
+        return null;
+    }
+}
+export function createAgentsRouter(options) {
+    const { modeContext } = options;
+    const router = Router();
+    router.get("/api/agents", (_req, res) => {
+        const agents = getLoadedAgents()
+            .map((agent) => ({
+            name: agent.name,
+            slug: agent.slug,
+            description: agent.description,
+            model: agent.model,
+            scope: agent.scope ?? null,
+            type: isBuiltinAgent(agent.slug) ? "builtin" : "custom",
+            lastEdited: getAgentLastEdited(agent.slug),
+        }))
+            .sort((left, right) => {
+            if (left.type !== right.type) {
+                return left.type === "builtin" ? -1 : 1;
+            }
+            return left.name.localeCompare(right.name);
+        });
+        sendJson(res, AgentListSchema, agents);
+    });
+    router.get("/api/agents/:slug", (req, res, next) => {
+        const slugParam = req.params.slug;
+        const slug = Array.isArray(slugParam) ? slugParam[0] : slugParam;
+        if (slug === "stream") {
+            next();
+            return;
+        }
+        if (!SLUG_REGEX.test(slug)) {
+            res.status(400).json({ error: "Invalid slug" });
+            return;
+        }
+        getLoadedAgents();
+        const filePath = join(AGENTS_DIR, `${slug}.agent.md`);
+        const resolvedAgentsDir = resolve(AGENTS_DIR);
+        const resolvedFilePath = resolve(filePath);
+        if (!(resolvedFilePath === resolvedAgentsDir || resolvedFilePath.startsWith(`${resolvedAgentsDir}${sep}`))) {
+            res.status(403).json({ error: "Access denied" });
+            return;
+        }
+        let content;
+        try {
+            content = readFileSync(filePath, "utf-8");
+        }
+        catch {
+            res.status(404).json({ error: `Agent '${slug}' not found` });
+            return;
+        }
+        const agent = parseAgentMd(content, slug);
+        if (!agent) {
+            res.status(500).json({ error: `Agent '${slug}' could not be parsed` });
+            return;
+        }
+        const builtin = isBuiltinAgent(slug);
+        sendJson(res, AgentDetailSchema, {
+            name: agent.name,
+            slug: agent.slug,
+            description: agent.description,
+            model: agent.model,
+            scope: agent.scope ?? null,
+            persistent: agent.persistent ?? false,
+            skills: agent.skills ?? [],
+            type: builtin ? "builtin" : "custom",
+            editable: !builtin,
+            systemPrompt: agent.systemMessage,
+        });
+    });
+    router.patch("/api/agents/:slug", async (req, res) => {
+        const slugParam = req.params.slug;
+        const slug = Array.isArray(slugParam) ? slugParam[0] : slugParam;
+        if (!SLUG_REGEX.test(slug)) {
+            throw new BadRequestError("Invalid slug");
+        }
+        if (modeContext.isTeam() && req.user?.role !== "team-lead") {
+            throw new ForbiddenError("Forbidden");
+        }
+        const patch = parseRequest(agentPatchSchema, req.body ?? {});
+        const filePath = join(AGENTS_DIR, `${slug}.agent.md`);
+        const resolvedAgentsDir = resolve(AGENTS_DIR);
+        const resolvedFilePath = resolve(filePath);
+        if (!(resolvedFilePath === resolvedAgentsDir || resolvedFilePath.startsWith(`${resolvedAgentsDir}${sep}`))) {
+            throw new ForbiddenError("Access denied");
+        }
+        assertAgentEditAccess({ entraAuthEnabled: config.entraAuthEnabled }, req.user);
+        if (isBuiltinAgent(slug)) {
+            throw new ForbiddenError("Built-in agents are read-only");
+        }
+        if (!existsSync(filePath)) {
+            throw new NotFoundError("Agent not found");
+        }
+        try {
+            const current = parseAgentMdOrThrow(readFileSync(filePath, "utf-8"), slug);
+            const updated = {
+                ...current,
+                name: patch.name ?? current.name,
+                description: patch.description ?? current.description,
+                model: patch.model ?? current.model,
+                systemMessage: patch.systemPrompt ?? current.systemMessage,
+            };
+            const nextContent = serializeAgentMd(updated);
+            writeFileSync(filePath, nextContent, "utf-8");
+            await notifyAgentSaved(slug, updated);
+            sendJson(res, AgentDetailSchema, {
+                name: updated.name,
+                slug: updated.slug,
+                description: updated.description,
+                model: updated.model,
+                scope: updated.scope ?? null,
+                persistent: updated.persistent ?? false,
+                skills: updated.skills ?? [],
+                type: "custom",
+                editable: true,
+                systemPrompt: updated.systemMessage,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new BadRequestError(`Invalid content: ${message}`);
+        }
+    });
+    router.get("/api/channels", (_req, res) => {
+        const agents = getLoadedAgents();
+        const persistentAgentChannels = agents
+            .filter((agent) => agent.persistent)
+            .map((agent) => ({
+            key: `agent:${agent.slug}`,
+            label: `# ${agent.slug}`,
+            slug: agent.slug,
+            name: agent.name,
+            description: agent.description,
+            ...(agent.scope ? { scope: agent.scope } : {}),
+        }))
+            .sort((a, b) => a.label.localeCompare(b.label));
+        sendJson(res, ChannelListSchema, [
+            {
+                key: "default",
+                label: "# chapterhouse",
+                name: "Chapterhouse",
+                description: "Orchestrator",
+            },
+            ...persistentAgentChannels,
+        ]);
+    });
+    // List all workers: reads from SQLite agent_tasks (last 24 hours) so completed
+    // dispatched subagents remain visible after they finish, not just in-flight ones.
+    router.get("/api/workers", (_req, res) => {
+        const rows = getDb()
+            .prepare(`SELECT task_id, agent_slug, description, status, started_at, completed_at
+       FROM agent_tasks
+       WHERE started_at >= datetime('now', '-24 hours')
+       ORDER BY started_at DESC
+       LIMIT 100`)
+            .all();
+        const registry = getAgentRegistry();
+        sendJson(res, WorkerListSchema, rows.map((row) => {
+            const agent = registry.find((a) => a.slug === row.agent_slug);
+            return {
+                taskId: row.task_id,
+                slug: row.agent_slug,
+                name: agent?.name || row.agent_slug,
+                model: agent?.model || "unknown",
+                description: row.description,
+                status: row.status,
+                startedAt: row.started_at,
+                completedAt: row.completed_at,
+            };
+        }));
+    });
+    // Detailed worker row: include task status, description, and any captured result/output.
+    router.get("/api/workers/:taskId", (req, res) => {
+        const taskId = req.params.taskId;
+        const row = getDb()
+            .prepare(`SELECT task_id, agent_slug, description, prompt, status, result, started_at, completed_at
+       FROM agent_tasks WHERE task_id = ?`)
+            .get(taskId);
+        if (!row) {
+            throw new NotFoundError("Task not found");
+        }
+        const registry = getAgentRegistry();
+        const agent = registry.find((a) => a.slug === row.agent_slug);
+        sendJson(res, WorkerDetailSchema, {
+            taskId: row.task_id,
+            agentSlug: row.agent_slug,
+            name: agent?.name || row.agent_slug,
+            description: row.description,
+            prompt: row.prompt,
+            status: row.status,
+            result: row.result,
+            startedAt: row.started_at,
+            completedAt: row.completed_at,
+        });
+    });
+    const TERMINAL_TASK_STATUSES = new Set(["completed", "failed", "cancelled", "error"]);
+    // SSE stream for per-task tool-call activity.
+    // Replays buffered/persisted backlog on connect, then streams live events until
+    // the task reaches a terminal state.
+    router.get("/api/workers/:taskId/events", (req, res) => {
+        const taskId = req.params.taskId;
+        const taskRow = getDb()
+            .prepare(`SELECT task_id FROM agent_tasks WHERE task_id = ?`)
+            .get(taskId);
+        if (!taskRow) {
+            throw new NotFoundError("Task not found");
+        }
+        res.setHeader("Content-Type", "text/event-stream");
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Connection", "keep-alive");
+        res.setHeader("X-Accel-Buffering", "no");
+        res.flushHeaders();
+        const rawLastId = req.headers["last-event-id"];
+        const lastSeq = rawLastId && !Array.isArray(rawLastId) && /^\d+$/.test(rawLastId.trim())
+            ? parseInt(rawLastId.trim(), 10)
+            : undefined;
+        const sendEvent = (event) => {
+            let payload;
+            if (event.kind === "output_delta") {
+                payload = {
+                    type: "output_delta",
+                    taskId: event.taskId,
+                    seq: event.seq,
+                    text: event.text ?? "",
+                };
+            }
+            else if (event.kind === "task_status") {
+                payload = {
+                    type: "task_status",
+                    taskId: event.taskId,
+                    seq: event.seq,
+                    status: event.status ?? "running",
+                    summary: event.summary,
+                };
+            }
+            else {
+                payload = {
+                    taskId: event.taskId,
+                    seq: event.seq,
+                    ts: event.ts,
+                    kind: event.kind,
+                    toolName: event.toolName,
+                    summary: event.summary,
+                };
+            }
+            res.write(`id: ${event.seq}\ndata: ${JSON.stringify(payload)}\n\n`);
+        };
+        let replayHighSeq = lastSeq;
+        if (lastSeq !== undefined) {
+            const bufferedEvents = getTaskLogEvents(taskId);
+            const oldestBufferedSeq = bufferedEvents[0]?.seq;
+            const bufferMissesRange = oldestBufferedSeq === undefined || oldestBufferedSeq > lastSeq + 1;
+            if (bufferMissesRange) {
+                const dbEvents = getTaskEvents(taskId, lastSeq);
+                for (const event of dbEvents) {
+                    sendEvent(event);
+                    if (replayHighSeq === undefined || event.seq > replayHighSeq) {
+                        replayHighSeq = event.seq;
+                    }
+                }
+            }
+        }
+        const replayEvents = getTaskLogEvents(taskId, replayHighSeq ?? 0);
+        const backlog = replayEvents.length > 0 ? replayEvents : getTaskEvents(taskId, replayHighSeq ?? 0);
+        for (const event of backlog) {
+            sendEvent(event);
+        }
+        const isTerminal = () => {
+            const row = getDb()
+                .prepare(`SELECT status FROM agent_tasks WHERE task_id = ?`)
+                .get(taskId);
+            return row ? TERMINAL_TASK_STATUSES.has(row.status) : true;
+        };
+        res.write(`: connected task=${taskId}\n\n`);
+        if (isTerminal()) {
+            res.end();
+            return;
+        }
+        const heartbeat = setInterval(() => {
+            res.write(`: keep-alive\n\n`);
+        }, 15_000);
+        setupSseCleanup((registerCleanup, cleanupNow) => {
+            registerCleanup(() => clearInterval(heartbeat));
+            registerCleanup(subscribeTaskLog(taskId, (event) => {
+                sendEvent(event);
+                // Close SSE when a terminal task_status event arrives
+                if (event.kind === "task_status" && event.status && TERMINAL_TASK_STATUSES.has(event.status)) {
+                    cleanupNow();
+                    res.end();
+                }
+            }));
+            registerCleanup(agentEventBus.subscribe("session:destroyed", (event) => {
+                if (event.sessionId === taskId && isTerminal()) {
+                    cleanupNow();
+                    res.end();
+                }
+            }));
+            registerCleanup(agentEventBus.subscribe("session:error", (event) => {
+                if (event.sessionId === taskId && isTerminal()) {
+                    cleanupNow();
+                    res.end();
+                }
+            }));
+            req.on("close", cleanupNow);
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Global agent EventBus SSE stream — thin pass-through of AgentEvents.
+    // Replaces the 4-second poll in the Workers frontend: clients subscribe once
+    // and receive push notifications on session:created / session:destroyed /
+    // session:error so the worker list updates in real time.
+    // Chat-specific events (delta, message, queued) are NOT emitted here.
+    // ---------------------------------------------------------------------------
+    router.get("/api/agents/stream", (req, res) => {
+        res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        });
+        res.write(formatSseData({ type: "connected" }));
+        const heartbeat = setInterval(() => { res.write(`:ping\n\n`); }, 20_000);
+        setupSseCleanup((registerCleanup, cleanupNow) => {
+            registerCleanup(() => clearInterval(heartbeat));
+            registerCleanup(agentEventBus.subscribeAll((event) => {
+                res.write(formatSseData({ type: "agent_event", agentEvent: event }));
+            }));
+            req.on("close", cleanupNow);
+        });
+    });
+    router.post("/api/agents/:slug/reload-confirm", async (req, res) => {
+        const slugParam = Array.isArray(req.params.slug) ? req.params.slug[0] : req.params.slug;
+        const slug = slugParam?.trim() || "";
+        const agent = getAgent(slug);
+        if (!agent?.persistent) {
+            throw new NotFoundError("Agent not found");
+        }
+        const sessionKey = `agent:${agent.slug}`;
+        await interruptSessionTurn(sessionKey);
+        const reloadResult = await reloadPersistentAgent(agent.slug);
+        if (reloadResult === "reloaded") {
+            broadcastSsePayloadToSession(sessionKey, { type: "agent_reloaded", slug: agent.slug, reason: "confirmed_restart" });
+        }
+        sendJson(res, StatusResponseSchema, { status: "ok" });
+    });
+    router.get("/api/model", (_req, res) => {
+        sendJson(res, ModelResponseSchema, { model: config.copilotModel });
+    });
+    router.post("/api/model", async (req, res) => {
+        const { model } = parseRequest(modelRequestSchema, req.body);
+        try {
+            const { getClient } = await import("../../copilot/client.js");
+            const client = await getClient();
+            const models = await client.listModels();
+            const match = models.find((m) => m.id === model);
+            if (!match) {
+                const suggestions = models
+                    .filter((m) => m.id.includes(model) || m.id.toLowerCase().includes(model.toLowerCase()))
+                    .map((m) => m.id);
+                const hint = suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}?` : "";
+                throw new BadRequestError(`Model '${model}' not found.${hint}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof BadRequestError) {
+                throw error;
+            }
+            // If we can't validate (client not ready), allow the switch — it'll fail on next message if wrong
+        }
+        const previous = config.copilotModel;
+        config.copilotModel = model;
+        persistModel(model);
+        sendJson(res, SetModelResponseSchema, { previous, current: model });
+    });
+    router.get("/api/models", async (_req, res) => {
+        try {
+            const { getClient } = await import("../../copilot/client.js");
+            const client = await getClient();
+            const models = await client.listModels();
+            sendJson(res, ListModelsResponseSchema, { models: models.map((m) => m.id), current: config.copilotModel });
+        }
+        catch (error) {
+            log.error({ err: error instanceof Error ? error.message : error }, "Failed to list models");
+            throw new InternalServerError();
+        }
+    });
+    router.get("/api/auto", (_req, res) => {
+        const routerConfig = getRouterConfig();
+        const lastRoute = getLastRouteResult();
+        sendJson(res, AutoConfigSchema, {
+            ...routerConfig,
+            currentModel: config.copilotModel,
+            lastRoute: lastRoute || null,
+        });
+    });
+    router.post("/api/auto", (req, res) => {
+        const body = parseRequest(autoRequestSchema, req.body ?? {});
+        const updated = updateRouterConfig(body);
+        log.info({ enabled: updated.enabled }, "Auto-routing updated");
+        sendJson(res, AutoConfigSchema, updated);
+    });
+    router.get("/api/skills", (_req, res) => {
+        sendJson(res, SkillListSchema, listSkills());
+    });
+    router.delete("/api/skills/:slug", (req, res) => {
+        const slug = Array.isArray(req.params.slug) ? req.params.slug[0] : req.params.slug;
+        const result = removeSkill(slug);
+        if (!result.ok) {
+            throw new BadRequestError(result.message);
+        }
+        sendJson(res, RemoveSkillResponseSchema, { ok: true, message: result.message });
+    });
+    return router;
+}
+//# sourceMappingURL=agents.js.map