@tea-agent/loop-agent 0.31.1 → 0.32.1

package/dist/worker/console/static-src/app/useRecoveryActions.js

@@ -0,0 +1,257 @@
+import { useCallback } from "react";
+import { isAutoRecoveryReason } from "../../recovery-selection.js";
+import { formatDagRerunIneligible, postOperator, requestId, } from "./console-types.js";
+/** Recovery CTA dispatch: diagnose/report/inspect shortcuts, reason-gated
+ *  confirm flow with dagRerunPlan preflight, and gated reruns/retries. */
+export function useRecoveryActions(params) {
+    const { shell, actions, taskId, dagRunId, fromNodeId, featureId, recoveryReason, recoveryReasonTouched, recoveryConfirm, recoveryPlanSummary, setRecoveryConfirm, setRecoveryPlanSummary, setRecoveryReport, setRecoveryReason, setRecoveryReasonTouched, buildCurrentRecoveryReason, openFullCanvas, } = params;
+    const { setOpError, setOpErrorCode, setOpMessage, setBusy } = shell;
+    const { runAction, isActionSuccess } = actions;
+    const handleRecoveryCta = useCallback(async (cta) => {
+        // Leaving a confirm flow when picking diagnose / advisory CTAs.
+        if (!cta.requiresReason) {
+            setRecoveryConfirm(null);
+            setRecoveryPlanSummary(null);
+        }
+        if (cta.action === "doctor") {
+            setRecoveryReport(null);
+            void runAction("doctor", {});
+            return;
+        }
+        if (cta.action === "dagReport" || cta.id === "report") {
+            const runId = dagRunId.trim();
+            if (runId) {
+                setRecoveryConfirm(null);
+                setRecoveryPlanSummary(null);
+                const body = await runAction("dagReport", { runId });
+                const envelope = (body?.result ?? {});
+                const run = (envelope.raw?.runs ?? envelope.runs)?.[0];
+                if (body && body.ok !== false && !body.error && run) {
+                    setRecoveryReport({
+                        runId: run.runId ?? runId,
+                        title: run.title,
+                        status: run.status,
+                        category: run.productLineFailureCategory,
+                        recommendation: run.recoveryRecommendation?.summary ??
+                            run.recommendedFollowUp ??
+                            undefined,
+                    });
+                    setOpMessage(null);
+                }
+                return;
+            }
+            if (taskId.trim()) {
+                setRecoveryReport(null);
+                void runAction("status", { taskId });
+                return;
+            }
+            setOpError("查看报告需要先选择 DAG 运行 ID（或填写任务 ID）");
+            return;
+        }
+        if (cta.action === "observeLink") {
+            setRecoveryReport(null);
+            void openFullCanvas();
+            return;
+        }
+        if (cta.requiresReason) {
+            setRecoveryReport(null);
+            setRecoveryConfirm(cta);
+            setRecoveryPlanSummary(null);
+            // Switching away from an ineligible node-rerun should not keep that error.
+            if (cta.id !== "dagRerun") {
+                setOpError(null);
+                setOpErrorCode(null);
+            }
+            if (!recoveryReasonTouched || isAutoRecoveryReason(recoveryReason)) {
+                setRecoveryReason(buildCurrentRecoveryReason(cta.label));
+                setRecoveryReasonTouched(false);
+            }
+            if (cta.id === "dagRerun" && dagRunId.trim() && fromNodeId.trim()) {
+                setBusy(true);
+                try {
+                    const { status, body } = await postOperator("dagRerunPlan", {
+                        runId: dagRunId.trim(),
+                        fromNode: fromNodeId.trim(),
+                    });
+                    const plan = (body.result ?? {});
+                    if (plan &&
+                        typeof plan === "object" &&
+                        ("eligible" in plan || plan.planHash)) {
+                        setRecoveryPlanSummary(plan);
+                    }
+                    if (status < 400 && body.ok !== false && plan.eligible !== false) {
+                        setOpMessage(null);
+                    }
+                    else if (plan.eligible === false) {
+                        setOpError(body.error?.message ?? formatDagRerunIneligible(plan));
+                    }
+                    else {
+                        setOpMessage(body.error?.message ??
+                            "无法预检重跑计划；确认后仍将尝试提交（CLI 可能尚未就绪）");
+                    }
+                }
+                finally {
+                    setBusy(false);
+                }
+            }
+            return;
+        }
+        setOpError(null);
+        setOpErrorCode(null);
+        setOpMessage(`${cta.label}：请经 CLI — ${cta.commandHint ?? ""}`);
+    }, [
+        buildCurrentRecoveryReason,
+        dagRunId,
+        fromNodeId,
+        openFullCanvas,
+        recoveryReason,
+        recoveryReasonTouched,
+        runAction,
+        setBusy,
+        setOpError,
+        setOpErrorCode,
+        setOpMessage,
+        setRecoveryConfirm,
+        setRecoveryPlanSummary,
+        setRecoveryReport,
+        setRecoveryReason,
+        setRecoveryReasonTouched,
+        taskId,
+    ]);
+    const submitRecoveryConfirm = useCallback(async () => {
+        const cta = recoveryConfirm;
+        if (!cta)
+            return;
+        const reason = recoveryReason.trim();
+        if (!reason) {
+            setOpError("恢复操作需要结构化原因");
+            return;
+        }
+        const clientRequestId = requestId(`recovery-${cta.id}`);
+        setRecoveryConfirm(null);
+        if (cta.id === "dagRerun") {
+            const runId = dagRunId.trim();
+            const fromNode = fromNodeId.trim();
+            if (!runId || !fromNode) {
+                setOpError("从节点重跑需要 DAG 运行 ID 与起始节点 ID");
+                return;
+            }
+            let planHash = recoveryPlanSummary?.planHash?.trim();
+            let planEligible = recoveryPlanSummary?.eligible;
+            if (!planHash || planEligible === undefined) {
+                const planBody = await runAction("dagRerunPlan", {
+                    runId,
+                    fromNode,
+                });
+                const plan = (planBody?.result ?? {});
+                if (plan.planHash || plan.eligible !== undefined) {
+                    setRecoveryPlanSummary(plan);
+                }
+                planHash = plan.planHash?.trim() || planHash;
+                planEligible = plan.eligible;
+                if (plan.eligible === false) {
+                    setOpError(planBody?.error?.message ?? formatDagRerunIneligible(plan));
+                    return;
+                }
+                if (planBody && planBody.ok === false && !planHash) {
+                    setOpError(planBody.error?.message ??
+                        "无法获取 planHash；请确认 loop-agent dag rerun --plan 可用");
+                    return;
+                }
+            }
+            if (planEligible === false) {
+                setOpError(formatDagRerunIneligible(recoveryPlanSummary ?? {}));
+                return;
+            }
+            if (!planHash) {
+                setOpError("无法获取 planHash；请确认 loop-agent dag rerun --plan 可用");
+                return;
+            }
+            await runAction("dagRerun", { runId, fromNode, planHash, reason }, { clientRequestId });
+            return;
+        }
+        if (cta.id === "standaloneTaskRerun") {
+            const runId = dagRunId.trim();
+            if (!runId) {
+                setOpError("完整重跑任务需要 DAG 运行 ID");
+                return;
+            }
+            const actionParams = {
+                runId,
+                reason,
+                ...(taskId.trim() ? { taskId: taskId.trim() } : {}),
+            };
+            const prep = await runAction("prepareMutationGate", {
+                action: "standaloneTaskRerun",
+                actionParams,
+            });
+            if (!isActionSuccess(prep))
+                return;
+            const receipt = (prep?.result ?? prep);
+            if (!receipt.receiptId || !receipt.humanGateToken) {
+                setOpError("prepareMutationGate 未返回可消费的 Human Gate receipt");
+                return;
+            }
+            await runAction("standaloneTaskRerun", {
+                ...actionParams,
+                confirmationId: receipt.receiptId,
+                humanGateToken: receipt.humanGateToken,
+            }, { clientRequestId });
+            return;
+        }
+        if (cta.id === "workerTaskRetry") {
+            const id = taskId.trim();
+            if (!id) {
+                setOpError("重新排队 Worker Task 需要任务 ID");
+                return;
+            }
+            const actionParams = {
+                taskId: id,
+                reason,
+                ...(featureId.trim() ? { featureId: featureId.trim() } : {}),
+            };
+            const prep = await runAction("prepareMutationGate", {
+                action: "workerTaskRetry",
+                actionParams,
+            });
+            if (!isActionSuccess(prep))
+                return;
+            const receipt = (prep?.result ?? prep);
+            if (!receipt.receiptId || !receipt.humanGateToken) {
+                setOpError("prepareMutationGate 未返回可消费的 Human Gate receipt");
+                return;
+            }
+            await runAction("workerTaskRetry", {
+                ...actionParams,
+                confirmationId: receipt.receiptId,
+                humanGateToken: receipt.humanGateToken,
+            }, { clientRequestId });
+            return;
+        }
+        if (cta.id === "reconcile") {
+            const runId = dagRunId.trim();
+            if (!runId) {
+                setOpError("对账恢复需要 DAG 运行 ID");
+                return;
+            }
+            setOpMessage(`${cta.label}：请经 CLI — ${cta.commandHint ?? ""}`);
+            return;
+        }
+        setOpMessage(`${cta.label}：请经 CLI — ${cta.commandHint ?? ""}`);
+    }, [
+        dagRunId,
+        featureId,
+        fromNodeId,
+        recoveryConfirm,
+        recoveryPlanSummary?.planHash,
+        recoveryReason,
+        runAction,
+        isActionSuccess,
+        setOpError,
+        setOpMessage,
+        setRecoveryConfirm,
+        setRecoveryPlanSummary,
+        taskId,
+    ]);
+    return { handleRecoveryCta, submitRecoveryConfirm };
+}

package/dist/worker/console/static-src/app/useRecoveryConsole.js

@@ -0,0 +1,334 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { classifyRecoveryFact, consoleRecoveryCtas, partitionRecoveryCtas, recommendedRecoveryCtaId, } from "../../recovery-cta.js";
+import { buildRecoveryReason, isAutoRecoveryReason, pickDefaultRecoveryNodeId, pickDefaultRecoveryRunId, sortRecoveryNodeCandidates, } from "../../recovery-selection.js";
+import { postOperator, RECOVERY_FACT_LABEL, } from "./console-types.js";
+import { useRecoveryActions } from "./useRecoveryActions.js";
+/** Recovery workspace: DAG-run / node candidate selection, fact-classified
+ *  CTA lanes, structured reason prefill, plan preflight and gated reruns. */
+export function useRecoveryConsole(params) {
+    const { shell, actions, wizard } = params;
+    const { nav, opError, opErrorCode, lastOpState, setOpError, setObserveBusy } = shell;
+    const { taskId } = wizard;
+    const [dagRunId, setDagRunId] = useState("");
+    const [fromNodeId, setFromNodeId] = useState("");
+    const [featureId, setFeatureId] = useState("");
+    const [recoveryReason, setRecoveryReason] = useState("");
+    const [recoveryReasonTouched, setRecoveryReasonTouched] = useState(false);
+    const [recoveryPlanSummary, setRecoveryPlanSummary] = useState(null);
+    const [recoveryConfirm, setRecoveryConfirm] = useState(null);
+    const [recoveryRuns, setRecoveryRuns] = useState([]);
+    const [recoveryNodes, setRecoveryNodes] = useState([]);
+    const [recoveryRunsLoading, setRecoveryRunsLoading] = useState(false);
+    const [recoveryNodesLoading, setRecoveryNodesLoading] = useState(false);
+    const [recoveryRunStatus, setRecoveryRunStatus] = useState(null);
+    const [manualRunId, setManualRunId] = useState(false);
+    const [manualNodeId, setManualNodeId] = useState(false);
+    const [recoveryReport, setRecoveryReport] = useState(null);
+    const [observeLinkStatus, setObserveLinkStatus] = useState("idle");
+    const [observeLinkMessage, setObserveLinkMessage] = useState(null);
+    const [observeUrl, setObserveUrl] = useState(null);
+    const [inspectSplitOpen, setInspectSplitOpen] = useState(false);
+    const inspectPath = useCallback(() => {
+        if (dagRunId.trim()) {
+            return `/inspect/#/dag/${encodeURIComponent(dagRunId.trim())}`;
+        }
+        return "/inspect/#/";
+    }, [dagRunId]);
+    const openFullInspect = useCallback(() => {
+        window.location.assign(inspectPath());
+    }, [inspectPath]);
+    /** Resolve DAG run id for inspect (side panel or full page). */
+    const resolveDagRunForInspect = useCallback(async () => {
+        if (dagRunId.trim())
+            return dagRunId.trim();
+        const id = taskId.trim();
+        if (!id) {
+            setOpError("打开 DAG 检视需要任务 ID 或 DAG 运行 ID");
+            return null;
+        }
+        setObserveBusy(true);
+        setOpError(null);
+        try {
+            const { status, body } = await postOperator("observeLink", {
+                taskId: id,
+            });
+            const result = (body.result ?? {});
+            if (status >= 400 || body.ok === false) {
+                setOpError(body.error?.message ?? "无法解析 DAG 画布地址");
+                setObserveLinkStatus("unavailable");
+                setObserveLinkMessage(body.error?.message ?? null);
+                return null;
+            }
+            const resolvedDag = typeof result.dagRunId === "string" ? result.dagRunId.trim() : "";
+            if (resolvedDag) {
+                setDagRunId(resolvedDag);
+                setObserveLinkStatus("match");
+                setObserveLinkMessage(null);
+                setObserveUrl(`/inspect/#/dag/${encodeURIComponent(resolvedDag)}`);
+                return resolvedDag;
+            }
+            setOpError("尚未找到该任务的 DAG 运行，请稍后再打开检视");
+            setObserveLinkStatus("unavailable");
+            setObserveLinkMessage(result.message ?? "未解析到 DAG run");
+            return null;
+        }
+        catch (error) {
+            setOpError(error instanceof Error ? error.message : String(error));
+            return null;
+        }
+        finally {
+            setObserveBusy(false);
+        }
+    }, [dagRunId, taskId, setOpError, setObserveBusy]);
+    /** Prefer in-page side panel so Operate state is preserved. */
+    const openInspectSplit = useCallback(async () => {
+        const resolved = await resolveDagRunForInspect();
+        if (resolved)
+            setInspectSplitOpen(true);
+    }, [resolveDagRunForInspect]);
+    /** Full DAG canvas — use only when user explicitly leaves Operate. */
+    const openFullCanvas = useCallback(async () => {
+        const resolved = await resolveDagRunForInspect();
+        if (!resolved)
+            return;
+        window.location.assign(`/inspect/#/dag/${encodeURIComponent(resolved)}`);
+    }, [resolveDagRunForInspect]);
+    const loadRecoveryRuns = useCallback(async () => {
+        setRecoveryRunsLoading(true);
+        try {
+            const id = taskId.trim();
+            const qs = new URLSearchParams();
+            if (id)
+                qs.set("taskId", id);
+            qs.set("limit", "40");
+            const res = await fetch(`/api/operator/v1/recovery/candidates?${qs.toString()}`, { credentials: "same-origin" });
+            if (!res.ok) {
+                setRecoveryRuns([]);
+                return;
+            }
+            const body = (await res.json());
+            setRecoveryRuns(Array.isArray(body.runs) ? body.runs : []);
+        }
+        catch {
+            setRecoveryRuns([]);
+        }
+        finally {
+            setRecoveryRunsLoading(false);
+        }
+    }, [taskId]);
+    const loadRecoveryNodes = useCallback(async (runId) => {
+        const id = runId.trim();
+        if (!id) {
+            setRecoveryNodes([]);
+            setRecoveryRunStatus(null);
+            return;
+        }
+        setRecoveryNodesLoading(true);
+        try {
+            const res = await fetch(`/api/dag-runs/${encodeURIComponent(id)}`, {
+                credentials: "same-origin",
+            });
+            if (!res.ok) {
+                setRecoveryNodes([]);
+                setRecoveryRunStatus(null);
+                return;
+            }
+            const body = (await res.json());
+            setRecoveryRunStatus(typeof body.status === "string" ? body.status : null);
+            const rawNodes = Array.isArray(body.nodes) ? body.nodes : [];
+            const nodes = sortRecoveryNodeCandidates(rawNodes
+                .map((n) => {
+                const nodeId = (n.nodeId ?? n.id ?? "").trim();
+                if (!nodeId)
+                    return null;
+                return {
+                    nodeId,
+                    status: n.status,
+                    label: n.label ?? n.name,
+                    errorPreview: n.errorPreview,
+                };
+            })
+                .filter((n) => n !== null));
+            setRecoveryNodes(nodes);
+        }
+        catch {
+            setRecoveryNodes([]);
+            setRecoveryRunStatus(null);
+        }
+        finally {
+            setRecoveryNodesLoading(false);
+        }
+    }, []);
+    useEffect(() => {
+        if (nav !== "recovery")
+            return;
+        void loadRecoveryRuns();
+    }, [nav, taskId, loadRecoveryRuns]);
+    useEffect(() => {
+        if (nav !== "recovery")
+            return;
+        if (manualRunId)
+            return;
+        if (recoveryRuns.length === 0)
+            return;
+        const current = dagRunId.trim();
+        const inList = current
+            ? recoveryRuns.some((r) => r.dagRunId === current)
+            : false;
+        if (!current || !inList) {
+            const preferred = pickDefaultRecoveryRunId(recoveryRuns);
+            if (preferred && preferred !== current)
+                setDagRunId(preferred);
+        }
+    }, [nav, recoveryRuns, dagRunId, manualRunId]);
+    useEffect(() => {
+        if (nav !== "recovery")
+            return;
+        void loadRecoveryNodes(dagRunId);
+    }, [nav, dagRunId, loadRecoveryNodes]);
+    useEffect(() => {
+        if (nav !== "recovery")
+            return;
+        if (manualNodeId)
+            return;
+        if (recoveryNodes.length === 0)
+            return;
+        const current = fromNodeId.trim();
+        const inList = current
+            ? recoveryNodes.some((n) => n.nodeId === current)
+            : false;
+        if (!current || !inList) {
+            const preferred = pickDefaultRecoveryNodeId(recoveryNodes);
+            if (preferred && preferred !== current)
+                setFromNodeId(preferred);
+        }
+    }, [nav, recoveryNodes, fromNodeId, manualNodeId]);
+    const recoveryFact = classifyRecoveryFact({
+        // Selected DAG run status owns the recovery matrix; do not let read actions
+        // (dagReport / doctor) flip CTAs via transient lastOpState=succeeded.
+        operationState: recoveryRunStatus ? null : lastOpState,
+        errorCode: recoveryRunStatus ? null : opErrorCode,
+        dagStatus: recoveryRunStatus,
+    });
+    const recoveryCtas = useMemo(() => consoleRecoveryCtas(recoveryFact), [recoveryFact]);
+    const recoveryLanes = useMemo(() => partitionRecoveryCtas(recoveryCtas), [recoveryCtas]);
+    const recommendedCtaId = useMemo(() => recommendedRecoveryCtaId(recoveryFact), [recoveryFact]);
+    const selectedRecoveryNode = useMemo(() => recoveryNodes.find((n) => n.nodeId === fromNodeId.trim()), [recoveryNodes, fromNodeId]);
+    const recoveryConfirmRef = useRef(null);
+    useEffect(() => {
+        if (!recoveryConfirm)
+            return;
+        recoveryConfirmRef.current?.scrollIntoView({
+            behavior: "smooth",
+            block: "nearest",
+        });
+    }, [recoveryConfirm?.id]);
+    const buildCurrentRecoveryReason = useCallback((actionLabel) => buildRecoveryReason({
+        actionLabel,
+        dagRunId: dagRunId.trim() || undefined,
+        fromNodeId: fromNodeId.trim() || undefined,
+        runStatus: recoveryRunStatus,
+        nodeStatus: selectedRecoveryNode?.status,
+        nodeError: selectedRecoveryNode?.errorPreview,
+        factClassLabel: RECOVERY_FACT_LABEL[recoveryFact],
+        errorMessage: opError,
+        errorCode: opErrorCode,
+    }), [
+        dagRunId,
+        fromNodeId,
+        opError,
+        opErrorCode,
+        recoveryFact,
+        recoveryRunStatus,
+        selectedRecoveryNode?.errorPreview,
+        selectedRecoveryNode?.status,
+    ]);
+    useEffect(() => {
+        if (nav !== "recovery")
+            return;
+        if (recoveryReasonTouched && !isAutoRecoveryReason(recoveryReason))
+            return;
+        const next = buildCurrentRecoveryReason(recoveryConfirm?.label);
+        if (next && next !== recoveryReason)
+            setRecoveryReason(next);
+    }, [
+        nav,
+        dagRunId,
+        fromNodeId,
+        recoveryRunStatus,
+        selectedRecoveryNode,
+        recoveryFact,
+        opError,
+        opErrorCode,
+        recoveryConfirm?.label,
+        recoveryReasonTouched,
+        recoveryReason,
+        buildCurrentRecoveryReason,
+    ]);
+    const { handleRecoveryCta, submitRecoveryConfirm } = useRecoveryActions({
+        shell,
+        actions,
+        taskId,
+        dagRunId,
+        fromNodeId,
+        featureId,
+        recoveryReason,
+        recoveryReasonTouched,
+        recoveryConfirm,
+        recoveryPlanSummary,
+        setRecoveryConfirm,
+        setRecoveryPlanSummary,
+        setRecoveryReport,
+        setRecoveryReason,
+        setRecoveryReasonTouched,
+        buildCurrentRecoveryReason,
+        openFullCanvas,
+    });
+    return {
+        dagRunId,
+        setDagRunId,
+        fromNodeId,
+        setFromNodeId,
+        featureId,
+        setFeatureId,
+        recoveryReason,
+        setRecoveryReason,
+        recoveryReasonTouched,
+        setRecoveryReasonTouched,
+        recoveryPlanSummary,
+        recoveryConfirm,
+        setRecoveryConfirm,
+        setRecoveryPlanSummary,
+        recoveryRuns,
+        recoveryNodes,
+        recoveryRunsLoading,
+        recoveryNodesLoading,
+        recoveryRunStatus,
+        manualRunId,
+        setManualRunId,
+        manualNodeId,
+        setManualNodeId,
+        recoveryReport,
+        setRecoveryReport,
+        observeLinkStatus,
+        observeLinkMessage,
+        observeUrl,
+        inspectSplitOpen,
+        setInspectSplitOpen,
+        inspectPath,
+        openFullInspect,
+        resolveDagRunForInspect,
+        openInspectSplit,
+        openFullCanvas,
+        loadRecoveryRuns,
+        loadRecoveryNodes,
+        recoveryFact,
+        recoveryCtas,
+        recoveryLanes,
+        recommendedCtaId,
+        recoveryConfirmRef,
+        buildCurrentRecoveryReason,
+        handleRecoveryCta,
+        submitRecoveryConfirm,
+    };
+}