@tea-agent/loop-agent 0.39.0-beta.0 → 0.39.0-beta.10

package/dist/worker/console/routes.js

@@ -3,10 +3,12 @@ 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 { probePiReadiness } from "./pi-readiness.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";
+import { pickNativeWorkspaceDirectory } from "./native-directory-picker.js";
 export function sendJson(res, status, body, extraHeaders) {
     const payload = JSON.stringify(body);
     res.writeHead(status, {
@@ -38,6 +40,10 @@ function contentTypeFor(pathname) {
     return "application/octet-stream";
 }
 async function readJsonBody(req, maxBytes = 10 * 1024 * 1024) {
+    // Body pre-read by the multi-workspace dispatcher (workspaceId resolution).
+    const preRead = req.__preReadBody;
+    if (preRead !== undefined)
+        return preRead;
     const chunks = [];
     let total = 0;
     for await (const chunk of req) {
@@ -67,6 +73,7 @@ export async function handleConsoleHealthRequest(_req, res, ctx) {
             piReadiness: ctx.operator?.getReadiness().state ?? "setup-required",
             inspectReady: ctx.inspect.ready,
             routes: ROUTES,
+            consoleInstanceId: ctx.consoleInstanceId,
         }));
     }
     catch {
@@ -77,6 +84,7 @@ export async function handleConsoleHealthRequest(_req, res, ctx) {
             repoFingerprint: "unavailable",
             packageName: "unknown",
             packageVersion: "0.0.0",
+            consoleInstanceId: ctx.consoleInstanceId,
             piReadiness: ctx.operator?.getReadiness().state ?? "setup-required",
             inspect: {
                 ready: ctx.inspect.ready,
@@ -116,6 +124,7 @@ async function handleRecoveryCandidates(_req, res, ctx, url) {
 }
 async function handleSessionPing(req, res, ctx) {
     const failure = evaluateMutationGate(req, {
+        cookieName: ctx.bootToken.cookieName,
         bootToken: ctx.bootToken.value,
         confirmationToken: ctx.bootToken.confirmationToken,
         consoleOrigin: ctx.getConsoleOrigin(),
@@ -130,6 +139,16 @@ async function handleSessionPing(req, res, ctx) {
     }
     sendJson(res, 200, { ok: true, pong: true });
 }
+/**
+ * Actions the inspect-scoped mutation token may dispatch. Deliberately
+ * minimal: the experimental prompt-override rerun tab needs plan preflight +
+ * execution only. Everything else (task creation, runDag, reconcile, chat,
+ * worker actions…) requires the general Console token.
+ */
+export const INSPECT_MUTATION_ALLOWED_ACTIONS = new Set([
+    "dagRerunPlan",
+    "dagRerun",
+]);
 async function handleCreateOperation(req, res, ctx) {
     if (!ctx.operator) {
         sendJson(res, 503, {
@@ -141,12 +160,31 @@ async function handleCreateOperation(req, res, ctx) {
         });
         return;
     }
-    const failure = evaluateMutationGate(req, {
+    const generalGateContext = {
+        cookieName: ctx.bootToken.cookieName,
         bootToken: ctx.bootToken.value,
         confirmationToken: ctx.bootToken.confirmationToken,
         consoleOrigin: ctx.getConsoleOrigin(),
         allowNonLoopbackAccess: ctx.allowNonLoopbackAccess === true,
-    });
+    };
+    let failure = evaluateMutationGate(req, generalGateContext);
+    let inspectScoped = false;
+    if (failure && ctx.inspectBootToken) {
+        // Scoped /inspect credentials: try the inspect gate before failing. The
+        // general gate already rejected, so passing here only ever yields the
+        // allowlisted actions below — never general write capability.
+        const scopedFailure = evaluateMutationGate(req, {
+            cookieName: ctx.inspectBootToken.cookieName,
+            bootToken: ctx.inspectBootToken.value,
+            confirmationToken: ctx.inspectBootToken.confirmationToken,
+            consoleOrigin: ctx.getConsoleOrigin(),
+            allowNonLoopbackAccess: ctx.allowNonLoopbackAccess === true,
+        });
+        if (!scopedFailure) {
+            inspectScoped = true;
+            failure = undefined;
+        }
+    }
     if (failure) {
         sendJson(res, failure.status, {
             ok: false,
@@ -173,10 +211,21 @@ async function handleCreateOperation(req, res, ctx) {
         ? body.actionParams
         : {};
     const clientRequestId = typeof body.clientRequestId === "string" ? body.clientRequestId : undefined;
+    if (inspectScoped && !INSPECT_MUTATION_ALLOWED_ACTIONS.has(action)) {
+        sendJson(res, 403, {
+            ok: false,
+            error: {
+                code: "ACTION_NOT_IN_INSPECT_SCOPE",
+                message: `inspect-scoped token only allows: ${[...INSPECT_MUTATION_ALLOWED_ACTIONS].join(", ")}`,
+            },
+        });
+        return;
+    }
     const result = await dispatchOperatorAction(ctx.operator.actionContext, {
         action,
         actionParams,
         clientRequestId,
+        source: "human-ui",
     });
     sendJson(res, result.status, result.body);
 }
@@ -202,7 +251,35 @@ async function handleGetOperation(_req, res, ctx, operationId) {
         });
         return;
     }
-    sendJson(res, 200, { ok: true, operation: op });
+    sendJson(res, 200, {
+        ok: true,
+        workspaceId: ctx.workspace?.workspaceId,
+        operation: { ...op, workspaceId: ctx.workspace?.workspaceId },
+    });
+}
+/**
+ * GET /api/operator/v1/operations?workspaceId= — NEW per-workspace list route
+ * (multi-workspace foundation). Returns only the resolved Context's Operations
+ * and injects the owning workspaceId. operation-store.ts is unchanged.
+ */
+async function handleListOperations(_req, res, ctx) {
+    if (!ctx.operator) {
+        sendJson(res, 503, {
+            ok: false,
+            error: {
+                code: "INTERNAL_ERROR",
+                message: "operator runtime unavailable",
+            },
+        });
+        return;
+    }
+    const operations = await ctx.operator.operations.list();
+    sendJson(res, 200, {
+        ok: true,
+        schemaVersion: 1,
+        workspaceId: ctx.workspace?.workspaceId,
+        ops: operations.map((op) => ({ ...op, workspaceId: ctx.workspace?.workspaceId })),
+    });
 }
 async function handleOperationEvents(req, res, ctx, operationId) {
     if (!ctx.operator) {
@@ -410,6 +487,10 @@ export async function handleConsoleOperatorRequest(req, res, ctx) {
         await handleCreateOperation(req, res, ctx);
         return true;
     }
+    if (method === "GET" && pathname === "/api/operator/v1/operations") {
+        await handleListOperations(req, res, ctx);
+        return true;
+    }
     if (method === "GET" && pathname === "/api/operator/v1/night-aux-ticker") {
         await handleNightAuxTickerGet(req, res, ctx);
         return true;
@@ -428,6 +509,7 @@ export async function handleConsoleOperatorRequest(req, res, ctx) {
     }
     if (isMutationMethod(method)) {
         const failure = evaluateMutationGate(req, {
+            cookieName: ctx.bootToken.cookieName,
             bootToken: ctx.bootToken.value,
             confirmationToken: ctx.bootToken.confirmationToken,
             consoleOrigin: ctx.getConsoleOrigin(),
@@ -473,3 +555,273 @@ export async function handleConsoleRequest(req, res, ctx) {
     }
     return false;
 }
+export function createWorkspaceReadinessCache() {
+    const entries = new Map();
+    return {
+        get: (repoRoot) => entries.get(repoRoot),
+        set: (repoRoot, entry) => {
+            entries.set(repoRoot, entry);
+        },
+    };
+}
+const defaultWorkspaceReadinessCache = createWorkspaceReadinessCache();
+const READY_STATE_TTL_MS = 60_000;
+const NON_READY_STATE_TTL_MS = 15_000;
+function isCacheFresh(entry, now) {
+    const ttl = entry.state === "ready" ? READY_STATE_TTL_MS : NON_READY_STATE_TTL_MS;
+    return now - entry.probedAt < ttl;
+}
+/** Readiness placeholder for a never-probed workspace (AC-006): the list is
+ *  still returned immediately with a pending marker, refreshed by the
+ *  background probe. */
+function pendingReadinessSummary(inspectReady) {
+    return {
+        state: "pending",
+        summary: `pi=pending; inspect=${inspectReady ? "ready" : "unavailable"}`,
+    };
+}
+/**
+ * Process-level Workspace Registry HTTP surface (2026-08-22 multi-workspace
+ * foundation):
+ *   GET    /api/operator/v1/workspaces             — visible list
+ *   POST   /api/operator/v1/workspaces/pick        — host native folder chooser
+ *   POST   /api/operator/v1/workspaces             — body { "name": "<label>",
+ *                                                     "directoryPath": "<dir>" }
+ *   DELETE /api/operator/v1/workspaces/:workspaceId — soft remove (restore on re-add)
+ *
+ * POST/DELETE are mutations and pass the Console mutation gate. GET carries no
+ * workspace selection parameter.
+ *
+ * AC-006 (2026-08-23): GET is NON-BLOCKING — registry + process-level
+ * readiness cache answer immediately (first sight may be a pending
+ * placeholder); probes refresh the cache in the background for subsequent
+ * requests. A hanging probe can never delay the 200 list.
+ */
+export async function handleWorkspaceRoutes(req, res, registry, deps, url, pathname, method, readinessDeps) {
+    if (method === "GET" && pathname === "/api/operator/v1/workspaces") {
+        const records = await registry.listVisible();
+        const inspectReady = readinessDeps.inspectReady;
+        const readinessCache = readinessDeps.readinessCache ?? defaultWorkspaceReadinessCache;
+        const workspaces = records.map((record) => {
+            const cached = readinessCache.get(record.repoRoot);
+            return {
+                workspaceId: record.workspaceId,
+                name: record.name,
+                displayPath: record.displayPath,
+                repoFingerprint: record.repoFingerprint,
+                createdAt: record.createdAt,
+                lastAccessedAt: record.lastAccessedAt,
+                readiness: cached
+                    ? {
+                        state: cached.state,
+                        summary: `pi=${cached.state}; inspect=${inspectReady ? "ready" : "unavailable"}`,
+                    }
+                    : pendingReadinessSummary(inspectReady),
+            };
+        });
+        // Respond FIRST, then refresh readiness in the background (AC-006).
+        sendJson(res, 200, {
+            ok: true,
+            schemaVersion: 1,
+            workspaces,
+        });
+        void Promise.all(records.map(async (record) => {
+            const cached = readinessCache.get(record.repoRoot);
+            if (cached && isCacheFresh(cached, Date.now()))
+                return;
+            let state;
+            try {
+                const report = await probePiReadiness({
+                    override: deps.piReadinessProbe,
+                    repoRoot: record.repoRoot,
+                });
+                state = report.state;
+            }
+            catch {
+                state = "setup-required";
+            }
+            readinessCache.set(record.repoRoot, {
+                state,
+                probedAt: Date.now(),
+            });
+        })).catch(() => undefined);
+        return;
+    }
+    if (method === "POST" && pathname === "/api/operator/v1/workspaces/pick") {
+        const failure = evaluateMutationGate(req, {
+            cookieName: deps.bootToken.cookieName,
+            bootToken: deps.bootToken.value,
+            confirmationToken: deps.bootToken.confirmationToken,
+            consoleOrigin: deps.getConsoleOrigin(),
+            allowNonLoopbackAccess: deps.allowNonLoopbackAccess,
+        });
+        if (failure) {
+            sendJson(res, failure.status, {
+                ok: false,
+                error: { code: failure.code, message: failure.message },
+            });
+            return;
+        }
+        if (deps.allowNonLoopbackAccess) {
+            sendJson(res, 409, {
+                ok: false,
+                error: {
+                    code: "NATIVE_PICKER_UNAVAILABLE",
+                    message: "原生目录选择仅在本机回环地址启动的 Console 中可用。",
+                },
+            });
+            return;
+        }
+        const abortController = new AbortController();
+        const abort = () => abortController.abort();
+        req.once("aborted", abort);
+        res.once("close", abort);
+        try {
+            const directoryPath = await (deps.pickDirectory ?? pickNativeWorkspaceDirectory)(abortController.signal);
+            if (!res.writableEnded && !abortController.signal.aborted) {
+                sendJson(res, 200, { ok: true, directoryPath });
+            }
+        }
+        catch (error) {
+            if (!res.writableEnded && !abortController.signal.aborted) {
+                sendJson(res, 500, {
+                    ok: false,
+                    error: {
+                        code: "DIRECTORY_PICKER_FAILED",
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                });
+            }
+        }
+        finally {
+            req.off("aborted", abort);
+            res.off("close", abort);
+        }
+        return;
+    }
+    if (method === "POST" && pathname === "/api/operator/v1/workspaces") {
+        const failure = evaluateMutationGate(req, {
+            cookieName: deps.bootToken.cookieName,
+            bootToken: deps.bootToken.value,
+            confirmationToken: deps.bootToken.confirmationToken,
+            consoleOrigin: deps.getConsoleOrigin(),
+            allowNonLoopbackAccess: deps.allowNonLoopbackAccess,
+        });
+        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 directoryPath = typeof body.directoryPath === "string"
+            ? body.directoryPath
+            : typeof body.path === "string"
+                ? body.path
+                : "";
+        if (!directoryPath.trim()) {
+            sendJson(res, 400, {
+                ok: false,
+                error: {
+                    code: "INVALID_INPUT",
+                    message: "directoryPath (string) is required",
+                },
+            });
+            return;
+        }
+        if (body.name !== undefined &&
+            (typeof body.name !== "string" || !body.name.trim())) {
+            sendJson(res, 400, {
+                ok: false,
+                error: {
+                    code: "INVALID_INPUT",
+                    message: "name must be a non-empty string when provided",
+                },
+            });
+            return;
+        }
+        const name = typeof body.name === "string" ? body.name : undefined;
+        const result = await registry.add(directoryPath, name ? { name } : {});
+        if (!result.ok) {
+            const status = result.code === "DUPLICATE"
+                ? 409
+                : result.code === "INVALID_PATH"
+                    ? 400
+                    : 400;
+            sendJson(res, status, {
+                ok: false,
+                error: {
+                    code: result.code,
+                    message: result.message,
+                },
+            });
+            return;
+        }
+        const record = result.record;
+        sendJson(res, 201, {
+            ok: true,
+            workspace: {
+                workspaceId: record.workspaceId,
+                name: record.name,
+                displayPath: record.displayPath,
+                repoFingerprint: record.repoFingerprint,
+                createdAt: record.createdAt,
+                lastAccessedAt: record.lastAccessedAt,
+                readiness: {
+                    state: "setup-required",
+                    summary: `pi=unknown; inspect=${readinessDeps.inspectReady ? "ready" : "unavailable"}`,
+                },
+            },
+        });
+        return;
+    }
+    const removeMatch = pathname.match(/^\/api\/operator\/v1\/workspaces\/([^/]+)$/);
+    if (method === "DELETE" && removeMatch) {
+        const failure = evaluateMutationGate(req, {
+            cookieName: deps.bootToken.cookieName,
+            bootToken: deps.bootToken.value,
+            confirmationToken: deps.bootToken.confirmationToken,
+            consoleOrigin: deps.getConsoleOrigin(),
+            allowNonLoopbackAccess: deps.allowNonLoopbackAccess,
+        });
+        if (failure) {
+            sendJson(res, failure.status, {
+                ok: false,
+                error: { code: failure.code, message: failure.message },
+            });
+            return;
+        }
+        const workspaceId = decodeURIComponent(removeMatch[1]);
+        const removed = await registry.remove(workspaceId);
+        if (!removed) {
+            sendJson(res, 404, {
+                ok: false,
+                error: {
+                    code: "WORKSPACE_NOT_FOUND",
+                    message: `unknown workspace: ${workspaceId}`,
+                },
+            });
+            return;
+        }
+        sendJson(res, 200, { ok: true, workspaceId, removed: true });
+        return;
+    }
+    sendJson(res, 404, {
+        ok: false,
+        error: { code: "NOT_FOUND", message: `unknown workspace route: ${pathname}` },
+    });
+}

package/dist/worker/console/security.js

@@ -1,24 +1,78 @@
-import { randomBytes, timingSafeEqual } from "node:crypto";
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
 import { isLoopbackHost } from "./loopback.js";
+/** Prefix for instance-scoped Cookie names; not a lookup name. */
 export const BOOT_CAPABILITY_COOKIE = "loop_console_capability";
 /** Custom mutation confirmation header (design §9). JS-readable; not the HttpOnly boot cookie. */
 export const CONFIRMATION_TOKEN_HEADER = "x-loop-console-confirmation";
-/** Issue per-process unguessable boot capability + confirmation tokens. */
-export function issueBootCapabilityToken() {
+function normalizeInstanceScope(scope) {
+    const repoFingerprint = scope.repoFingerprint.trim();
+    if (!repoFingerprint) {
+        throw new Error("console instance scope requires a non-empty repoFingerprint");
+    }
+    const bindHost = scope.bindHost.trim();
+    if (!bindHost) {
+        throw new Error("console instance scope requires a non-empty bindHost");
+    }
+    if (!Number.isInteger(scope.configuredPort) || scope.configuredPort < 0) {
+        throw new Error(`console instance scope configuredPort must be an integer >= 0, got ${String(scope.configuredPort)}`);
+    }
+    const instanceNonce = scope.instanceNonce?.trim();
+    if (scope.configuredPort === 0) {
+        if (!instanceNonce) {
+            throw new Error("console instance scope requires a non-empty instanceNonce when configuredPort is 0");
+        }
+        return {
+            repoFingerprint,
+            bindHost,
+            configuredPort: 0,
+            instanceNonce,
+        };
+    }
+    return {
+        repoFingerprint,
+        bindHost,
+        configuredPort: scope.configuredPort,
+    };
+}
+/** Deterministic Cookie name for one Console instance; never includes repo path or token. */
+export function deriveBootCapabilityCookieName(scope, variant) {
+    const normalized = normalizeInstanceScope(scope);
+    const digest = createHash("sha256")
+        .update("loop-console-capability-v1\0", "utf8")
+        .update(normalized.repoFingerprint, "utf8")
+        .update("\0", "utf8")
+        .update(normalized.bindHost, "utf8")
+        .update("\0", "utf8")
+        .update(String(normalized.configuredPort), "utf8")
+        .update("\0", "utf8")
+        .update(normalized.instanceNonce ?? "", "utf8")
+        .update("\0", "utf8")
+        .update(variant ?? "", "utf8")
+        .digest("hex")
+        .slice(0, 32);
+    return `${BOOT_CAPABILITY_COOKIE}_${digest}`;
+}
+/** Issue per-process unguessable boot capability + confirmation tokens.
+ *  `variant` (e.g. "inspect") derives a separate cookie name so scoped
+ *  credentials cannot be replayed against the general mutation surface. */
+export function issueBootCapabilityToken(scope, options = {}) {
+    const cookieName = deriveBootCapabilityCookieName(scope, options.variant);
     const value = randomBytes(32).toString("base64url");
     const confirmationToken = randomBytes(32).toString("base64url");
     const setCookieHeader = [
-        `${BOOT_CAPABILITY_COOKIE}=${value}`,
+        `${cookieName}=${value}`,
         "HttpOnly",
         "SameSite=Strict",
         "Path=/",
     ].join("; ");
-    return { value, setCookieHeader, confirmationToken };
+    return { cookieName, value, setCookieHeader, confirmationToken };
 }
-/** Inject confirmation token into HTML so the SPA can send the mutation header. */
-export function injectConfirmationTokenScript(html, confirmationToken) {
+/** Inject confirmation token into HTML so the SPA can send the mutation
+ *  header. `varName` separates the general Console token from the scoped
+ *  inspect token on the read-only /inspect surface. */
+export function injectConfirmationTokenScript(html, confirmationToken, varName = "__CONSOLE_CONFIRMATION_TOKEN__") {
     const source = typeof html === "string" ? html : html.toString("utf8");
-    const script = `<script>window.__CONSOLE_CONFIRMATION_TOKEN__=${JSON.stringify(confirmationToken)};</script>`;
+    const script = `<script>window.${varName}=${JSON.stringify(confirmationToken)};</script>`;
     if (source.includes("</head>")) {
         return Buffer.from(source.replace("</head>", `${script}</head>`), "utf8");
     }
@@ -65,16 +119,16 @@ function safeEqualToken(a, b) {
 function loopbackOriginMatches(origin, consoleOrigin) {
     if (origin === consoleOrigin)
         return true;
-    const parseLoopback = (value) => {
+    const parseLoopbackPort = (value) => {
         const match = /^http:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/i.exec(value);
-        return match ? `${match[1].toLowerCase()}${match[2] ?? ""}` : null;
+        return match ? (match[2] ?? ":80") : null;
     };
-    const originKey = parseLoopback(origin);
-    const consoleKey = parseLoopback(consoleOrigin);
+    const originKey = parseLoopbackPort(origin);
+    const consoleKey = parseLoopbackPort(consoleOrigin);
     return originKey !== null && consoleKey !== null && originKey === consoleKey;
 }
 export function evaluateMutationGate(req, ctx) {
-    const cookieToken = parseCookieHeader(req.headers.cookie, BOOT_CAPABILITY_COOKIE);
+    const cookieToken = parseCookieHeader(req.headers.cookie, ctx.cookieName);
     if (!cookieToken) {
         return {
             status: 403,