@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/worker/console/resolve-dag-run-for-task.js

@@ -0,0 +1,115 @@
+/**
+ * Resolve / list DAG run ids for a harness task under `.harness/dag-runs`.
+ * Used by Console observeLink and Recovery candidates API.
+ */
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { sortRecoveryRunCandidates, } from "./recovery-selection.js";
+const LIFECYCLE_ORDER = ["active", "paused", "completed"];
+async function readTaskIdFromRunDir(runDir) {
+    const runJsonPath = path.join(runDir, "run.json");
+    try {
+        const raw = JSON.parse(await readFile(runJsonPath, "utf8"));
+        const fromBinding = raw.taskContractBinding?.taskId?.trim() ||
+            raw.sourceBinding?.taskId?.trim();
+        if (fromBinding)
+            return fromBinding;
+        const title = raw.title?.trim() ?? "";
+        const hybrid = /^Hybrid DAG:\s*(.+)$/i.exec(title);
+        if (hybrid?.[1]?.trim())
+            return hybrid[1].trim();
+    }
+    catch {
+        /* missing/invalid run.json — skip */
+    }
+    return undefined;
+}
+async function readRunMeta(runDir) {
+    try {
+        const raw = JSON.parse(await readFile(path.join(runDir, "state.json"), "utf8"));
+        return {
+            status: typeof raw.status === "string" ? raw.status : undefined,
+            title: typeof raw.title === "string" ? raw.title : undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+async function scanDagRunCandidates(repoRoot, taskIdFilter) {
+    const wanted = taskIdFilter?.trim() || undefined;
+    const matches = [];
+    for (const lifecycle of LIFECYCLE_ORDER) {
+        const lifecycleDir = path.join(repoRoot, ".harness", "dag-runs", lifecycle);
+        let entries = [];
+        try {
+            entries = await readdir(lifecycleDir);
+        }
+        catch {
+            continue;
+        }
+        for (const name of entries) {
+            if (!name || name === ".gitkeep")
+                continue;
+            const runDir = path.join(lifecycleDir, name);
+            let st;
+            try {
+                st = await stat(runDir);
+            }
+            catch {
+                continue;
+            }
+            if (!st.isDirectory())
+                continue;
+            const boundTaskId = await readTaskIdFromRunDir(runDir);
+            if (wanted && boundTaskId !== wanted)
+                continue;
+            const meta = await readRunMeta(runDir);
+            matches.push({
+                dagRunId: name,
+                lifecycle,
+                mtimeMs: st.mtimeMs,
+                status: meta.status,
+                title: meta.title,
+                ...(boundTaskId ? { taskId: boundTaskId } : {}),
+            });
+        }
+    }
+    return matches;
+}
+/**
+ * Prefer active/paused over completed; within a lifecycle, newest mtime wins.
+ */
+export async function resolveLatestDagRunIdForTask(repoRoot, taskId) {
+    const wanted = taskId.trim();
+    if (!wanted)
+        return undefined;
+    const matches = await scanDagRunCandidates(repoRoot, wanted);
+    if (matches.length === 0)
+        return undefined;
+    const lifecycleRank = (value) => LIFECYCLE_ORDER.indexOf(value);
+    matches.sort((a, b) => {
+        const life = lifecycleRank(a.lifecycle) - lifecycleRank(b.lifecycle);
+        if (life !== 0)
+            return life;
+        return b.mtimeMs - a.mtimeMs;
+    });
+    const top = matches[0];
+    return {
+        dagRunId: top.dagRunId,
+        lifecycle: top.lifecycle,
+        mtimeMs: top.mtimeMs,
+    };
+}
+/**
+ * List DAG runs for Recovery pickers.
+ * - With taskId: only runs bound to that task
+ * - Without taskId: recent runs across lifecycles (capped)
+ * Sorted for recovery attention (failed/paused first).
+ */
+export async function listDagRunsForRecovery(repoRoot, options) {
+    const taskId = options?.taskId?.trim() || undefined;
+    const limit = Math.min(Math.max(options?.limit ?? 40, 1), 100);
+    const matches = await scanDagRunCandidates(repoRoot, taskId);
+    return sortRecoveryRunCandidates(matches).slice(0, limit);
+}

package/dist/worker/console/resource-loader.js

@@ -0,0 +1,95 @@
+/**
+ * Official Console ResourceLoader (Phase 2).
+ * Closed surface: no edit/write/bash/full-tools business tools.
+ * Runtime env MUST NOT restore denied tools.
+ * Requirement Interview uses a stricter allowlist (see interview/tools.ts).
+ */
+import { createInterviewResourceLoader, INTERVIEW_ALLOWED_TOOLS, INTERVIEW_DENIED_TOOLS, authorizeInterviewTool, } from "./interview/tools.js";
+export const OFFICIAL_DENIED_TOOL_IDS = Object.freeze([
+    "edit",
+    "write",
+    "bash",
+    "full-tools",
+    "full_tools",
+    "coding-chat",
+    "coding_chat",
+    "shell",
+    "apply_patch",
+    "apply-patch",
+    // Interview / operator mutation tools must never appear as free coding tools
+    "contractApply",
+    "contract_apply",
+    "runDag",
+    "run_dag",
+    "reconcile",
+]);
+/** Official Console surface allows Interview-scoped tools only when Interview session is active. */
+export const OFFICIAL_ALLOWED_TOOL_IDS = Object.freeze([
+    ...INTERVIEW_ALLOWED_TOOLS,
+]);
+const DENIED = new Set(OFFICIAL_DENIED_TOOL_IDS.map((id) => id.toLowerCase()));
+const ALLOWED = new Set(OFFICIAL_ALLOWED_TOOL_IDS.map((id) => id.toLowerCase()));
+/** Official allowed tools: Interview closed set (no mutation operator tools). */
+export function listOfficialTools() {
+    return OFFICIAL_ALLOWED_TOOL_IDS;
+}
+export function isOfficialToolDenied(toolId) {
+    const id = toolId.trim().toLowerCase();
+    if (DENIED.has(id))
+        return true;
+    const compact = id.replace(/[-_]/g, "");
+    for (const d of DENIED) {
+        if (d.replace(/[-_]/g, "") === compact)
+            return true;
+    }
+    return false;
+}
+/**
+ * Attempt to activate a tool on the Official Console surface.
+ * Write-class, full-tools, and Interview-forbidden mutation ids are always rejected.
+ */
+export function tryActivateTool(toolId) {
+    const id = toolId.trim();
+    if (!id) {
+        return {
+            ok: false,
+            code: "tool-denied",
+            toolId: id,
+            message: "empty tool id is not allowed on Official Console surface",
+        };
+    }
+    if (isOfficialToolDenied(id)) {
+        return {
+            ok: false,
+            code: "tool-denied",
+            toolId: id,
+            message: `tool "${id}" is denied on Official Loop Operator Console (no edit/write/bash/full-tools/contractApply/runDag/reconcile)`,
+        };
+    }
+    if (!ALLOWED.has(id.toLowerCase())) {
+        return {
+            ok: false,
+            code: "tool-denied",
+            toolId: id,
+            message: `tool "${id}" is not registered on Official Console ResourceLoader`,
+        };
+    }
+    return { ok: true, toolId: id };
+}
+export function assertOfficialToolAllowed(toolId) {
+    const result = tryActivateTool(toolId);
+    if (!result.ok) {
+        throw new Error(result.message);
+    }
+}
+export function createClosedResourceLoader() {
+    return {
+        mode: "official-closed",
+        deniedToolIds: OFFICIAL_DENIED_TOOL_IDS,
+        allowedToolIds: OFFICIAL_ALLOWED_TOOL_IDS,
+        listTools: listOfficialTools,
+        tryActivateTool,
+        allowsEnvToolRestore: false,
+    };
+}
+export { createInterviewResourceLoader, INTERVIEW_ALLOWED_TOOLS, INTERVIEW_DENIED_TOOLS, authorizeInterviewTool, };

package/dist/worker/console/routes.js

@@ -0,0 +1,475 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { dispatchOperatorAction } from "./operator-actions.js";
+import { openSseResponse, parseLastEventId, writeSseEvent, } from "./operation-sse.js";
+import { buildOperatorSurfaceHealthV1 } from "./operator-surface-health.js";
+import { ROUTES } from "../observe/routes.js";
+import { evaluateMutationGate, injectConfirmationTokenScript, isMutationMethod, } from "./security.js";
+import { listDagRunsForRecovery } from "./resolve-dag-run-for-task.js";
+export function sendJson(res, status, body, extraHeaders) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Content-Length": Buffer.byteLength(payload),
+        ...extraHeaders,
+    });
+    res.end(payload);
+}
+function contentTypeFor(pathname) {
+    const lower = pathname.toLowerCase();
+    if (lower.endsWith(".html"))
+        return "text/html; charset=utf-8";
+    if (lower.endsWith(".js") || lower.endsWith(".mjs")) {
+        return "text/javascript; charset=utf-8";
+    }
+    if (lower.endsWith(".css"))
+        return "text/css; charset=utf-8";
+    if (lower.endsWith(".json"))
+        return "application/json; charset=utf-8";
+    if (lower.endsWith(".svg"))
+        return "image/svg+xml";
+    if (lower.endsWith(".png"))
+        return "image/png";
+    if (lower.endsWith(".ico"))
+        return "image/x-icon";
+    if (lower.endsWith(".woff2"))
+        return "font/woff2";
+    return "application/octet-stream";
+}
+async function readJsonBody(req, maxBytes = 10 * 1024 * 1024) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        total += buf.length;
+        if (total > maxBytes) {
+            throw new Error(`request body exceeds ${maxBytes} bytes`);
+        }
+        chunks.push(buf);
+    }
+    if (chunks.length === 0)
+        return {};
+    const raw = Buffer.concat(chunks).toString("utf8");
+    if (!raw.trim())
+        return {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`invalid JSON body: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export async function handleConsoleHealthRequest(_req, res, ctx) {
+    try {
+        sendJson(res, 200, buildOperatorSurfaceHealthV1({
+            repoRoot: ctx.repoRoot,
+            piReadiness: ctx.operator?.getReadiness().state ?? "setup-required",
+            inspectReady: ctx.inspect.ready,
+            routes: ROUTES,
+        }));
+    }
+    catch {
+        sendJson(res, 200, {
+            schemaVersion: 1,
+            ok: true,
+            product: "loop-operator-console",
+            repoFingerprint: "unavailable",
+            packageName: "unknown",
+            packageVersion: "0.0.0",
+            piReadiness: ctx.operator?.getReadiness().state ?? "setup-required",
+            inspect: {
+                ready: ctx.inspect.ready,
+                routeCapabilities: ctx.inspect.routeCapabilities,
+                snapshotAvailable: true,
+                eventStreamAvailable: true,
+            },
+            generatedAt: new Date().toISOString(),
+        });
+    }
+}
+async function handleReadiness(_req, res, ctx) {
+    const report = ctx.operator?.getReadiness();
+    if (!report) {
+        sendJson(res, 200, {
+            state: "setup-required",
+            message: "operator runtime not configured",
+        });
+        return;
+    }
+    sendJson(res, 200, report);
+}
+async function handleRecoveryCandidates(_req, res, ctx, url) {
+    const taskId = url.searchParams.get("taskId")?.trim() || undefined;
+    const limitRaw = url.searchParams.get("limit");
+    const limit = limitRaw ? Number.parseInt(limitRaw, 10) : undefined;
+    const runs = await listDagRunsForRecovery(ctx.repoRoot, {
+        taskId,
+        ...(Number.isFinite(limit) ? { limit } : {}),
+    });
+    sendJson(res, 200, {
+        ok: true,
+        schemaVersion: 1,
+        taskId: taskId ?? null,
+        runs,
+    });
+}
+async function handleSessionPing(req, res, ctx) {
+    const failure = evaluateMutationGate(req, {
+        bootToken: ctx.bootToken.value,
+        confirmationToken: ctx.bootToken.confirmationToken,
+        consoleOrigin: ctx.getConsoleOrigin(),
+        allowNonLoopbackAccess: ctx.allowNonLoopbackAccess === true,
+    });
+    if (failure) {
+        sendJson(res, failure.status, {
+            ok: false,
+            error: { code: failure.code, message: failure.message },
+        });
+        return;
+    }
+    sendJson(res, 200, { ok: true, pong: true });
+}
+async function handleCreateOperation(req, res, ctx) {
+    if (!ctx.operator) {
+        sendJson(res, 503, {
+            ok: false,
+            error: {
+                code: "INTERNAL_ERROR",
+                message: "operator runtime unavailable",
+            },
+        });
+        return;
+    }
+    const failure = evaluateMutationGate(req, {
+        bootToken: ctx.bootToken.value,
+        confirmationToken: ctx.bootToken.confirmationToken,
+        consoleOrigin: ctx.getConsoleOrigin(),
+        allowNonLoopbackAccess: ctx.allowNonLoopbackAccess === true,
+    });
+    if (failure) {
+        sendJson(res, failure.status, {
+            ok: false,
+            error: { code: failure.code, message: failure.message },
+        });
+        return;
+    }
+    let body;
+    try {
+        body = (await readJsonBody(req));
+    }
+    catch (error) {
+        sendJson(res, 400, {
+            ok: false,
+            error: {
+                code: "INVALID_INPUT",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return;
+    }
+    const action = typeof body.action === "string" ? body.action : "";
+    const actionParams = body.actionParams && typeof body.actionParams === "object"
+        ? body.actionParams
+        : {};
+    const clientRequestId = typeof body.clientRequestId === "string" ? body.clientRequestId : undefined;
+    const result = await dispatchOperatorAction(ctx.operator.actionContext, {
+        action,
+        actionParams,
+        clientRequestId,
+    });
+    sendJson(res, result.status, result.body);
+}
+async function handleGetOperation(_req, res, ctx, operationId) {
+    if (!ctx.operator) {
+        sendJson(res, 503, {
+            ok: false,
+            error: {
+                code: "INTERNAL_ERROR",
+                message: "operator runtime unavailable",
+            },
+        });
+        return;
+    }
+    const op = await ctx.operator.operations.get(operationId);
+    if (!op) {
+        sendJson(res, 404, {
+            ok: false,
+            error: {
+                code: "NOT_FOUND",
+                message: `operation not found: ${operationId}`,
+            },
+        });
+        return;
+    }
+    sendJson(res, 200, { ok: true, operation: op });
+}
+async function handleOperationEvents(req, res, ctx, operationId) {
+    if (!ctx.operator) {
+        sendJson(res, 503, {
+            ok: false,
+            error: {
+                code: "INTERNAL_ERROR",
+                message: "operator runtime unavailable",
+            },
+        });
+        return;
+    }
+    const op = await ctx.operator.operations.get(operationId);
+    if (!op) {
+        sendJson(res, 404, {
+            ok: false,
+            error: {
+                code: "NOT_FOUND",
+                message: `operation not found: ${operationId}`,
+            },
+        });
+        return;
+    }
+    const lastEventId = parseLastEventId(typeof req.headers["last-event-id"] === "string"
+        ? req.headers["last-event-id"]
+        : undefined);
+    const listed = ctx.operator.events.listFrom(operationId, lastEventId);
+    if ("error" in listed) {
+        sendJson(res, 410, {
+            ok: false,
+            error: {
+                code: "EVENT_CURSOR_EXPIRED",
+                message: "event cursor expired; re-read operation snapshot",
+            },
+        });
+        return;
+    }
+    openSseResponse(res);
+    for (const event of listed.events) {
+        writeSseEvent(res, event);
+    }
+    // Keep connection briefly for live events; poll store
+    let closed = false;
+    req.on("close", () => {
+        closed = true;
+    });
+    const started = Date.now();
+    const maxMs = 30_000;
+    let cursor = listed.events.length > 0
+        ? listed.events[listed.events.length - 1].seq
+        : lastEventId;
+    while (!closed && Date.now() - started < maxMs) {
+        await new Promise((r) => setTimeout(r, 200));
+        const more = ctx.operator.events.listFrom(operationId, cursor);
+        if ("error" in more) {
+            res.write(`event: error\ndata: ${JSON.stringify({ code: "EVENT_CURSOR_EXPIRED" })}\n\n`);
+            break;
+        }
+        for (const event of more.events) {
+            writeSseEvent(res, event);
+            cursor = event.seq;
+        }
+        const current = await ctx.operator.operations.get(operationId);
+        if (current &&
+            (current.state === "succeeded" ||
+                current.state === "failed" ||
+                current.state === "timed-out" ||
+                current.state === "needs-reconcile")) {
+            // flush any final events then end
+            const final = ctx.operator.events.listFrom(operationId, cursor);
+            if (!("error" in final)) {
+                for (const event of final.events) {
+                    writeSseEvent(res, event);
+                }
+            }
+            break;
+        }
+    }
+    res.end();
+}
+/**
+ * Path-escape-safe static file serve for Console SPA.
+ * Sets boot capability cookie on HTML responses.
+ */
+export async function serveConsoleStatic(req, res, ctx) {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    let pathname = decodeURIComponent(url.pathname);
+    if (pathname === "/") {
+        pathname = "/index.html";
+    }
+    const filePath = path.join(ctx.staticDir, pathname);
+    const resolvedStatic = path.resolve(ctx.staticDir);
+    const resolvedFile = path.resolve(filePath);
+    if (!resolvedFile.startsWith(resolvedStatic + path.sep) &&
+        resolvedFile !== resolvedStatic) {
+        sendJson(res, 404, { error: "Not found" });
+        return;
+    }
+    if (!existsSync(resolvedFile)) {
+        // SPA fallback for non-file routes
+        const indexPath = path.join(resolvedStatic, "index.html");
+        if (existsSync(indexPath) && !pathname.includes(".")) {
+            const html = injectConfirmationTokenScript(await readFile(indexPath), ctx.bootToken.confirmationToken);
+            res.writeHead(200, {
+                "Content-Type": "text/html; charset=utf-8",
+                "Content-Length": html.byteLength,
+                "Set-Cookie": ctx.bootToken.setCookieHeader,
+            });
+            res.end(html);
+            return;
+        }
+        sendJson(res, 404, { error: "Not found" });
+        return;
+    }
+    const raw = await readFile(resolvedFile);
+    const contentType = contentTypeFor(pathname);
+    const content = contentType.startsWith("text/html")
+        ? injectConfirmationTokenScript(raw, ctx.bootToken.confirmationToken)
+        : raw;
+    const headers = {
+        "Content-Type": contentType,
+        "Content-Length": content.byteLength,
+    };
+    if (contentType.startsWith("text/html")) {
+        headers["Set-Cookie"] = ctx.bootToken.setCookieHeader;
+    }
+    res.writeHead(200, headers);
+    res.end(content);
+}
+async function handleNightAuxTickerGet(_req, res, ctx) {
+    const ticker = ctx.operator?.nightAuxTicker;
+    if (!ticker) {
+        sendJson(res, 503, {
+            ok: false,
+            error: {
+                code: "INTERNAL_ERROR",
+                message: "night aux ticker unavailable",
+            },
+        });
+        return;
+    }
+    sendJson(res, 200, { ok: true, ticker: ticker.status() });
+}
+async function handleNightAuxTickerPost(req, res, ctx) {
+    const ticker = ctx.operator?.nightAuxTicker;
+    if (!ticker) {
+        sendJson(res, 503, {
+            ok: false,
+            error: {
+                code: "INTERNAL_ERROR",
+                message: "night aux ticker unavailable",
+            },
+        });
+        return;
+    }
+    let body;
+    try {
+        body = (await readJsonBody(req));
+    }
+    catch (error) {
+        sendJson(res, 400, {
+            ok: false,
+            error: {
+                code: "INVALID_INPUT",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return;
+    }
+    if (typeof body.enabled !== "boolean") {
+        sendJson(res, 400, {
+            ok: false,
+            error: {
+                code: "INVALID_INPUT",
+                message: "enabled (boolean) is required",
+            },
+        });
+        return;
+    }
+    const status = ticker.setEnabled(body.enabled);
+    sendJson(res, 200, { ok: true, ticker: status });
+}
+export async function handleConsoleOperatorRequest(req, res, ctx) {
+    const method = (req.method ?? "GET").toUpperCase();
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const pathname = decodeURIComponent(url.pathname);
+    if (!pathname.startsWith("/api/operator/v1/") &&
+        !pathname.startsWith("/api/session/")) {
+        return false;
+    }
+    if (method === "GET" && pathname === "/api/operator/v1/readiness") {
+        await handleReadiness(req, res, ctx);
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/operator/v1/recovery/candidates") {
+        await handleRecoveryCandidates(req, res, ctx, url);
+        return true;
+    }
+    // Phase 1 mutation stub for security tests
+    if (method === "POST" && pathname === "/api/session/ping") {
+        await handleSessionPing(req, res, ctx);
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/operator/v1/operations") {
+        await handleCreateOperation(req, res, ctx);
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/operator/v1/night-aux-ticker") {
+        await handleNightAuxTickerGet(req, res, ctx);
+        return true;
+    }
+    const opMatch = pathname.match(/^\/api\/operator\/v1\/operations\/([^/]+)(?:\/(events))?$/);
+    if (opMatch) {
+        const operationId = decodeURIComponent(opMatch[1]);
+        if (method === "GET" && opMatch[2] === "events") {
+            await handleOperationEvents(req, res, ctx, operationId);
+            return true;
+        }
+        if (method === "GET") {
+            await handleGetOperation(req, res, ctx, operationId);
+            return true;
+        }
+    }
+    if (isMutationMethod(method)) {
+        const failure = evaluateMutationGate(req, {
+            bootToken: ctx.bootToken.value,
+            confirmationToken: ctx.bootToken.confirmationToken,
+            consoleOrigin: ctx.getConsoleOrigin(),
+            allowNonLoopbackAccess: ctx.allowNonLoopbackAccess === true,
+        });
+        if (failure) {
+            sendJson(res, failure.status, {
+                ok: false,
+                error: { code: failure.code, message: failure.message },
+            });
+            return true;
+        }
+        if (method === "POST" && pathname === "/api/operator/v1/night-aux-ticker") {
+            await handleNightAuxTickerPost(req, res, ctx);
+            return true;
+        }
+        // Allow other operator POSTs only under known routes; unknown → 404
+        sendJson(res, 404, {
+            ok: false,
+            error: {
+                code: "NOT_FOUND",
+                message: `unknown mutation route: ${pathname}`,
+            },
+        });
+        return true;
+    }
+    sendJson(res, 404, { error: "Not found" });
+    return true;
+}
+export async function handleConsoleRequest(req, res, ctx) {
+    const method = (req.method ?? "GET").toUpperCase();
+    const pathname = decodeURIComponent(new URL(req.url ?? "/", "http://localhost").pathname);
+    if (method === "GET" && pathname === "/api/health") {
+        await handleConsoleHealthRequest(req, res, ctx);
+        return true;
+    }
+    const handled = await handleConsoleOperatorRequest(req, res, ctx);
+    if (handled)
+        return true;
+    if (pathname.startsWith("/api/")) {
+        sendJson(res, 404, { error: "Not found" });
+        return true;
+    }
+    return false;
+}