@tea-agent/loop-agent 0.31.1 → 0.32.1

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

@@ -0,0 +1,304 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { formatOperatorUserError } from "../../operator-user-error.js";
+import { ACTIVE_CHAT_SESSION_STORAGE_KEY } from "../../chat/workspace-landing.js";
+import { confirmationToken, CONFIRMATION_HEADER, LONG_RUNNING_ACTIONS, postOperator, waitForOperation, } from "./console-types.js";
+/** Central operator-action dispatcher: POST /api/operator/v1/operations with
+ *  polling, long-running background waits, interview payload handoff and the
+ *  per-operation SSE follow log. */
+export function useOperatorActions(params) {
+    const { shell, applyInterviewPayload } = params;
+    const { setBusy, setOpError, setOpErrorCode, setOpMessage, setReadiness, setStep, setNav, setLastOpState, setLayers, step, nav, } = shell;
+    const [operationId, setOperationId] = useState(null);
+    const [sseLog, setSseLog] = useState([]);
+    const [followSse, setFollowSse] = useState(true);
+    const sseAbort = useRef(null);
+    const [confirmationId, setConfirmationId] = useState(null);
+    const [confirmationDetails, setConfirmationDetails] = useState(null);
+    const runAction = useCallback(async (action, actionParams = {}, opts) => {
+        setBusy(true);
+        setOpError(null);
+        setOpErrorCode(null);
+        setOpMessage(null);
+        try {
+            const { status, body } = await postOperator(action, actionParams, opts?.clientRequestId);
+            if (status === 412 || body.error?.code === "PI_SETUP_REQUIRED") {
+                setOpError(formatOperatorUserError(body.error?.message ?? "Pi 未就绪或已降级：该操作暂不可用"));
+                setOpErrorCode(body.error?.code ?? "PI_SETUP_REQUIRED");
+                setReadiness("setup-required");
+                setStep("setup");
+                setNav("models");
+                return body;
+            }
+            if (status >= 400 || body.ok === false) {
+                setOpError(formatOperatorUserError(body.error?.message ??
+                    body.message ??
+                    `操作失败（HTTP ${status}）`));
+                setOpErrorCode(body.error?.code ?? String(status));
+                setLastOpState(body.state ?? `failed:${status}`);
+                setLayers((prev) => ({
+                    ...prev,
+                    command: body.error?.message ?? `failed:${body.error?.code ?? status}`,
+                }));
+                return body;
+            }
+            if (body.operationId) {
+                const activeChatSessionId = window.localStorage
+                    .getItem(ACTIVE_CHAT_SESSION_STORAGE_KEY)
+                    ?.trim();
+                if (activeChatSessionId) {
+                    void fetch(`/api/operator/v1/chat/sessions/${encodeURIComponent(activeChatSessionId)}/operation-links`, {
+                        method: "POST",
+                        credentials: "same-origin",
+                        headers: {
+                            "Content-Type": "application/json",
+                            [CONFIRMATION_HEADER]: confirmationToken(),
+                        },
+                        body: JSON.stringify({ operationId: body.operationId }),
+                    })
+                        .then((response) => {
+                        if (!response.ok)
+                            console.warn("Operator Chat operation link failed", response.status);
+                    })
+                        .catch((error) => console.warn("Operator Chat operation link failed", error));
+                }
+                setOperationId(body.operationId);
+                setLastOpState(body.state ?? "accepted");
+                setLayers((prev) => ({
+                    ...prev,
+                    command: body.state ?? "accepted",
+                    dag: action === "runDag" ? "running" : prev.dag,
+                }));
+                // Long DAG runs must not block the UI on a short poll timeout.
+                if (LONG_RUNNING_ACTIONS.has(action)) {
+                    setFollowSse(true);
+                    setOpMessage(`操作已接受，后台运行中：${body.operationId}（请看事件流；可同时打开 Observe）`);
+                    // Recovery / long actions still need terminal feedback on this page.
+                    const acceptedOpId = body.operationId;
+                    void waitForOperation(acceptedOpId, 30 * 60_000).then((finalOp) => {
+                        if (!finalOp)
+                            return;
+                        setLastOpState(finalOp.state ?? null);
+                        if (finalOp.state === "failed" ||
+                            finalOp.state === "needs-reconcile" ||
+                            finalOp.state === "timed-out") {
+                            setOpError(formatOperatorUserError(finalOp.errorMessage ??
+                                finalOp.stderrPreview ??
+                                `操作失败：${finalOp.state}`));
+                            setOpErrorCode(finalOp.errorCode ?? finalOp.state ?? null);
+                            setLayers((prev) => ({
+                                ...prev,
+                                command: `failed:${finalOp.errorCode ?? finalOp.state}`,
+                            }));
+                            return;
+                        }
+                        if (finalOp.state === "succeeded") {
+                            setOpMessage(`${action} 已成功`);
+                            setLayers((prev) => ({
+                                ...prev,
+                                command: "succeeded",
+                            }));
+                        }
+                    });
+                }
+                else {
+                    setOpMessage(`操作已接受：${body.operationId}`);
+                    const finalOp = await waitForOperation(body.operationId);
+                    if (finalOp) {
+                        setLastOpState(finalOp.state ?? null);
+                        if (finalOp.state === "failed" ||
+                            finalOp.state === "needs-reconcile" ||
+                            finalOp.state === "timed-out") {
+                            setOpError(formatOperatorUserError(finalOp.errorMessage ??
+                                finalOp.stderrPreview ??
+                                `操作失败：${finalOp.state}`));
+                            setOpErrorCode(finalOp.errorCode ?? finalOp.state ?? null);
+                            setLayers((prev) => ({
+                                ...prev,
+                                command: `failed:${finalOp.errorCode ?? finalOp.state}`,
+                            }));
+                            return {
+                                ok: false,
+                                operationId: body.operationId,
+                                state: finalOp.state,
+                                error: {
+                                    code: finalOp.errorCode ?? finalOp.state ?? "INTERNAL_ERROR",
+                                    message: finalOp.errorMessage ??
+                                        finalOp.stderrPreview ??
+                                        `操作失败：${finalOp.state}`,
+                                },
+                            };
+                        }
+                        setOpMessage(finalOp.errorMessage
+                            ? `${action}：${finalOp.errorMessage}`
+                            : `${action} 已成功`);
+                        setLayers((prev) => ({
+                            ...prev,
+                            command: finalOp.state ?? "succeeded",
+                        }));
+                        const finalResult = (finalOp.result ?? {});
+                        const succeeded = {
+                            ok: true,
+                            operationId: body.operationId,
+                            state: finalOp.state ?? "succeeded",
+                            result: finalResult,
+                        };
+                        if (action === "interviewStart" ||
+                            action === "interviewTurn" ||
+                            action === "interviewSkip") {
+                            applyInterviewPayload(finalResult);
+                        }
+                        const conf = finalResult.confirmation;
+                        if (conf?.confirmationId) {
+                            setConfirmationId(conf.confirmationId);
+                            setConfirmationDetails(finalResult);
+                        }
+                        if (opts?.advanceTo)
+                            setStep(opts.advanceTo);
+                        return succeeded;
+                    }
+                }
+            }
+            else {
+                setOpMessage(`${action} 已完成`);
+                setLastOpState(body.state ?? "succeeded");
+                setLayers((prev) => ({
+                    ...prev,
+                    command: "succeeded",
+                    verification: action === "contractValidate" || action === "spineCheck"
+                        ? "ran"
+                        : prev.verification,
+                }));
+            }
+            const result = (body.result ?? {});
+            if (action === "interviewStart" ||
+                action === "interviewTurn" ||
+                action === "interviewSkip") {
+                applyInterviewPayload(result);
+            }
+            const conf = result.confirmation;
+            if (conf?.confirmationId) {
+                setConfirmationId(conf.confirmationId);
+                setConfirmationDetails(result);
+            }
+            if (opts?.advanceTo)
+                setStep(opts.advanceTo);
+            return body;
+        }
+        catch (error) {
+            setOpError(error instanceof Error ? error.message : String(error));
+            return undefined;
+        }
+        finally {
+            setBusy(false);
+        }
+    }, [
+        applyInterviewPayload,
+        setBusy,
+        setOpError,
+        setOpErrorCode,
+        setOpMessage,
+        setReadiness,
+        setStep,
+        setNav,
+        setLastOpState,
+        setLayers,
+    ]);
+    const summarizeEnvelope = useCallback((body) => {
+        if (!body)
+            return "无响应";
+        if (body.error?.message)
+            return body.error.message;
+        if (body.message)
+            return body.message;
+        const result = body.result;
+        if (result && typeof result === "object") {
+            try {
+                return JSON.stringify(result).slice(0, 1200);
+            }
+            catch {
+                return "已返回结果";
+            }
+        }
+        return body.ok === false ? "失败" : "成功";
+    }, []);
+    const isActionSuccess = useCallback((body) => {
+        if (!body || body.ok === false || body.error)
+            return false;
+        const result = body.result;
+        if (!result)
+            return true;
+        if (typeof result.valid === "boolean")
+            return result.valid;
+        const nested = result.result;
+        if (nested && typeof nested.valid === "boolean")
+            return nested.valid;
+        return true;
+    }, []);
+    const followOperationEvents = useCallback(async (opId) => {
+        sseAbort.current?.abort();
+        const ac = new AbortController();
+        sseAbort.current = ac;
+        setSseLog((prev) => [...prev, `开始跟随事件流 ${opId}`]);
+        try {
+            const res = await fetch(`/api/operator/v1/operations/${encodeURIComponent(opId)}/events`, { credentials: "same-origin", signal: ac.signal });
+            if (!res.ok || !res.body) {
+                setSseLog((prev) => [...prev, `事件流 HTTP ${res.status}`]);
+                return;
+            }
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (followSse) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const chunks = buffer.split("\n\n");
+                buffer = chunks.pop() ?? "";
+                for (const chunk of chunks) {
+                    const dataLine = chunk
+                        .split("\n")
+                        .find((l) => l.startsWith("data:"));
+                    if (!dataLine)
+                        continue;
+                    const payload = dataLine.slice(5).trim();
+                    setSseLog((prev) => [...prev.slice(-80), payload.slice(0, 240)]);
+                }
+            }
+        }
+        catch (error) {
+            if (error.name !== "AbortError") {
+                setSseLog((prev) => [
+                    ...prev,
+                    `事件流错误：${error instanceof Error ? error.message : String(error)}`,
+                ]);
+            }
+        }
+    }, [followSse]);
+    useEffect(() => {
+        if (operationId && followSse && (step === "run" || nav === "recovery")) {
+            void followOperationEvents(operationId);
+        }
+        return () => sseAbort.current?.abort();
+    }, [operationId, followSse, step, nav, followOperationEvents]);
+    const stopFollowSse = useCallback(() => {
+        setFollowSse(false);
+        sseAbort.current?.abort();
+        setOpMessage("已停止跟随日志（未取消子进程）");
+    }, [setOpMessage]);
+    return {
+        runAction,
+        summarizeEnvelope,
+        isActionSuccess,
+        operationId,
+        setOperationId,
+        sseLog,
+        followSse,
+        setFollowSse,
+        stopFollowSse,
+        confirmationId,
+        setConfirmationId,
+        confirmationDetails,
+        setConfirmationDetails,
+    };
+}

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

@@ -0,0 +1,171 @@
+import { useCallback, useRef, useState } from "react";
+import { composePrdDocuments, importPrdFiles, validatePrdFileList, } from "../prd-file-import.js";
+/** PRD multi-file import: drag/drop + selection, primary-volume selection,
+ *  reorder/remove and composed-text regeneration with dirty tracking. */
+export function usePrdImport() {
+    const [prdText, setPrdText] = useState("# 需求\n\n实现 Loop Operator Console Happy Path：Interview → 契约落地 → DAG confirm → run。\n");
+    const [prdDocuments, setPrdDocuments] = useState([]);
+    const [prdPrimaryIndex, setPrdPrimaryIndex] = useState(0);
+    const [prdComposedDirty, setPrdComposedDirty] = useState(false);
+    const [prdFileError, setPrdFileError] = useState(null);
+    const [prdFileReading, setPrdFileReading] = useState(false);
+    const [prdDragOver, setPrdDragOver] = useState(false);
+    const prdDragDepth = useRef(0);
+    const prdImportGen = useRef(0);
+    const applyPrdComposition = useCallback((docs, primaryIndex) => {
+        const safePrimary = docs.length === 0
+            ? 0
+            : Math.min(Math.max(0, primaryIndex), docs.length - 1);
+        setPrdPrimaryIndex(safePrimary);
+        setPrdText(composePrdDocuments(docs, { primaryIndex: safePrimary }));
+        setPrdComposedDirty(false);
+    }, []);
+    const loadPrdFromFiles = useCallback(async (fileList) => {
+        const countError = validatePrdFileList(fileList, {
+            existingCount: prdDocuments.length,
+        });
+        if (countError) {
+            setPrdFileError(countError.message);
+            return;
+        }
+        const incoming = Array.from(fileList);
+        const gen = ++prdImportGen.current;
+        setPrdFileReading(true);
+        setPrdFileError(null);
+        try {
+            const result = await importPrdFiles(incoming);
+            if (gen !== prdImportGen.current)
+                return;
+            if (!result.ok) {
+                setPrdFileError(result.message);
+                return;
+            }
+            const nextDocs = [...prdDocuments, ...result.documents];
+            const nextPrimary = prdDocuments.length === 0 ? 0 : prdPrimaryIndex;
+            setPrdDocuments(nextDocs);
+            if (prdDocuments.length === 0 || !prdComposedDirty) {
+                applyPrdComposition(nextDocs, nextPrimary);
+                setPrdFileError(null);
+            }
+            else {
+                setPrdFileError("已追加文件，未改正文（正文已手动编辑）；可点「按文件重新合成」覆盖。");
+            }
+        }
+        catch {
+            if (gen !== prdImportGen.current)
+                return;
+            setPrdFileError("文件读取失败，请重试或直接粘贴");
+        }
+        finally {
+            if (gen === prdImportGen.current) {
+                setPrdFileReading(false);
+            }
+        }
+    }, [applyPrdComposition, prdComposedDirty, prdDocuments, prdPrimaryIndex]);
+    const onPrdTextChange = useCallback((value) => {
+        setPrdText(value);
+        if (prdDocuments.length > 0) {
+            setPrdComposedDirty(true);
+        }
+    }, [prdDocuments.length]);
+    const setPrimaryDocument = useCallback((index) => {
+        setPrdPrimaryIndex(index);
+        if (!prdComposedDirty) {
+            applyPrdComposition(prdDocuments, index);
+        }
+    }, [applyPrdComposition, prdComposedDirty, prdDocuments]);
+    const moveDocument = useCallback((index, delta) => {
+        const target = index + delta;
+        const next = [...prdDocuments];
+        const tmp = next[target];
+        next[target] = next[index];
+        next[index] = tmp;
+        const nextPrimary = prdPrimaryIndex === index
+            ? target
+            : prdPrimaryIndex === target
+                ? index
+                : prdPrimaryIndex;
+        setPrdDocuments(next);
+        setPrdPrimaryIndex(nextPrimary);
+        if (!prdComposedDirty) {
+            applyPrdComposition(next, nextPrimary);
+        }
+    }, [applyPrdComposition, prdComposedDirty, prdDocuments, prdPrimaryIndex]);
+    const removeDocument = useCallback((index) => {
+        const next = prdDocuments.filter((_, i) => i !== index);
+        const nextPrimary = next.length === 0
+            ? 0
+            : Math.min(prdPrimaryIndex >= index
+                ? Math.max(0, prdPrimaryIndex - 1)
+                : prdPrimaryIndex, Math.max(0, next.length - 1));
+        setPrdDocuments(next);
+        setPrdPrimaryIndex(nextPrimary);
+        if (next.length === 0) {
+            setPrdComposedDirty(false);
+        }
+        else if (!prdComposedDirty) {
+            applyPrdComposition(next, nextPrimary);
+        }
+    }, [applyPrdComposition, prdComposedDirty, prdDocuments, prdPrimaryIndex]);
+    const clearDocuments = useCallback(() => {
+        setPrdDocuments([]);
+        setPrdPrimaryIndex(0);
+        setPrdComposedDirty(false);
+        setPrdFileError(null);
+    }, []);
+    const recomposeDocuments = useCallback(() => {
+        if (prdComposedDirty &&
+            !window.confirm("将用当前文件列表重新合成正文，覆盖你在编辑区的修改。继续？")) {
+            return;
+        }
+        applyPrdComposition(prdDocuments, prdPrimaryIndex);
+        setPrdFileError(null);
+    }, [applyPrdComposition, prdComposedDirty, prdDocuments, prdPrimaryIndex]);
+    const onDragEnter = useCallback((e, disabled) => {
+        e.preventDefault();
+        e.stopPropagation();
+        if (disabled)
+            return;
+        prdDragDepth.current += 1;
+        setPrdDragOver(true);
+    }, []);
+    const onDragLeave = useCallback((e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        prdDragDepth.current = Math.max(0, prdDragDepth.current - 1);
+        if (prdDragDepth.current === 0) {
+            setPrdDragOver(false);
+        }
+    }, []);
+    const onDrop = useCallback((e, disabled) => {
+        e.preventDefault();
+        e.stopPropagation();
+        prdDragDepth.current = 0;
+        setPrdDragOver(false);
+        if (disabled)
+            return;
+        void loadPrdFromFiles(e.dataTransfer.files);
+    }, [loadPrdFromFiles]);
+    return {
+        prdText,
+        setPrdText,
+        onPrdTextChange,
+        prdDocuments,
+        prdPrimaryIndex,
+        prdComposedDirty,
+        prdFileError,
+        setPrdFileError,
+        prdFileReading,
+        prdDragOver,
+        loadPrdFromFiles,
+        applyPrdComposition,
+        setPrimaryDocument,
+        moveDocument,
+        removeDocument,
+        clearDocuments,
+        recomposeDocuments,
+        onDragEnter,
+        onDragLeave,
+        onDrop,
+    };
+}