@tea-agent/loop-agent 0.40.0-next.4 → 0.40.0-next.5

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) {
@@ -245,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) {
@@ -453,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;
@@ -517,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

@@ -119,12 +119,12 @@ 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) {