@tea-agent/loop-agent 0.18.1 → 0.20.0

package/dist/worker/console/operator-selection.js

@@ -0,0 +1,92 @@
+function segment(value) {
+    return encodeURIComponent(value);
+}
+function nonEmpty(value) {
+    return typeof value === "string" && value.length > 0;
+}
+export function encodeInspectHash(selection) {
+    switch (selection.kind) {
+        case "feature":
+            return `#/feature/${segment(selection.featureId)}`;
+        case "feature-task":
+            return `#/feature/${segment(selection.featureId)}/task/${segment(selection.taskId)}`;
+        case "legacy-task":
+            return `#/task/${segment(selection.taskId)}`;
+        case "dag-run":
+            // Inspect currently owns DAG-level routing. nodeId remains URL-adjacent
+            // selection state until the static router explicitly supports it.
+            return `#/dag/${segment(selection.dagRunId)}`;
+        case "worker-run":
+            return `#/run/${segment(selection.workerRunId)}`;
+        case "batch":
+            return `#/batch/${segment(selection.batchRunId)}`;
+    }
+}
+export function buildInspectPath(selection) {
+    return `/inspect/${selection ? encodeInspectHash(selection) : "#/"}`;
+}
+export function buildInspectUrl(origin, selection) {
+    const base = origin.trim().replace(/\/+$/, "");
+    if (!base)
+        throw new Error("buildInspectUrl: origin is required");
+    return `${base}${buildInspectPath(selection)}`;
+}
+function decodeSegment(value) {
+    if (!nonEmpty(value))
+        return null;
+    try {
+        const decoded = decodeURIComponent(value);
+        return decoded ? decoded : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function decodeInspectHash(hash) {
+    const normalized = hash.startsWith("#") ? hash.slice(1) : hash;
+    const parts = normalized.split("/").filter(Boolean);
+    if (parts.length === 0)
+        return null;
+    const [kind, first, third, fourth] = parts;
+    const id = decodeSegment(first);
+    if (!id)
+        return null;
+    if (kind === "feature" && parts.length === 2) {
+        return { kind: "feature", featureId: id };
+    }
+    if (kind === "feature" && parts.length === 4 && third === "task") {
+        const taskId = decodeSegment(fourth);
+        return taskId ? { kind: "feature-task", featureId: id, taskId } : null;
+    }
+    if (kind === "task" && parts.length === 2)
+        return { kind: "legacy-task", taskId: id };
+    if (kind === "dag" && parts.length === 2)
+        return { kind: "dag-run", dagRunId: id };
+    if (kind === "run" && parts.length === 2)
+        return { kind: "worker-run", workerRunId: id };
+    if (kind === "batch" && parts.length === 2)
+        return { kind: "batch", batchRunId: id };
+    return null;
+}
+export function selectionFromObserveLinkTarget(target) {
+    switch (target.kind) {
+        case "dag":
+            return { kind: "dag-run", dagRunId: target.dagRunId };
+        case "task":
+            return { kind: "legacy-task", taskId: target.taskId };
+        case "feature":
+            return { kind: "feature", featureId: target.featureId };
+        case "worker":
+            return { kind: "worker-run", workerRunId: target.workerRunId };
+        case "batch":
+            return { kind: "batch", batchRunId: target.batchRunId };
+    }
+}
+/** Canonicalize only the historical Console root hash shape. */
+export function normalizeLegacyConsoleDagHash(pathnameAndHash) {
+    const [pathname, hash = ""] = pathnameAndHash.split("#", 2);
+    if ((pathname === "/" || pathname === "") && /^\/dag\/[^/]+$/.test(hash)) {
+        return `/inspect/#${hash}`;
+    }
+    return pathnameAndHash;
+}

package/dist/worker/console/operator-surface-health.js

@@ -0,0 +1,23 @@
+import { deriveObserveRouteCapabilities, resolveObservePackageIdentity, } from "../observe/health.js";
+import { repoFingerprintV1 } from "./repo-fingerprint.js";
+export function buildOperatorSurfaceHealthV1(input) {
+    const { packageName, packageVersion } = resolveObservePackageIdentity();
+    const snapshotAvailable = input.routes.some((route) => route.method === "GET" && route.pattern.test("/api/snapshot"));
+    const eventStreamAvailable = input.routes.some((route) => route.method === "GET" && route.pattern.test("/api/events/stream"));
+    return {
+        schemaVersion: 1,
+        ok: true,
+        product: "loop-operator-console",
+        repoFingerprint: repoFingerprintV1(input.repoRoot),
+        packageName,
+        packageVersion,
+        piReadiness: input.piReadiness,
+        inspect: {
+            ready: input.inspectReady,
+            routeCapabilities: deriveObserveRouteCapabilities(input.routes),
+            snapshotAvailable,
+            eventStreamAvailable,
+        },
+        generatedAt: input.generatedAt ?? new Date().toISOString(),
+    };
+}

package/dist/worker/console/recovery-cta.js

@@ -38,9 +38,9 @@ const CTA = {
     },
     observeLink: {
         id: "observeLink",
-        label: "打开 Observe 深链",
+        label: "打开检视",
         action: "observeLink",
-        commandHint: "agent-worker observe serve --repo . --port 8787",
+        commandHint: "agent-worker console serve --repo . --port 8790",
     },
 };
 const MATRIX = {

package/dist/worker/console/routes.js

@@ -3,7 +3,8 @@ 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 { repoFingerprintV1 } from "./repo-fingerprint.js";
+import { buildOperatorSurfaceHealthV1 } from "./operator-surface-health.js";
+import { ROUTES } from "../observe/routes.js";
 import { evaluateMutationGate, injectConfirmationTokenScript, isMutationMethod, } from "./security.js";
 export function sendJson(res, status, body, extraHeaders) {
     const payload = JSON.stringify(body);
@@ -58,24 +59,33 @@ async function readJsonBody(req, maxBytes = 10 * 1024 * 1024) {
         throw new Error(`invalid JSON body: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-async function handleHealth(_req, res, ctx) {
-    let fingerprint;
+export async function handleConsoleHealthRequest(_req, res, ctx) {
     try {
-        fingerprint = repoFingerprintV1(ctx.repoRoot);
+        sendJson(res, 200, buildOperatorSurfaceHealthV1({
+            repoRoot: ctx.repoRoot,
+            piReadiness: ctx.operator?.getReadiness().state ?? "setup-required",
+            inspectReady: ctx.inspect.ready,
+            routes: ROUTES,
+        }));
     }
     catch {
-        fingerprint = "unavailable";
+        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(),
+        });
     }
-    const readiness = ctx.operator?.getReadiness();
-    sendJson(res, 200, {
-        ok: true,
-        product: "loop-operator-console",
-        productName: "Loop Operator Console",
-        repoRoot: ctx.repoRoot,
-        repoFingerprint: fingerprint,
-        piReadiness: readiness?.state ?? "setup-required",
-        generatedAt: new Date().toISOString(),
-    });
 }
 async function handleReadiness(_req, res, ctx) {
     const report = ctx.operator?.getReadiness();
@@ -93,6 +103,7 @@ async function handleSessionPing(req, res, ctx) {
         bootToken: ctx.bootToken.value,
         confirmationToken: ctx.bootToken.confirmationToken,
         consoleOrigin: ctx.getConsoleOrigin(),
+        allowNonLoopbackAccess: ctx.allowNonLoopbackAccess === true,
     });
     if (failure) {
         sendJson(res, failure.status, {
@@ -118,6 +129,7 @@ async function handleCreateOperation(req, res, ctx) {
         bootToken: ctx.bootToken.value,
         confirmationToken: ctx.bootToken.confirmationToken,
         consoleOrigin: ctx.getConsoleOrigin(),
+        allowNonLoopbackAccess: ctx.allowNonLoopbackAccess === true,
     });
     if (failure) {
         sendJson(res, failure.status, {
@@ -304,13 +316,13 @@ export async function serveConsoleStatic(req, res, ctx) {
     res.writeHead(200, headers);
     res.end(content);
 }
-export async function handleConsoleRequest(req, res, ctx) {
+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 (method === "GET" && pathname === "/api/health") {
-        await handleHealth(req, res, ctx);
-        return true;
+    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);
@@ -342,6 +354,7 @@ export async function handleConsoleRequest(req, res, ctx) {
             bootToken: ctx.bootToken.value,
             confirmationToken: ctx.bootToken.confirmationToken,
             consoleOrigin: ctx.getConsoleOrigin(),
+            allowNonLoopbackAccess: ctx.allowNonLoopbackAccess === true,
         });
         if (failure) {
             sendJson(res, failure.status, {
@@ -360,6 +373,19 @@ export async function handleConsoleRequest(req, res, ctx) {
         });
         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;

package/dist/worker/console/security.js

@@ -51,8 +51,8 @@ function safeEqualToken(a, b) {
 }
 /**
  * Minimum mutation challenge (design §9):
- * cookie boot token AND custom confirmation header/token + Host loopback +
- * Origin matches Console + Sec-Fetch-Site not cross-site.
+ * cookie boot token AND custom confirmation header/token + Host/Origin checks +
+ * Sec-Fetch-Site not cross-site.
  */
 export function evaluateMutationGate(req, ctx) {
     const cookieToken = parseCookieHeader(req.headers.cookie, BOOT_CAPABILITY_COOKIE);
@@ -92,7 +92,16 @@ export function evaluateMutationGate(req, ctx) {
     }
     const hostHeader = req.headers.host ?? "";
     const hostOnly = hostHeader.split(":")[0] ?? "";
-    if (!isLoopbackHost(hostOnly)) {
+    if (ctx.allowNonLoopbackAccess) {
+        if (!hostHeader.trim()) {
+            return {
+                status: 403,
+                code: "host-not-loopback",
+                message: "Host header is required for non-loopback Console binds",
+            };
+        }
+    }
+    else if (!isLoopbackHost(hostOnly)) {
         return {
             status: 403,
             code: "host-not-loopback",
@@ -100,7 +109,23 @@ export function evaluateMutationGate(req, ctx) {
         };
     }
     const origin = req.headers.origin;
-    if (typeof origin !== "string" ||
+    if (ctx.allowNonLoopbackAccess) {
+        const expectedFromHost = hostHeader.trim()
+            ? `http://${hostHeader.trim()}`
+            : "";
+        const originOk = typeof origin === "string" &&
+            origin.length > 0 &&
+            (origin === ctx.consoleOrigin ||
+                (Boolean(expectedFromHost) && origin === expectedFromHost));
+        if (!originOk) {
+            return {
+                status: 403,
+                code: "origin-mismatch",
+                message: "Origin does not match Console access URL",
+            };
+        }
+    }
+    else if (typeof origin !== "string" ||
         origin.length === 0 ||
         origin !== ctx.consoleOrigin) {
         return {

package/dist/worker/console/server.js

@@ -1,4 +1,5 @@
 import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
 import { createServer } from "node:http";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -12,25 +13,35 @@ import { isLoopbackHost } from "./loopback.js";
 import { createOperationEventStore, } from "./operation-sse.js";
 import { OperationStore } from "./operation-store.js";
 import { probePiReadiness, } from "./pi-readiness.js";
-import { handleConsoleRequest, serveConsoleStatic, } from "./routes.js";
+import { handleConsoleHealthRequest, handleConsoleOperatorRequest, sendJson, serveConsoleStatic, } from "./routes.js";
 import { issueBootCapabilityToken } from "./security.js";
 import { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
+import { deriveObserveRouteCapabilities } from "../observe/health.js";
+import { createObserveRouteContext, defaultObserveStaticDir, handleMatchedObserveRoute, matchObserveGetRoute, ROUTES, serveObserveStatic, } from "../observe/routes.js";
 /** Built static assets live next to the compiled server under dist/worker/console/static. */
 export function defaultConsoleStaticDir(fromFileUrl = import.meta.url) {
     return path.join(path.dirname(fileURLToPath(fromFileUrl)), "static");
 }
 /**
  * Create Loop Operator Console HTTP server.
- * Non-loopback host throws before listen (fail closed).
+ * Default bind is loopback; non-loopback hosts warn and stay allowed for LAN,
+ * matching Observe serve (mutations still require cookie + confirmation + Origin).
  */
 export async function createConsoleServer(options) {
     const host = options.host ?? "127.0.0.1";
-    if (!isLoopbackHost(host)) {
-        throw new Error(`console serve: non-loopback host "${host}" is not allowed (fail closed; use 127.0.0.1 or localhost)`);
+    const loopbackBind = isLoopbackHost(host);
+    if (!loopbackBind) {
+        process.stderr.write(`console serve: binding non-loopback host ${host} (Operator mutations enabled; no network auth — expose only on trusted networks)\n`);
     }
     const repoRoot = path.resolve(options.repoRoot);
     const port = options.port ?? 8790;
+    const debug = options.debug === true;
+    const keepAliveTimeoutMs = options.keepAliveTimeoutMs ?? 65_000;
     const staticDir = options.staticDir ?? defaultConsoleStaticDir();
+    const inspectStaticDir = options.inspectStaticDir ?? defaultObserveStaticDir();
+    const observeRouteContext = createObserveRouteContext(repoRoot, {
+        staticDir: inspectStaticDir,
+    });
     const bootToken = issueBootCapabilityToken();
     const operatorSessionId = `sess_${randomBytes(16).toString("hex")}`;
     const appData = openConsoleAppData({
@@ -83,6 +94,7 @@ export async function createConsoleServer(options) {
         refreshReadiness,
         observeBaseUrl: options.observeBaseUrl,
         fetchImpl: options.fetchImpl,
+        getConsoleOrigin: () => `http://${boundHost}:${boundPort}`,
     };
     let boundHost = host;
     let boundPort = port;
@@ -92,6 +104,11 @@ export async function createConsoleServer(options) {
         staticDir,
         bootToken,
         getConsoleOrigin,
+        allowNonLoopbackAccess: !loopbackBind,
+        inspect: {
+            ready: existsSync(path.join(inspectStaticDir, "index.html")),
+            routeCapabilities: deriveObserveRouteCapabilities(ROUTES),
+        },
         operator: {
             actionContext,
             operations,
@@ -101,6 +118,21 @@ export async function createConsoleServer(options) {
     };
     return new Promise((resolve, reject) => {
         const server = createServer((req, res) => {
+            const startedAt = Date.now();
+            if (debug) {
+                let logged = false;
+                const onceLog = (note) => {
+                    if (logged)
+                        return;
+                    logged = true;
+                    logConsoleRequest(req, res, startedAt, note);
+                };
+                res.on("finish", () => onceLog());
+                res.on("close", () => {
+                    if (!res.writableFinished)
+                        onceLog("aborted");
+                });
+            }
             void dispatch(req, res).catch((error) => {
                 if (!res.headersSent) {
                     const payload = JSON.stringify({
@@ -114,13 +146,54 @@ export async function createConsoleServer(options) {
                 }
             });
         });
+        server.keepAliveTimeout = keepAliveTimeoutMs;
+        server.headersTimeout = keepAliveTimeoutMs + 5_000;
+        server.requestTimeout = 0;
+        server.on("connection", (socket) => {
+            socket.on("error", () => {
+                // Ignore client resets while retaining one listener per connection.
+            });
+        });
+        server.on("clientError", (err, socket) => {
+            if (debug) {
+                process.stderr.write(`[console] ${new Date().toISOString()} clientError ${err.message}\n`);
+            }
+            if (!socket.destroyed) {
+                socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+            }
+        });
         async function dispatch(req, res) {
             // Refresh readiness pointer on each request surface
             actionContext.readiness = getReadiness();
-            const handled = await handleConsoleRequest(req, res, routeContext);
-            if (!handled) {
-                await serveConsoleStatic(req, res, routeContext);
+            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, routeContext);
+                return;
             }
+            if (pathname.startsWith("/api/operator/v1/") ||
+                pathname.startsWith("/api/session/")) {
+                await handleConsoleOperatorRequest(req, res, routeContext);
+                return;
+            }
+            if (method === "GET" && pathname.startsWith("/api/")) {
+                const match = matchObserveGetRoute(pathname);
+                if (match) {
+                    await handleMatchedObserveRoute(req, res, match, observeRouteContext);
+                    return;
+                }
+            }
+            if (pathname.startsWith("/inspect")) {
+                await serveObserveStatic(req, res, inspectStaticDir, {
+                    urlPrefix: "/inspect",
+                });
+                return;
+            }
+            if (pathname.startsWith("/api/")) {
+                sendJson(res, 404, { error: "Not found" });
+                return;
+            }
+            await serveConsoleStatic(req, res, routeContext);
         }
         server.on("error", reject);
         server.listen(port, host, () => {
@@ -132,7 +205,12 @@ export async function createConsoleServer(options) {
             boundHost = host;
             boundPort = addr.port;
             const url = `http://${host}:${addr.port}`;
-            process.stderr.write(`[console] Loop Operator Console listening on ${url} (loopback only)\n`);
+            if (debug) {
+                process.stderr.write(`[console] debug logging enabled; keepAliveTimeout=${keepAliveTimeoutMs}ms\n`);
+            }
+            process.stderr.write(`[console] Loop Operator Console listening on ${url}${loopbackBind
+                ? " (loopback)"
+                : " (non-loopback; trusted networks only)"}\n`);
             resolve({
                 url,
                 host,
@@ -149,6 +227,26 @@ export async function createConsoleServer(options) {
         });
     });
 }
+function requestSource(req) {
+    const forwarded = req.headers["x-forwarded-for"];
+    if (typeof forwarded === "string" && forwarded.trim()) {
+        return forwarded.split(",")[0]?.trim() || forwarded.trim();
+    }
+    if (Array.isArray(forwarded) && forwarded[0]) {
+        return forwarded[0].split(",")[0]?.trim() || forwarded[0];
+    }
+    const realIp = req.headers["x-real-ip"];
+    if (typeof realIp === "string" && realIp.trim()) {
+        return realIp.trim();
+    }
+    return req.socket.remoteAddress ?? "-";
+}
+function logConsoleRequest(req, res, startedAt, note) {
+    const ms = Date.now() - startedAt;
+    const ua = String(req.headers["user-agent"] ?? "-").slice(0, 120);
+    const suffix = note ? ` ${note}` : "";
+    process.stderr.write(`[console] ${new Date().toISOString()} ${req.method ?? "?"} ${req.url ?? "/"} ${res.statusCode} ${ms}ms from=${requestSource(req)} ua=${JSON.stringify(ua)}${suffix}\n`);
+}
 /** Test helper: replace readiness report in-process. */
 export function setConsoleReadinessForTests(server, report) {
     if (!server.getReadiness)