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

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]);
+}

package/dist/worker/console/static-src/shell/workspace-route.js

@@ -0,0 +1,337 @@
+export function resolveRouteWorkspaceSelection(workspaceId, knownWorkspaceIds) {
+    const id = workspaceId?.trim();
+    if (!id)
+        return { status: "ok", workspaceId: undefined };
+    if (knownWorkspaceIds.includes(id))
+        return { status: "ok", workspaceId: id };
+    return { status: "unknown-workspace", workspaceId: id };
+}
+export const OPERATE_TAB_IDS = [
+    "tasks",
+    "recovery",
+    "night",
+    "models",
+    "settings",
+];
+export const LAST_OPERATE_TAB_STORAGE_KEY = "loop-console.operator-shell.last-operate-tab.v1";
+export const LAST_INSPECT_HASH_STORAGE_KEY = "loop-console.operator-shell.last-inspect-hash.v1";
+export const DEFAULT_OPERATE_TAB = "tasks";
+export const CHAT_HREF = "/#/chat";
+export const DEFAULT_INSPECT_HREF = "/#/inspect";
+export const DEFAULT_OPERATE_HREF = "/#/operate/tasks";
+const INSPECT_COLLECTION_OR_OBJECT = /^(dag|run|task|feature|batch|night|pool|failures|dags)(\/|$)/;
+export function splitHash(hashValue) {
+    const raw = String(hashValue ?? "").replace(/^#/, "");
+    const qIndex = raw.indexOf("?");
+    const pathPart = qIndex >= 0 ? raw.slice(0, qIndex) : raw;
+    const path = pathPart
+        ? pathPart.startsWith("/")
+            ? pathPart
+            : `/${pathPart}`
+        : "/";
+    const query = new URLSearchParams(qIndex >= 0 ? raw.slice(qIndex + 1) : "");
+    return { path, query };
+}
+export function stripInspectPrefix(path) {
+    if (path === "/inspect" || path === "/inspect/")
+        return "/";
+    if (path.startsWith("/inspect/"))
+        return path.slice("/inspect".length) || "/";
+    return path;
+}
+function isOperateTab(value) {
+    return (value === "tasks" ||
+        value === "recovery" ||
+        value === "night" ||
+        value === "models" ||
+        value === "settings");
+}
+function readParam(query, key) {
+    const value = query.get(key)?.trim();
+    return value || undefined;
+}
+function readWorkspaceParams(query) {
+    return {
+        ...(readParam(query, "taskId") ? { taskId: readParam(query, "taskId") } : {}),
+        ...(readParam(query, "dagRunId")
+            ? { dagRunId: readParam(query, "dagRunId") }
+            : {}),
+        ...(readParam(query, "fromNodeId")
+            ? { fromNodeId: readParam(query, "fromNodeId") }
+            : {}),
+        ...(readParam(query, "featureId")
+            ? { featureId: readParam(query, "featureId") }
+            : {}),
+        ...(readParam(query, "intent") ? { intent: readParam(query, "intent") } : {}),
+        ...(readParam(query, "workspaceId")
+            ? { workspaceId: readParam(query, "workspaceId") }
+            : {}),
+        ...(readParam(query, "sessionId")
+            ? { sessionId: readParam(query, "sessionId") }
+            : {}),
+    };
+}
+function paramsQuery(params) {
+    const query = new URLSearchParams();
+    for (const key of [
+        "taskId",
+        "dagRunId",
+        "fromNodeId",
+        "featureId",
+        "intent",
+        "workspaceId",
+        "sessionId",
+    ]) {
+        const value = params[key]?.trim();
+        if (value)
+            query.set(key, value);
+    }
+    return query.toString();
+}
+export function readLastOperateTab(storage) {
+    try {
+        const raw = storage?.getItem(LAST_OPERATE_TAB_STORAGE_KEY);
+        if (isOperateTab(raw))
+            return raw;
+    }
+    catch {
+        /* ignore */
+    }
+    return DEFAULT_OPERATE_TAB;
+}
+export function rememberOperateTab(tab, storage) {
+    try {
+        storage?.setItem(LAST_OPERATE_TAB_STORAGE_KEY, tab);
+    }
+    catch {
+        /* ignore */
+    }
+}
+export function readLastInspectHref(storage) {
+    try {
+        const raw = storage?.getItem(LAST_INSPECT_HASH_STORAGE_KEY)?.trim();
+        if (raw?.startsWith("/#/inspect"))
+            return raw;
+    }
+    catch {
+        /* ignore */
+    }
+    return DEFAULT_INSPECT_HREF;
+}
+export function rememberInspectHref(href, storage) {
+    const canonical = href.startsWith("/#/inspect")
+        ? href
+        : rewriteInspectHrefToCanonical(href);
+    if (!canonical.startsWith("/#/inspect"))
+        return;
+    try {
+        storage?.setItem(LAST_INSPECT_HASH_STORAGE_KEY, canonical);
+    }
+    catch {
+        /* ignore */
+    }
+}
+export function buildOperateHref(tab = DEFAULT_OPERATE_TAB, params = {}) {
+    const qs = paramsQuery(params);
+    return `/#/operate/${tab}${qs ? `?${qs}` : ""}`;
+}
+export function buildInspectHref(inspectPath = "/", query) {
+    const normalized = stripInspectPrefix(inspectPath.startsWith("/") ? inspectPath : `/${inspectPath}`);
+    const path = normalized === "/" || normalized === ""
+        ? "/inspect"
+        : `/inspect${normalized}`;
+    const qs = typeof query === "string"
+        ? query.replace(/^\?/, "")
+        : query?.toString() ?? "";
+    return `/#${path}${qs ? `?${qs}` : ""}`;
+}
+export function buildChatHref(params = {}) {
+    const qs = paramsQuery(params);
+    return qs ? `${CHAT_HREF}?${qs}` : CHAT_HREF;
+}
+/** Keep the selected Workspace on any canonical Console destination without
+ * changing its page-specific path or query state. */
+export function withWorkspaceId(href, workspaceId) {
+    const canonical = href.startsWith("/#")
+        ? href
+        : href.startsWith("#")
+            ? `/${href}`
+            : rewriteInspectHrefToCanonical(href);
+    const { path, query } = splitHash(canonical.slice(2));
+    const id = workspaceId?.trim();
+    if (id)
+        query.set("workspaceId", id);
+    else
+        query.delete("workspaceId");
+    const qs = query.toString();
+    return `/#${path}${qs ? `?${qs}` : ""}`;
+}
+export function buildCanonicalHref(input) {
+    if (input.workspace === "chat")
+        return buildChatHref(input);
+    if (input.workspace === "operate") {
+        return buildOperateHref(input.operateTab ?? DEFAULT_OPERATE_TAB, input);
+    }
+    return buildInspectHref(input.inspectPath ?? "/", input.inspectQuery);
+}
+function finishInspect(inspectPath, query, replace) {
+    const qs = query.toString();
+    const canonicalHref = buildInspectHref(inspectPath, qs);
+    return {
+        workspace: "inspect",
+        operateTab: DEFAULT_OPERATE_TAB,
+        inspectPath: stripInspectPrefix(inspectPath),
+        canonicalHash: canonicalHref.slice(2),
+        canonicalHref,
+        replace,
+        ...readWorkspaceParams(query),
+    };
+}
+function finishOperate(tab, query, replace) {
+    const canonicalHref = buildOperateHref(tab, readWorkspaceParams(query));
+    return {
+        workspace: "operate",
+        operateTab: tab,
+        inspectPath: "/",
+        canonicalHash: canonicalHref.slice(2),
+        canonicalHref,
+        replace,
+        ...readWorkspaceParams(query),
+    };
+}
+function finishChat(replace, params) {
+    const effective = params ?? {};
+    const canonicalHref = buildChatHref(effective);
+    return {
+        workspace: "chat",
+        operateTab: DEFAULT_OPERATE_TAB,
+        inspectPath: "/",
+        canonicalHash: canonicalHref.slice(2),
+        canonicalHref,
+        replace,
+        ...effective,
+    };
+}
+export function parseWorkspaceRoute(location, options = {}) {
+    const pathname = String(location.pathname ?? "/").replace(/\/+$/, "") || "/";
+    const lastTab = options.lastOperateTab ?? DEFAULT_OPERATE_TAB;
+    if (pathname === "/inspect") {
+        const { path, query } = splitHash(location.hash ?? "#/");
+        return finishInspect(path, query, true);
+    }
+    const { path, query } = splitHash(location.hash ?? "");
+    if (!location.hash || path === "/")
+        return null;
+    if (path === "/inspect" || path.startsWith("/inspect/")) {
+        return finishInspect(stripInspectPrefix(path), query, false);
+    }
+    if (path === "/chat")
+        return finishChat(false, readWorkspaceParams(query));
+    if (path === "/operate") {
+        return finishOperate(lastTab, query, true);
+    }
+    if (path.startsWith("/operate/")) {
+        const tab = path.slice("/operate/".length).split("/")[0] ?? "";
+        if (isOperateTab(tab))
+            return finishOperate(tab, query, false);
+        return finishOperate(lastTab, query, true);
+    }
+    if (isOperateTab(path.replace(/^\//, "").split("/")[0] ?? "")) {
+        const tab = path.replace(/^\//, "").split("/")[0];
+        return finishOperate(tab, query, true);
+    }
+    const inspectInternal = stripInspectPrefix(path).replace(/^\//, "");
+    if (INSPECT_COLLECTION_OR_OBJECT.test(inspectInternal)) {
+        return finishInspect(path, query, true);
+    }
+    return null;
+}
+export function rewriteInspectHrefToCanonical(href, base = typeof globalThis.location?.href === "string"
+    ? globalThis.location.href
+    : "http://local.invalid/") {
+    const raw = String(href ?? "").trim();
+    if (!raw)
+        return DEFAULT_INSPECT_HREF;
+    if (raw.startsWith("/#/inspect"))
+        return raw;
+    if (raw.startsWith("#/inspect"))
+        return `/${raw}`;
+    if (raw.startsWith("/#/operate") || raw.startsWith("/#/chat"))
+        return raw;
+    if (raw.startsWith("#/operate") || raw.startsWith("#/chat"))
+        return `/${raw}`;
+    try {
+        const url = new URL(raw, base);
+        const pathname = url.pathname.replace(/\/+$/, "") || "/";
+        if (pathname === "/inspect") {
+            const { path, query } = splitHash(url.hash || "#/");
+            const merged = new URLSearchParams(url.search);
+            for (const [key, value] of query)
+                merged.set(key, value);
+            return buildInspectHref(path, merged);
+        }
+        const { path, query } = splitHash(url.hash || "");
+        if (path === "/inspect" || path.startsWith("/inspect/")) {
+            return buildInspectHref(stripInspectPrefix(path), query);
+        }
+        const internal = path.replace(/^\//, "");
+        if (INSPECT_COLLECTION_OR_OBJECT.test(internal)) {
+            return buildInspectHref(path, query);
+        }
+    }
+    catch {
+        /* fall through */
+    }
+    if (raw.startsWith("#/") && INSPECT_COLLECTION_OR_OBJECT.test(raw.slice(2))) {
+        return buildInspectHref(raw.slice(1));
+    }
+    return DEFAULT_INSPECT_HREF;
+}
+export function isInspectDocumentHref(href, base = typeof globalThis.location?.href === "string"
+    ? globalThis.location.href
+    : "http://local.invalid/") {
+    try {
+        const url = new URL(String(href ?? ""), base);
+        const pathname = url.pathname.replace(/\/+$/, "") || "/";
+        if (pathname !== "/inspect")
+            return false;
+        return !/\.[a-z0-9]+$/i.test(url.pathname);
+    }
+    catch {
+        return false;
+    }
+}
+export function hrefToLocationHash(href) {
+    const canonical = href.startsWith("/#")
+        ? href
+        : href.startsWith("#")
+            ? `/${href}`
+            : rewriteInspectHrefToCanonical(href);
+    return canonical.startsWith("/#") ? canonical.slice(1) : canonical;
+}
+export function applyCanonicalHref(href) {
+    const hash = hrefToLocationHash(href);
+    if (typeof window === "undefined")
+        return hash;
+    const current = window.location.hash || "";
+    const normalizedCurrent = current.startsWith("#") ? current : `#${current}`;
+    const normalizedNext = hash.startsWith("#") ? hash : `#${hash}`;
+    if (normalizedCurrent !== normalizedNext) {
+        window.location.hash = normalizedNext;
+    }
+    return normalizedNext;
+}
+export function shouldCanonicalizeInspectDocument(location) {
+    const pathname = String(location.pathname ?? "/").replace(/\/+$/, "") || "/";
+    return pathname === "/inspect";
+}
+export function canonicalConsoleInspectHref(location) {
+    const { path, query } = splitHash(location.hash ?? "#/");
+    return buildInspectHref(path, query);
+}
+export function inspectInternalHash(hashValue) {
+    const { path, query } = splitHash(hashValue);
+    const internal = stripInspectPrefix(path);
+    const qs = query.toString();
+    return `${internal}${qs ? `?${qs}` : ""}`;
+}