@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/worker/console/static-src/operator-chat/resource-auto-invocation.js

@@ -0,0 +1,91 @@
+/**
+ * Operator Chat — Skills panel auto-invocation mutation client.
+ *
+ * Real PATCH only (contract mockApi.strategy = not-needed). Fail closed on
+ * write errors; adopt returned snapshot when reloadApplied; surface partial
+ * busy (preference saved, reload pending) without aborting the turn.
+ */
+import { parseRuntimeSnapshotError } from "./runtime-snapshot-store.js";
+function autoInvocationUrl(origin, sessionId, resourceId) {
+    return `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/skills/${encodeURIComponent(resourceId)}/auto-invocation`;
+}
+/**
+ * PATCH skill auto-invocation preference for the current session's repo.
+ * Never comments out or replaces the real request path.
+ */
+export async function patchSkillAutoInvocation(input) {
+    const fetchImpl = input.fetchImpl ?? fetch;
+    try {
+        const res = await fetchImpl(autoInvocationUrl(input.origin, input.sessionId, input.resourceId), {
+            method: "PATCH",
+            credentials: "include",
+            headers: {
+                "content-type": "application/json",
+                "x-loop-console-confirmation": input.confirmationToken,
+            },
+            body: JSON.stringify({
+                autoInvocationEnabled: input.autoInvocationEnabled,
+            }),
+        });
+        const body = (await res.json().catch(() => ({})));
+        if (!res.ok || body.ok === false) {
+            return {
+                ok: false,
+                error: {
+                    ...parseRuntimeSnapshotError(body),
+                    status: res.status,
+                },
+            };
+        }
+        const preferenceSaved = body.preferenceSaved === true;
+        const reloadApplied = body.reloadApplied === true;
+        if (!preferenceSaved) {
+            return {
+                ok: false,
+                error: {
+                    status: res.status,
+                    code: "PI_RESOURCE_PREFERENCES_WRITE_FAILED",
+                    message: "preference was not saved",
+                },
+            };
+        }
+        if (!reloadApplied) {
+            const code = body.error?.code ?? "PI_SESSION_BUSY";
+            const message = body.error?.message ??
+                "preference saved; current session is busy and was not reloaded";
+            return {
+                ok: true,
+                preferenceSaved: true,
+                reloadApplied: false,
+                ...(body.snapshot ? { snapshot: body.snapshot } : {}),
+                partialBusy: { code, message },
+            };
+        }
+        return {
+            ok: true,
+            preferenceSaved: true,
+            reloadApplied: true,
+            ...(body.snapshot ? { snapshot: body.snapshot } : {}),
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: {
+                message: error instanceof Error ? error.message : String(error),
+            },
+        };
+    }
+}
+export function autoInvocationStatusCopy(skill) {
+    if (skill.autoInvocationEnabled) {
+        return {
+            badge: "允许自动使用",
+            help: "模型可自动选择该技能，也可通过 /skill:<name> 手动调用。",
+        };
+    }
+    return {
+        badge: "已隐藏自动使用",
+        help: `已从模型自动技能列表隐藏，仍可通过 /skill:${skill.name} 手动调用。`,
+    };
+}

package/dist/worker/console/static-src/operator-chat/resource-diagnostics.js

@@ -0,0 +1,204 @@
+/**
+ * Resource-panel diagnostics presentation.
+ *
+ * Pi ResourceLoader emits machine English (`warning` / `collision` + full
+ * Windows paths). The Skills / Packages / Models panels must not dump that
+ * block above the inventory — it pushes the list off-screen. Classify here,
+ * then render a header chip + grouped popover with natural Chinese copy.
+ */
+const COLLISION_NAME = /name\s+"([^"]+)"\s+collision/i;
+const INVALID_CHARS = /invalid characters|must be lowercase/i;
+const INVALID_EDGE_HYPHEN = /must not start or end with a hyphen/i;
+const INVALID_DOUBLE_HYPHEN = /consecutive hyphens/i;
+const GROUP_COPY = {
+    "load-failed": {
+        heading: "需要处理",
+        hint: "有些清单没读完整，下面的列表可能不全。",
+    },
+    "invalid-name": {
+        heading: "名称不规范",
+        hint: "技能已经加载，还能用。名称请改成小写字母、数字和连字符，例如 sdd-requirement-analysis。",
+    },
+    collision: {
+        heading: "同名未生效",
+        hint: "同名技能只保留先扫到的那一份，后面的不会进当前会话。",
+    },
+    other: {
+        heading: "其他提示",
+        hint: "不影响你浏览当前列表。",
+    },
+};
+const GROUP_ORDER = [
+    "load-failed",
+    "invalid-name",
+    "collision",
+    "other",
+];
+export function shortResourcePath(path) {
+    if (!path)
+        return undefined;
+    const parts = path.replace(/\\/g, "/").split("/").filter(Boolean);
+    if (parts.length === 0)
+        return path;
+    const file = parts.at(-1);
+    if (!file)
+        return path;
+    const parent = parts.at(-2);
+    return parent ? `${parent}/${file}` : file;
+}
+export function skillNameFromPath(path) {
+    if (!path)
+        return undefined;
+    const parts = path.replace(/\\/g, "/").split("/").filter(Boolean);
+    if (parts.length === 0)
+        return undefined;
+    const last = parts.at(-1);
+    if (!last)
+        return undefined;
+    if (/^skill\.md$/i.test(last) && parts.length >= 2) {
+        return parts.at(-2);
+    }
+    return last.replace(/\.md$/i, "");
+}
+export function diagnosticMatchesSkill(item, skill) {
+    if (item.path) {
+        const left = item.path.replace(/\\/g, "/").toLowerCase();
+        const right = skill.path.replace(/\\/g, "/").toLowerCase();
+        if (left === right || left.endsWith(right) || right.endsWith(left)) {
+            return true;
+        }
+    }
+    return Boolean(item.skillName && item.skillName === skill.name);
+}
+function shortenMessage(message) {
+    const trimmed = message.trim();
+    if (trimmed.length <= 80)
+        return trimmed;
+    return `${trimmed.slice(0, 79)}…`;
+}
+function titleForLoadFailed(diag) {
+    const hay = `${diag.code ?? ""} ${diag.message}`.toLowerCase();
+    if (hay.includes("preference"))
+        return "自动使用偏好读不出来";
+    if (hay.includes("package"))
+        return "软件包清单没读完整";
+    if (hay.includes("skill"))
+        return "技能清单没读完整";
+    if (hay.includes("extension"))
+        return "扩展没读完整";
+    if (hay.includes("prompt"))
+        return "提示词没读完整";
+    if (hay.includes("theme"))
+        return "主题没读完整";
+    if (hay.includes("context"))
+        return "上下文文件没读完整";
+    return "有些内容没读完整";
+}
+function detailForInvalidName(message) {
+    if (INVALID_DOUBLE_HYPHEN.test(message)) {
+        return "名称里不要连用两个连字符。现在这样也能用。";
+    }
+    if (INVALID_EDGE_HYPHEN.test(message)) {
+        return "名称开头和结尾不要用连字符。现在这样也能用。";
+    }
+    return "名称请只用小写字母、数字和连字符。现在这样也能用。";
+}
+export function classifyResourceDiagnostic(diag) {
+    const type = (diag.type ?? "warning").toLowerCase();
+    const message = diag.message ?? "";
+    const collisionMatch = message.match(COLLISION_NAME) ??
+        (type === "collision" ? message.match(/"([^"]+)"/) : null);
+    if (type === "collision" || collisionMatch) {
+        const skillName = collisionMatch?.[1] ?? skillNameFromPath(diag.path);
+        return {
+            kind: "collision",
+            tone: "warning",
+            title: skillName ? `「${skillName}」有多份` : "有一份同名技能没生效",
+            detail: "同名只保留先扫到的那一份，这份被盖掉了。",
+            path: diag.path,
+            shortPath: shortResourcePath(diag.path),
+            skillName,
+            retryable: false,
+        };
+    }
+    if (INVALID_CHARS.test(message) ||
+        INVALID_EDGE_HYPHEN.test(message) ||
+        INVALID_DOUBLE_HYPHEN.test(message)) {
+        const skillName = skillNameFromPath(diag.path);
+        return {
+            kind: "invalid-name",
+            tone: "warning",
+            title: skillName ?? "有个技能名称不合规范",
+            detail: detailForInvalidName(message),
+            path: diag.path,
+            shortPath: shortResourcePath(diag.path),
+            skillName,
+            retryable: false,
+        };
+    }
+    const isLoadFailed = type === "error" ||
+        diag.retryable === true ||
+        diag.code === "RESOURCE_LOAD_FAILED" ||
+        diag.code === "PACKAGE_INVENTORY_FAILED" ||
+        diag.code === "PI_RESOURCE_PREFERENCES_MALFORMED";
+    if (isLoadFailed) {
+        return {
+            kind: "load-failed",
+            tone: "error",
+            title: titleForLoadFailed(diag),
+            detail: shortenMessage(message),
+            path: diag.path,
+            shortPath: shortResourcePath(diag.path),
+            retryable: diag.retryable === true,
+        };
+    }
+    return {
+        kind: "other",
+        tone: type === "error" ? "error" : "warning",
+        title: shortenMessage(message) || "一条提示",
+        path: diag.path,
+        shortPath: shortResourcePath(diag.path),
+        retryable: false,
+    };
+}
+export function summarizeResourceDiagnostics(diagnostics) {
+    const items = diagnostics.map(classifyResourceDiagnostic);
+    const buckets = new Map();
+    for (const item of items) {
+        const list = buckets.get(item.kind) ?? [];
+        list.push(item);
+        buckets.set(item.kind, list);
+    }
+    const groups = GROUP_ORDER.flatMap((kind) => {
+        const groupItems = buckets.get(kind);
+        if (!groupItems?.length)
+            return [];
+        return [{ kind, ...GROUP_COPY[kind], items: groupItems }];
+    });
+    const errorCount = items.filter((item) => item.tone === "error").length;
+    const warningCount = items.length - errorCount;
+    return {
+        total: items.length,
+        errorCount,
+        warningCount,
+        chipLabel: chipLabel(errorCount, warningCount),
+        groups,
+    };
+}
+function chipLabel(errorCount, warningCount) {
+    if (errorCount > 0 && warningCount > 0) {
+        return `${errorCount} 个问题 · ${warningCount} 条提示`;
+    }
+    if (errorCount > 0) {
+        return errorCount === 1 ? "1 个问题" : `${errorCount} 个问题`;
+    }
+    if (warningCount === 1)
+        return "1 条提示";
+    return `${warningCount} 条提示`;
+}
+export function skillHasNameWarning(skill, items) {
+    return items.some((item) => item.kind === "invalid-name" && diagnosticMatchesSkill(item, skill));
+}
+export function noticesForSkill(skill, items) {
+    return items.filter((item) => item.kind !== "collision" && diagnosticMatchesSkill(item, skill));
+}

package/dist/worker/console/static-src/operator-chat/runtime-snapshot-store.js

@@ -0,0 +1,257 @@
+/**
+ * Operator Chat — runtime snapshot store (design §2.2 / AC-04/05/06).
+ *
+ * A pure, framework-free state machine for the unified Live Runtime Snapshot.
+ * The browser treats the current Pi session as the single source of truth:
+ *
+ *   status: idle → loading → ready | error
+ *   reload: reloading (single-flight; no silent queueing) → success | failure
+ *
+ * `createRuntimeSnapshotStore` is intentionally side-effect free so it can be
+ * unit-tested in a plain Node environment; the React binding (fetch + attach)
+ * lives in `useRuntimeSnapshot.ts`.
+ */
+export const runtimeSnapshotInitialState = {
+    status: "idle",
+    snapshot: null,
+    error: null,
+    reloading: false,
+    reloadError: null,
+    mutationBusy: false,
+    mutationToken: null,
+};
+/** Parse a failed HTTP body into a structured snapshot error (never empty). */
+export function parseRuntimeSnapshotError(body) {
+    if (!body || typeof body !== "object") {
+        return { message: "runtime snapshot request failed" };
+    }
+    const record = body;
+    const err = record.error;
+    if (err && typeof err === "object") {
+        const e = err;
+        return {
+            ...(typeof e.code === "string" && e.code ? { code: e.code } : {}),
+            ...(typeof record.status === "number" ? { status: record.status } : {}),
+            message: typeof e.message === "string" && e.message
+                ? e.message
+                : "runtime snapshot request failed",
+        };
+    }
+    return {
+        ...(typeof record.status === "number" ? { status: record.status } : {}),
+        message: typeof record === "object" && "message" in record &&
+            typeof record.message === "string" &&
+            record.message
+            ? record.message
+            : "runtime snapshot request failed",
+    };
+}
+export function runtimeSnapshotReducer(state, action) {
+    switch (action.type) {
+        case "load-start":
+            // Stale replies are dropped by the fetch layer (sessionId guard); the
+            // reducer stays a deterministic state machine. The previous snapshot
+            // remains visible during a background refresh.
+            return {
+                ...state,
+                sessionId: action.sessionId,
+                status: "loading",
+                error: null,
+            };
+        case "load-success":
+            // RF-04: monotonic revision guard — a stale (lower-revision) reply for
+            // the current session must never overwrite a newer snapshot, so a slow
+            // refresh cannot reorder-overwrite the current session selection. The
+            // fetch layer already drops replies for other sessions (sessionId guard).
+            if (state.snapshot &&
+                state.sessionId === action.sessionId &&
+                action.snapshot.revision < state.snapshot.revision) {
+                return state;
+            }
+            return {
+                ...state,
+                sessionId: action.sessionId,
+                status: "ready",
+                snapshot: action.snapshot,
+                error: null,
+                reloadError: null,
+                reloading: false,
+            };
+        case "load-failure":
+            // AC-06: a failed load is a STRUCTURED error state — never folded
+            // into a fake empty snapshot.
+            return {
+                ...state,
+                sessionId: action.sessionId,
+                status: "error",
+                error: action.error,
+                snapshot: null,
+            };
+        case "reload-start":
+            // Single-flight: a reload already in progress is NOT queued (AC-06).
+            if (state.reloading)
+                return state;
+            return {
+                ...state,
+                reloading: true,
+                reloadError: null,
+                ...(state.status === "error" ? { error: null } : {}),
+            };
+        case "reload-success":
+            // Atomic replacement: the new snapshot supersedes the old one and
+            // every open panel reads the same revision.
+            return {
+                ...state,
+                status: "ready",
+                snapshot: action.snapshot,
+                reloading: false,
+                reloadError: null,
+                error: null,
+                sessionId: action.snapshot.sessionId || state.sessionId,
+            };
+        case "reload-failure":
+            return {
+                ...state,
+                reloading: false,
+                reloadError: action.error,
+            };
+        case "mutation-start":
+            return {
+                ...state,
+                mutationBusy: true,
+                mutationToken: action.token,
+            };
+        case "mutation-adopt":
+            // RF2-02: atomic adoption of a mutation response snapshot. Three
+            // guards are evaluated BEFORE any write:
+            //   - mutationToken: only the LATEST mutation may adopt — a stale
+            //     out-of-order response is dropped entirely;
+            //   - sessionId: never adopt a mutation response into a state that
+            //     belongs to a different session;
+            //   - revision monotonic: equal/higher revisions adopt, lower reject
+            //     (a stale reply can never reorder-overwrite the selection).
+            // The action NEVER settles mutationBusy (mutation-settle owns that)
+            // and never passes through an intermediate stale/loading state.
+            if (state.mutationToken !== action.token)
+                return state;
+            if (state.sessionId !== undefined &&
+                state.sessionId !== action.sessionId)
+                return state;
+            if (state.snapshot &&
+                action.snapshot.revision < state.snapshot.revision)
+                return state;
+            return {
+                ...state,
+                sessionId: action.sessionId,
+                status: "ready",
+                snapshot: action.snapshot,
+                error: null,
+                reloadError: null,
+                reloading: false,
+            };
+        case "mutation-settle":
+            // RF-04: only the LATEST request token settles the busy state; a
+            // stale (earlier) settle must not clear busy while a newer mutation
+            // is still in flight.
+            if (state.mutationToken !== action.token)
+                return state;
+            return {
+                ...state,
+                mutationBusy: false,
+                mutationToken: null,
+            };
+        case "mutation-reset":
+            // RF3-02: a session switch immediately abandons the in-flight
+            // mutation lifecycle — the new session must not inherit the old
+            // session's busy state. The adopted snapshot/status stay untouched
+            // (a load-start for the new session follows); stale adopt/settle
+            // actions then become no-ops via the token + sessionId guards.
+            return {
+                ...state,
+                mutationBusy: false,
+                mutationToken: null,
+            };
+        case "reset":
+            return { ...runtimeSnapshotInitialState };
+        default:
+            return state;
+    }
+}
+/**
+ * Derive the session/runtimeContext selection patch from an ADOPTED snapshot
+ * (RF3-01). The hydrate effect in `useRuntimeControls` feeds this patch into
+ * `mergeSessionRuntime` / `runtimeContext`, so derived state only ever comes
+ * from a snapshot the reducer guards accepted — the mutation success branch
+ * never writes session/runtimeContext directly. Missing fields are omitted;
+ * `auto` resolves to the Pi effective thinking level.
+ */
+export function runtimeSelectionFromSnapshot(snapshot) {
+    const selection = snapshot.selection;
+    return {
+        ...(selection.model
+            ? {
+                model: {
+                    provider: selection.model.provider,
+                    modelId: selection.model.id,
+                },
+            }
+            : {}),
+        ...(selection.thinkingSelection === "auto"
+            ? selection.effectiveThinkingLevel
+                ? { thinkingLevel: selection.effectiveThinkingLevel }
+                : {}
+            : { thinkingLevel: selection.thinkingSelection }),
+    };
+}
+/**
+ * RF4: merge an incoming `/runtime-context` response with the ADOPTED snapshot
+ * (coordination seam genuinely called by the production `useRuntimeControls`
+ * context hydration effect; tests import this same symbol — no copied logic).
+ *
+ * Content fields (systemPrompt/resources/suffix/readOnly) always come from the
+ * response. model/thinkingLevel NEVER come from the response body — the
+ * backend returns them without revision semantics, so a late reply for the
+ * same session could carry a stale selection. Selection is derived exclusively
+ * from the adopted snapshot when it matches the current session (same
+ * derivation as the snapshot hydration effect: `runtimeSelectionFromSnapshot`,
+ * `auto` resolves to the Pi effective level); otherwise the current derived
+ * values are preserved, or omitted when absent. The store is never written
+ * here, so the snapshot hydration effect never re-runs.
+ */
+export function mergeRuntimeContextWithSnapshot(current, context, snapshot, sessionId) {
+    const selection = snapshot && snapshot.sessionId === sessionId
+        ? runtimeSelectionFromSnapshot(snapshot)
+        : {};
+    const model = selection.model ?? current?.model;
+    const thinkingLevel = selection.thinkingLevel ?? current?.thinkingLevel;
+    return {
+        readOnly: context.readOnly,
+        systemPrompt: context.systemPrompt,
+        resources: context.resources,
+        suffix: context.suffix,
+        ...(model ? { model } : {}),
+        ...(thinkingLevel ? { thinkingLevel } : {}),
+    };
+}
+/** Create a fresh snapshot store (framework-free; React binding adds fetch). */
+export function createRuntimeSnapshotStore(initial = runtimeSnapshotInitialState) {
+    let state = initial;
+    const listeners = new Set();
+    return {
+        getState: () => state,
+        dispatch: (action) => {
+            state = runtimeSnapshotReducer(state, action);
+            for (const listener of listeners)
+                listener();
+            return state;
+        },
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}
+/** True when the given error is the busy 409 (PI_SESSION_BUSY). */
+export function isSnapshotBusyError(error) {
+    return error?.code === "PI_SESSION_BUSY";
+}

package/dist/worker/console/static-src/operator-chat/session-title-watcher.js

@@ -0,0 +1,128 @@
+/**
+ * Owns title-only SSE lifecycles. It is deliberately independent from the
+ * timeline SSE applier: title frames update the session index only.
+ */
+export class SessionTitleWatcher {
+    options;
+    eligible = new Set();
+    controllers = new Map();
+    fetchFn;
+    backoffMs;
+    deadlineMs;
+    constructor(options) {
+        this.options = options;
+        this.fetchFn = options.fetchFn ?? fetch;
+        this.backoffMs = options.backoffMs ?? 1_000;
+        this.deadlineMs = options.deadlineMs ?? 30_000;
+    }
+    markEligible(sessionId) {
+        this.eligible.add(sessionId);
+    }
+    startIfEligible(sessionId) {
+        if (!this.eligible.delete(sessionId) || this.controllers.has(sessionId))
+            return;
+        const controller = new AbortController();
+        this.controllers.set(sessionId, controller);
+        void this.run(sessionId, controller);
+    }
+    cancel(sessionId) {
+        this.eligible.delete(sessionId);
+        this.controllers.get(sessionId)?.abort();
+        this.controllers.delete(sessionId);
+    }
+    reconcile(sessionIds) {
+        const current = new Set(sessionIds);
+        for (const sessionId of this.controllers.keys()) {
+            if (!current.has(sessionId))
+                this.cancel(sessionId);
+        }
+    }
+    dispose() {
+        for (const controller of this.controllers.values())
+            controller.abort();
+        this.controllers.clear();
+        this.eligible.clear();
+    }
+    async run(sessionId, controller) {
+        let lastEventId;
+        const seen = new Set();
+        let deadlineReached = false;
+        const deadline = window.setTimeout(() => {
+            deadlineReached = true;
+            controller.abort();
+        }, this.deadlineMs);
+        try {
+            while (!controller.signal.aborted) {
+                try {
+                    const headers = { Accept: "text/event-stream" };
+                    if (lastEventId)
+                        headers["Last-Event-ID"] = lastEventId;
+                    const response = await this.fetchFn(`${this.options.origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/events`, { headers, credentials: "include", signal: controller.signal });
+                    if (response.status === 404 || !response.body)
+                        return;
+                    if (!response.ok)
+                        throw new Error(`HTTP ${response.status}`);
+                    const reader = response.body.getReader();
+                    const decoder = new TextDecoder();
+                    let buffer = "";
+                    for (;;) {
+                        const { done, value } = await reader.read();
+                        if (done || controller.signal.aborted)
+                            break;
+                        buffer += decoder.decode(value, { stream: true });
+                        const blocks = buffer.split("\n\n");
+                        buffer = blocks.pop() ?? "";
+                        for (const block of blocks) {
+                            const eventId = block.split("\n").find((line) => line.startsWith("id: "))?.slice(4);
+                            if (eventId)
+                                lastEventId = eventId;
+                            if (!eventId || seen.has(eventId) || !block.includes("event: session_title"))
+                                continue;
+                            const data = block.split("\n").find((line) => line.startsWith("data: "))?.slice(6);
+                            if (!data)
+                                continue;
+                            try {
+                                const parsed = JSON.parse(data);
+                                const title = parsed.data?.title?.trim();
+                                if (!title)
+                                    continue;
+                                seen.add(eventId);
+                                if (!this.options.hasSession(sessionId))
+                                    return;
+                                this.options.onTitle(sessionId, { title, automatic: Boolean(parsed.data?.automatic) });
+                                if (parsed.data?.automatic)
+                                    return;
+                            }
+                            catch { /* malformed title frames are ignored */ }
+                        }
+                    }
+                }
+                catch {
+                    if (controller.signal.aborted)
+                        return;
+                }
+                if (!controller.signal.aborted)
+                    await abortableSleep(this.backoffMs, controller.signal);
+            }
+        }
+        finally {
+            window.clearTimeout(deadline);
+            if (this.controllers.get(sessionId) === controller)
+                this.controllers.delete(sessionId);
+            if (deadlineReached || !this.options.hasSession(sessionId))
+                void this.options.refresh();
+        }
+    }
+}
+function abortableSleep(ms, signal) {
+    return new Promise((resolve) => {
+        const timer = window.setTimeout(done, ms);
+        const onAbort = () => done();
+        function done() {
+            window.clearTimeout(timer);
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}