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

package/dist/worker/console/static-src/pages/tasks/run-panel-progress.js

@@ -0,0 +1,110 @@
+/**
+ * Pure projection from a DAG run detail payload (GET /api/dag-runs/:id) into
+ * the structured run progress shown on the wizard RunPanel: node counts,
+ * current node + elapsed time, failure pointer, and stall signal. The panel
+ * used to show only a raw SSE log tail — node/phase information drowned in
+ * log noise during 20-40 minute runs.
+ */
+export function classifyRunProgressNodeStatus(raw) {
+    const status = (raw ?? "").trim().toLowerCase();
+    if (!status)
+        return "pending";
+    if (status.includes("running") || status === "in_progress" || status === "active") {
+        return "running";
+    }
+    if (status.includes("fail") || status.includes("error") || status === "blocked") {
+        return "failed";
+    }
+    if (status.includes("finish") ||
+        status.includes("success") ||
+        status === "done" ||
+        status === "ok") {
+        return "finished";
+    }
+    if (status.includes("skip"))
+        return "skipped";
+    return "pending";
+}
+function toProgressNode(node) {
+    const nodeId = String(node.nodeId ?? node.id ?? "").trim();
+    return {
+        nodeId,
+        label: String((node.label ?? node.name ?? nodeId) || "未命名节点"),
+        status: String(node.status ?? ""),
+        rank: typeof node.rank === "string" ? node.rank : undefined,
+        startedAt: typeof node.startedAt === "string" ? node.startedAt : undefined,
+        durationMs: typeof node.durationMs === "number" ? node.durationMs : undefined,
+        errorPreview: typeof node.errorPreview === "string" ? node.errorPreview : undefined,
+    };
+}
+function elapsedSince(iso, now) {
+    if (!iso)
+        return null;
+    const started = Date.parse(iso);
+    if (Number.isNaN(started))
+        return null;
+    const elapsed = now - started;
+    return elapsed >= 0 ? elapsed : null;
+}
+export function summarizeRunProgress(dag, now = Date.now()) {
+    if (!dag) {
+        return {
+            total: 0,
+            finished: 0,
+            running: null,
+            failed: null,
+            terminal: false,
+            effectiveStatus: null,
+            stalled: false,
+            currentNodeElapsedMs: null,
+            runElapsedMs: null,
+        };
+    }
+    const rawNodes = Array.isArray(dag.nodes) ? dag.nodes : [];
+    const nodes = rawNodes.map(toProgressNode);
+    const classes = nodes.map((node) => classifyRunProgressNodeStatus(node.status));
+    const finished = classes.filter((cls) => cls === "finished" || cls === "skipped").length;
+    const runningIndex = classes.indexOf("running");
+    const running = runningIndex >= 0 ? nodes[runningIndex] : null;
+    const failedIndex = classes.indexOf("failed");
+    const failed = failedIndex >= 0 ? nodes[failedIndex] : null;
+    const effectiveStatus = String(dag.effectiveStatus ??
+        dag.status ??
+        "").toLowerCase();
+    const terminal = TERMINAL_RUN_PROGRESS_STATUSES.has(effectiveStatus);
+    const runStartedAt = typeof dag.startedAt === "string" ? dag.startedAt : undefined;
+    const runDurationMs = typeof dag.durationMs === "number" ? dag.durationMs : undefined;
+    return {
+        total: nodes.length,
+        finished,
+        running,
+        failed,
+        terminal,
+        effectiveStatus: effectiveStatus || null,
+        stalled: effectiveStatus === "running-suspected-stall",
+        currentNodeElapsedMs: running?.durationMs ?? elapsedSince(running?.startedAt, now),
+        runElapsedMs: terminal
+            ? (runDurationMs ?? elapsedSince(runStartedAt, now))
+            : elapsedSince(runStartedAt, now),
+    };
+}
+const TERMINAL_RUN_PROGRESS_STATUSES = new Set([
+    "finished",
+    "failed",
+    "partial_failed",
+    "superseded",
+    "abandoned",
+]);
+export function formatDurationMs(ms) {
+    if (ms == null || !Number.isFinite(ms) || ms < 0)
+        return "—";
+    const totalSeconds = Math.floor(ms / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    if (hours > 0)
+        return `${hours} 时 ${minutes} 分`;
+    if (minutes > 0)
+        return `${minutes} 分 ${seconds} 秒`;
+    return `${seconds} 秒`;
+}

package/dist/worker/console/static-src/shell/useWorkspaces.js

@@ -0,0 +1,299 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { confirmationToken } from "../operator-chat/format.js";
+import { describeMutationGateFailure, isMutationGateFailureCode, } from "../operator-chat/mutation-gate.js";
+/**
+ * Multi-workspace registry state (2026-08-23, AC-001/AC-003).
+ *
+ * Consumes the process-level GET/POST/DELETE /api/operator/v1/workspaces
+ * surface. POST/DELETE pass the Console mutation-gate confirmation token.
+ * The selected workspaceId is remembered in localStorage and validated
+ * against the visible list. A stale local preference falls back to the first
+ * visible workspace; an explicit unknown URL id remains fail-closed in the
+ * route layer.
+ *
+ * The network/state machine lives in createWorkspacesController (headless,
+ * node-testable); useWorkspaces is a thin React subscription wrapper.
+ */
+export const ACTIVE_WORKSPACE_STORAGE_KEY = "loop-console.operator-shell.active-workspace.v1";
+export function readStoredWorkspaceId(storage) {
+    try {
+        const raw = storage?.getItem(ACTIVE_WORKSPACE_STORAGE_KEY)?.trim();
+        return raw || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function rememberWorkspaceId(workspaceId, storage) {
+    try {
+        if (workspaceId)
+            storage?.setItem(ACTIVE_WORKSPACE_STORAGE_KEY, workspaceId);
+        else
+            storage?.removeItem(ACTIVE_WORKSPACE_STORAGE_KEY);
+    }
+    catch {
+        /* localStorage unavailable: in-memory selection still works. */
+    }
+}
+export function pickDefaultWorkspaceId(workspaces, storedId) {
+    if (storedId) {
+        if (workspaces.some((w) => w.workspaceId === storedId))
+            return { status: "ok", workspaceId: storedId };
+        return { status: "ok", workspaceId: workspaces[0]?.workspaceId ?? null };
+    }
+    return { status: "ok", workspaceId: workspaces[0]?.workspaceId ?? null };
+}
+export function describeWorkspaceAddError(status, code, message) {
+    if (status === 409 || code === "DUPLICATE") {
+        return (message ||
+            "该目录（或等价路径）已存在为 Workspace：请直接选择既有条目，或更换其他真实目录。");
+    }
+    if (status === 400 || code === "INVALID_PATH") {
+        return message || "目录不可用：请确认输入的是存在的真实目录绝对路径。";
+    }
+    if (isMutationGateFailureCode(code)) {
+        return describeMutationGateFailure(code);
+    }
+    return message || `添加 Workspace 失败（HTTP ${status}）`;
+}
+// The headless object also exposes subscribe(); declared via intersection below.
+/** Headless multi-workspace state machine (real request path, no React). */
+export function createWorkspacesController(params = {}) {
+    const origin = params.origin ?? "";
+    const fetchImpl = params.fetchFn ?? fetch;
+    const storage = params.storage;
+    const token = params.confirmationTokenFn ?? confirmationToken;
+    const listeners = new Set();
+    let state = {
+        workspaces: [],
+        loading: true,
+        error: null,
+        workspaceId: readStoredWorkspaceId(storage),
+        unknownWorkspaceId: null,
+    };
+    const emit = () => {
+        for (const listener of listeners)
+            listener();
+    };
+    const setState = (patch) => {
+        state = { ...state, ...patch };
+        emit();
+    };
+    const refresh = async () => {
+        try {
+            const res = await fetchImpl(`${origin}/api/operator/v1/workspaces`, {
+                credentials: "include",
+            });
+            if (!res.ok)
+                return;
+            const body = (await res.json());
+            const list = body.workspaces ?? [];
+            // A stale local preference falls back to the first server-visible
+            // Workspace. Explicit route ids are validated separately and remain
+            // fail-closed.
+            const pick = pickDefaultWorkspaceId(list, state.workspaceId);
+            if (pick.status === "unknown-workspace") {
+                setState({
+                    workspaces: list,
+                    unknownWorkspaceId: pick.workspaceId,
+                });
+                return;
+            }
+            const nextId = pick.workspaceId;
+            const previousId = state.workspaceId;
+            setState({
+                workspaces: list,
+                unknownWorkspaceId: null,
+                ...(nextId !== previousId ? { workspaceId: nextId } : {}),
+            });
+            if (nextId !== previousId)
+                rememberWorkspaceId(nextId, storage);
+        }
+        catch {
+            /* Registry unreachable: keep last known list. */
+        }
+        finally {
+            if (state.loading)
+                setState({ loading: false });
+        }
+    };
+    const addWorkspace = async (directoryPath, name) => {
+        setState({ error: null });
+        try {
+            const res = await fetchImpl(`${origin}/api/operator/v1/workspaces`, {
+                method: "POST",
+                credentials: "include",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-loop-console-confirmation": token(),
+                },
+                body: JSON.stringify({ directoryPath, ...(name ? { name } : {}) }),
+            });
+            const body = (await res.json().catch(() => ({})));
+            if (!res.ok || !body.workspace) {
+                const message = describeWorkspaceAddError(res.status, body.error?.code, body.error?.message);
+                setState({ error: message });
+                return { ok: false, error: message };
+            }
+            await refresh();
+            setState({ workspaceId: body.workspace.workspaceId });
+            rememberWorkspaceId(body.workspace.workspaceId, storage);
+            return { ok: true, workspaceId: body.workspace.workspaceId };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const display = `添加 Workspace 失败：${message}`;
+            setState({ error: display });
+            return { ok: false, error: display };
+        }
+    };
+    const pickWorkspaceDirectory = async () => {
+        setState({ error: null });
+        try {
+            const res = await fetchImpl(`${origin}/api/operator/v1/workspaces/pick`, {
+                method: "POST",
+                credentials: "include",
+                headers: {
+                    "x-loop-console-confirmation": token(),
+                },
+            });
+            const body = (await res.json().catch(() => ({})));
+            if (!res.ok) {
+                const message = isMutationGateFailureCode(body.error?.code)
+                    ? describeMutationGateFailure(body.error?.code ?? "")
+                    : (body.error?.message ?? `打开目录选择窗口失败（HTTP ${res.status}）`);
+                setState({ error: message });
+                return null;
+            }
+            return typeof body.directoryPath === "string" && body.directoryPath.trim()
+                ? body.directoryPath
+                : null;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            setState({ error: `打开目录选择窗口失败：${message}` });
+            return null;
+        }
+    };
+    const removeWorkspace = async (targetId) => {
+        setState({ error: null });
+        try {
+            const res = await fetchImpl(`${origin}/api/operator/v1/workspaces/${encodeURIComponent(targetId)}`, {
+                method: "DELETE",
+                credentials: "include",
+                headers: {
+                    "x-loop-console-confirmation": token(),
+                },
+            });
+            const body = (await res.json().catch(() => ({})));
+            if (!res.ok) {
+                const message = res.status === 404
+                    ? "Workspace 已不存在（可能已被移除），列表将刷新。"
+                    : isMutationGateFailureCode(body.error?.code)
+                        ? describeMutationGateFailure(body.error?.code ?? "")
+                        : (body.error?.message ?? `移除 Workspace 失败（HTTP ${res.status}）`);
+                setState({ error: message });
+                await refresh();
+                return { ok: false, error: message };
+            }
+            await refresh();
+            // Soft remove keeps historical sessions; if the removed workspace was
+            // selected, switch to a remaining one (never a startup-workspace id —
+            // only visible registry entries are ever selected).
+            if (state.workspaceId === targetId) {
+                const nextId = state.workspaces[0]?.workspaceId ?? null;
+                setState({ workspaceId: nextId });
+                rememberWorkspaceId(nextId, storage);
+            }
+            return { ok: true };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const display = `移除 Workspace 失败：${message}`;
+            setState({ error: display });
+            return { ok: false, error: display };
+        }
+    };
+    const selectWorkspace = (next) => {
+        if (next === state.workspaceId && !state.unknownWorkspaceId)
+            return;
+        setState({ workspaceId: next, unknownWorkspaceId: null });
+        rememberWorkspaceId(next, storage);
+    };
+    void refresh();
+    return {
+        get workspaces() {
+            return state.workspaces;
+        },
+        get loading() {
+            return state.loading;
+        },
+        get error() {
+            return state.error;
+        },
+        get workspaceId() {
+            return state.workspaceId;
+        },
+        get unknownWorkspaceId() {
+            return state.unknownWorkspaceId;
+        },
+        refresh,
+        pickWorkspaceDirectory,
+        addWorkspace,
+        removeWorkspace,
+        selectWorkspace,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}
+/** React binding: one controller per mount, state mirrored into useState. */
+export function useWorkspaces(params) {
+    const controllerRef = useRef(null);
+    if (!controllerRef.current) {
+        controllerRef.current = createWorkspacesController(params);
+    }
+    const controller = controllerRef.current;
+    const [state, setState] = useState(() => ({
+        workspaces: controller.workspaces,
+        loading: controller.loading,
+        error: controller.error,
+        workspaceId: controller.workspaceId,
+        unknownWorkspaceId: controller.unknownWorkspaceId,
+    }));
+    useEffect(() => {
+        const unsubscribe = controller.subscribe(() => {
+            setState({
+                workspaces: controller.workspaces,
+                loading: controller.loading,
+                error: controller.error,
+                workspaceId: controller.workspaceId,
+                unknownWorkspaceId: controller.unknownWorkspaceId,
+            });
+        });
+        return unsubscribe;
+    }, [controller]);
+    return useMemo(() => ({
+        get workspaces() {
+            return state.workspaces;
+        },
+        get loading() {
+            return state.loading;
+        },
+        get error() {
+            return state.error;
+        },
+        get workspaceId() {
+            return state.workspaceId;
+        },
+        get unknownWorkspaceId() {
+            return state.unknownWorkspaceId;
+        },
+        refresh: controller.refresh,
+        pickWorkspaceDirectory: controller.pickWorkspaceDirectory,
+        addWorkspace: controller.addWorkspace,
+        removeWorkspace: controller.removeWorkspace,
+        selectWorkspace: controller.selectWorkspace,
+    }), [state, controller]);
+}