@tea-agent/loop-agent 0.38.1 → 0.38.3

package/dist/worker/console/static-src/operator-chat/open-preview-in-browser.js

@@ -0,0 +1,328 @@
+/** Shown near the preview header when window.open is blocked or Blob/URL creation fails. */
+export const PREVIEW_OPEN_POPUP_BLOCKED = "无法在浏览器中打开：弹窗被拦截";
+export const PREVIEW_TRUNCATION_NOTICE = "内容已截断，以下为已加载片段。";
+/** Window features that force a real OS window instead of a browser tab.
+ *  Do not include `noopener` here: browsers then return null even on success. */
+export function previewOpenWindowFeatures(input) {
+    const availWidth = input?.availWidth ?? 1440;
+    const availHeight = input?.availHeight ?? 900;
+    const width = Math.min(1280, Math.max(880, Math.floor(availWidth * 0.82)));
+    const height = Math.min(960, Math.max(640, Math.floor(availHeight * 0.88)));
+    return [
+        "popup=yes",
+        `width=${width}`,
+        `height=${height}`,
+        "left=72",
+        "top=36",
+        "menubar=yes",
+        "toolbar=yes",
+        "location=yes",
+        "status=yes",
+        "resizable=yes",
+        "scrollbars=yes",
+    ].join(",");
+}
+export function escapeHtml(text) {
+    return text
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+function normalizedLanguage(language) {
+    return language.trim().toLowerCase();
+}
+export function isHtmlPreviewLanguage(language) {
+    const lang = normalizedLanguage(language);
+    return lang === "html" || lang === "htm";
+}
+export function isMarkdownPreviewLanguage(language) {
+    const lang = normalizedLanguage(language);
+    return lang === "md" || lang === "markdown";
+}
+function formatTextBody(preview) {
+    if (normalizedLanguage(preview.language) !== "json")
+        return preview.content;
+    try {
+        return JSON.stringify(JSON.parse(preview.content), null, 2);
+    }
+    catch {
+        return preview.content;
+    }
+}
+function isSafeHttpHref(href) {
+    return /^https?:\/\//i.test(href.trim());
+}
+function renderMarkdownInline(text) {
+    const withCode = [];
+    const coded = text.replace(/`([^`]+)`/g, (_all, code) => {
+        withCode.push(`<code>${code}</code>`);
+        return `\u0000${withCode.length - 1}\u0000`;
+    });
+    const linked = coded.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_all, label, href) => {
+        if (!isSafeHttpHref(href))
+            return label;
+        return `<a href="${href}" rel="noopener noreferrer" target="_blank">${label}</a>`;
+    });
+    const emphasized = linked
+        .replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>")
+        .replace(/__([^_]+)__/g, "<strong>$1</strong>")
+        .replace(/\*([^*]+)\*/g, "<em>$1</em>");
+    return emphasized.replace(/\u0000(\d+)\u0000/g, (_all, idx) => {
+        return withCode[Number(idx)] ?? "";
+    });
+}
+function flushParagraph(lines) {
+    if (!lines.length)
+        return "";
+    return `<p>${renderMarkdownInline(lines.join(" "))}</p>`;
+}
+function renderMarkdownBlocks(escaped) {
+    const lines = escaped.replaceAll("\r\n", "\n").split("\n");
+    const out = [];
+    let paragraph = [];
+    let listKind = null;
+    const closeList = () => {
+        if (listKind) {
+            out.push(listKind === "ul" ? "</ul>" : "</ol>");
+            listKind = null;
+        }
+    };
+    const closeParagraph = () => {
+        if (paragraph.length) {
+            out.push(flushParagraph(paragraph));
+            paragraph = [];
+        }
+    };
+    for (const line of lines) {
+        const heading = /^(#{1,6})\s+(.+)$/.exec(line);
+        if (heading) {
+            closeParagraph();
+            closeList();
+            const level = heading[1].length;
+            out.push(`<h${level}>${renderMarkdownInline(heading[2])}</h${level}>`);
+            continue;
+        }
+        if (/^---+$/.test(line.trim()) || /^\*\*\*+$/.test(line.trim())) {
+            closeParagraph();
+            closeList();
+            out.push("<hr>");
+            continue;
+        }
+        const quote = /^&gt;\s?(.*)$/.exec(line);
+        if (quote) {
+            closeParagraph();
+            closeList();
+            out.push(`<blockquote><p>${renderMarkdownInline(quote[1] ?? "")}</p></blockquote>`);
+            continue;
+        }
+        const ul = /^[-*]\s+(.+)$/.exec(line);
+        if (ul) {
+            closeParagraph();
+            if (listKind !== "ul") {
+                closeList();
+                out.push("<ul>");
+                listKind = "ul";
+            }
+            out.push(`<li>${renderMarkdownInline(ul[1])}</li>`);
+            continue;
+        }
+        const ol = /^\d+\.\s+(.+)$/.exec(line);
+        if (ol) {
+            closeParagraph();
+            if (listKind !== "ol") {
+                closeList();
+                out.push("<ol>");
+                listKind = "ol";
+            }
+            out.push(`<li>${renderMarkdownInline(ol[1])}</li>`);
+            continue;
+        }
+        if (line.trim() === "") {
+            closeParagraph();
+            closeList();
+            continue;
+        }
+        closeList();
+        paragraph.push(line);
+    }
+    closeParagraph();
+    closeList();
+    return out.join("\n");
+}
+/** Conservative Markdown → HTML for the detached reading tab. Input is escaped first. */
+export function renderMarkdownLite(source) {
+    const escaped = escapeHtml(source);
+    const chunks = [];
+    const fence = /```([^\n`]*)\n([\s\S]*?)```/g;
+    let last = 0;
+    let match;
+    while ((match = fence.exec(escaped))) {
+        if (match.index > last) {
+            chunks.push(renderMarkdownBlocks(escaped.slice(last, match.index)));
+        }
+        chunks.push(`<pre class="md-code"><code>${match[2] ?? ""}</code></pre>`);
+        last = match.index + match[0].length;
+    }
+    if (last < escaped.length) {
+        chunks.push(renderMarkdownBlocks(escaped.slice(last)));
+    }
+    return chunks.filter(Boolean).join("\n");
+}
+function readingPageCss() {
+    return `
+:root { color-scheme: light dark; }
+html, body { margin: 0; min-height: 100%; background: #f7f5f0; color: #1f1b16; }
+body { font: 16px/1.65 ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif; }
+.bar { position: sticky; top: 0; z-index: 1; display: flex; gap: 12px; align-items: center; padding: 10px 16px 10px 20px; border-bottom: 1px solid #e4ddd2; background: #fffdf8; }
+.bar .meta { min-width: 0; flex: 1; display: flex; flex-direction: column; gap: 2px; }
+.bar strong { font-size: 13px; font-weight: 650; word-break: break-all; }
+.bar .kind { color: #6b6258; font-size: 12px; }
+.modes { display: inline-flex; gap: 2px; padding: 2px; border: 1px solid #e4ddd2; border-radius: 8px; background: #f3eee6; }
+.modes button { appearance: none; border: 0; background: transparent; color: #6b6258; font: 12px/1.2 inherit; padding: 5px 10px; border-radius: 6px; cursor: pointer; }
+.modes button:hover { color: #1f1b16; }
+.modes button.is-active { background: #fff; color: #1f1b16; font-weight: 600; box-shadow: 0 1px 2px rgb(0 0 0 / 8%); }
+.notice { margin: 0; padding: 8px 20px; background: #fff6d8; color: #5c4b00; font-size: 13px; }
+.pane { display: none; }
+.pane.is-active { display: block; }
+.doc { max-width: 52rem; margin: 0 auto; padding: 32px 24px 96px; }
+.doc.md h1, .doc.md h2, .doc.md h3, .doc.md h4 { line-height: 1.25; margin: 1.4em 0 0.5em; }
+.doc.md h1 { font-size: 2rem; }
+.doc.md h2 { font-size: 1.45rem; }
+.doc.md p { margin: 0.8em 0; }
+.doc.md ul, .doc.md ol { margin: 0.6em 0; padding-left: 1.4em; }
+.doc.md blockquote { margin: 0.8em 0; padding: 0.2em 0.9em; border-left: 3px solid #d9cfc0; color: #4a433c; }
+.doc.md hr { border: 0; border-top: 1px solid #e4ddd2; margin: 1.6em 0; }
+.doc.md a { color: #0b57d0; }
+.doc.md code, .md-code, .source { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; font-size: 0.92em; }
+.doc.md :not(pre) > code { padding: 0.1em 0.35em; border-radius: 4px; background: #efe8dc; }
+.md-code, .source { margin: 1em 0; padding: 14px 16px; overflow: auto; white-space: pre-wrap; background: #fff; border: 1px solid #e4ddd2; border-radius: 8px; }
+.frame { margin: 0; padding: 0; }
+iframe.page { display: block; width: 100%; height: calc(100vh - 53px); border: 0; background: #fff; }
+`.trim();
+}
+function formattedSource(preview) {
+    return escapeHtml(formatTextBody(preview));
+}
+function previewPane(preview) {
+    if (isHtmlPreviewLanguage(preview.language)) {
+        return `<div class="frame"><iframe class="page" sandbox="" srcdoc="${escapeHtml(preview.content)}"></iframe></div>`;
+    }
+    if (isMarkdownPreviewLanguage(preview.language)) {
+        return `<article class="doc md">${renderMarkdownLite(preview.content)}</article>`;
+    }
+    return `<article class="doc"><pre class="source">${formattedSource(preview)}</pre></article>`;
+}
+function sourcePane(preview) {
+    return `<article class="doc"><pre class="source">${formattedSource(preview)}</pre></article>`;
+}
+function readingPageScript() {
+    return `<script>
+(function () {
+  var previewBtn = document.getElementById("view-preview");
+  var sourceBtn = document.getElementById("view-source");
+  var previewPane = document.getElementById("pane-preview");
+  var sourcePane = document.getElementById("pane-source");
+  if (!previewBtn || !sourceBtn || !previewPane || !sourcePane) return;
+  function show(mode) {
+    var source = mode === "source";
+    previewBtn.classList.toggle("is-active", !source);
+    sourceBtn.classList.toggle("is-active", source);
+    previewBtn.setAttribute("aria-pressed", String(!source));
+    sourceBtn.setAttribute("aria-pressed", String(source));
+    previewPane.classList.toggle("is-active", !source);
+    sourcePane.classList.toggle("is-active", source);
+  }
+  previewBtn.addEventListener("click", function () { show("preview"); });
+  sourceBtn.addEventListener("click", function () { show("source"); });
+})();
+</script>`;
+}
+/** Build the Blob document HTML from the already-loaded preview snapshot. */
+export function buildPreviewBrowserDocument(preview) {
+    const title = escapeHtml(preview.path);
+    const notice = preview.truncated
+        ? `<p class="notice">${escapeHtml(PREVIEW_TRUNCATION_NOTICE)}</p>`
+        : "";
+    const lang = normalizedLanguage(preview.language);
+    return `<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${title}</title>
+<style>
+${readingPageCss()}
+</style>
+</head>
+<body>
+<header class="bar">
+  <div class="meta">
+    <strong>${title}</strong>
+    <span class="kind">${escapeHtml(lang || "text")}${preview.truncated ? " · 已截断" : ""}</span>
+  </div>
+  <div class="modes" role="group" aria-label="查看模式">
+    <button type="button" id="view-preview" class="is-active" aria-pressed="true">预览</button>
+    <button type="button" id="view-source" aria-pressed="false">查看原文</button>
+  </div>
+</header>
+${notice}
+<div id="pane-preview" class="pane is-active">${previewPane(preview)}</div>
+<div id="pane-source" class="pane">${sourcePane(preview)}</div>
+${readingPageScript()}
+</body>
+</html>`;
+}
+function screenAvail() {
+    const screen = globalThis.screen;
+    return {
+        availWidth: screen?.availWidth,
+        availHeight: screen?.availHeight,
+    };
+}
+function defaultHost() {
+    const g = globalThis;
+    if (typeof g.open !== "function") {
+        throw new Error("window.open is unavailable");
+    }
+    return {
+        open: g.open.bind(g),
+        createObjectURL: g.URL.createObjectURL.bind(g.URL),
+        revokeObjectURL: g.URL.revokeObjectURL.bind(g.URL),
+    };
+}
+/**
+ * Open the current preview in a new OS window from already-loaded
+ * path/content/language/truncated. Does not fetch the repo file API again.
+ *
+ * Width/height window features ask the browser for a real window, not a tab.
+ * Do not pass `noopener` as a feature: browsers then return null even on
+ * success. Detach via `opener = null` after a real handle is obtained. Keep
+ * the Blob URL alive — revoking immediately blanks the page.
+ */
+export function openPreviewInBrowser(preview, host = defaultHost(), features = previewOpenWindowFeatures(screenAvail())) {
+    let objectUrl;
+    try {
+        const documentHtml = buildPreviewBrowserDocument(preview);
+        const blob = new Blob([documentHtml], { type: "text/html;charset=utf-8" });
+        objectUrl = host.createObjectURL(blob);
+        const opened = host.open(objectUrl, "_blank", features);
+        if (!opened) {
+            host.revokeObjectURL(objectUrl);
+            return { ok: false, error: PREVIEW_OPEN_POPUP_BLOCKED };
+        }
+        try {
+            opened.opener = null;
+        }
+        catch {
+            // Some hosts expose a frozen handle; the window is still open.
+        }
+        return { ok: true };
+    }
+    catch {
+        if (objectUrl)
+            host.revokeObjectURL(objectUrl);
+        return { ok: false, error: PREVIEW_OPEN_POPUP_BLOCKED };
+    }
+}

package/dist/worker/console/static-src/operator-chat/turn-stream-controller.js

@@ -31,6 +31,13 @@ export function operatorChatEventsUrl(origin, sessionId) {
 export function operatorChatAbortUrl(origin, sessionId, turnId) {
     return `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/turns/${encodeURIComponent(turnId)}/abort`;
 }
+export function turnPhaseFromOwnership(bag) {
+    if (bag.stoppingTurnId || bag.stopRequested)
+        return "stopping";
+    if (bag.activeTurnId || bag.streaming || bag.submitInFlight || bag.pendingSubmission)
+        return "running";
+    return "idle";
+}
 export function createTurnOwnershipBag(seed) {
     return {
         submitInFlight: false,
@@ -53,7 +60,7 @@ export function createTurnOwnershipBag(seed) {
 }
 /** Whether a second concurrent send is blocked by ownership / busy. */
 export function isSubmitOwnershipBusy(bag) {
-    return bag.streaming || bag.submitInFlight || Boolean(bag.pendingSubmission);
+    return turnPhaseFromOwnership(bag) !== "idle";
 }
 /**
  * Release submit ownership. Optionally scoped to a clientRequestId so a stale

package/dist/worker/console/static-src/operator-chat/turn-submission.js

@@ -3,6 +3,48 @@
  * Extracted so double-submit, TURN_ACTIVE adoption, transport ambiguity, and
  * generation fences can be unit-tested without mounting the full React tree.
  */
+/**
+ * Choose the submission path from the mutable ownership facts, never from a
+ * possibly stale React render. A stopping intent without a bound Turn must
+ * remain held until reconciliation binds or releases that ownership.
+ */
+export function decideSubmissionRoute(input) {
+    if (input.turnPhase === "stopping") {
+        return input.blockedByTurnId
+            ? {
+                action: "queue-deferred",
+                blockedByTurnId: input.blockedByTurnId,
+            }
+            : { action: "hold" };
+    }
+    return input.turnPhase === "idle" ? { action: "send-now" } : { action: "hold" };
+}
+/**
+ * Reconcile a deferred PUT that raced with Stop completion. The same
+ * clientRequestId may move to the normal POST path only after authoritative
+ * state proves that no Turn/runtime remains busy.
+ */
+export function reconcileDeferredSubmissionFromState(input) {
+    const { clientRequestId, blockedByTurnId, state } = input;
+    if (!state)
+        return { action: "hold" };
+    if (state.deferredTurn?.clientRequestId === clientRequestId) {
+        return { action: "deferred", deferredTurn: state.deferredTurn };
+    }
+    if (state.activeTurn?.clientRequestId === clientRequestId) {
+        return { action: "accepted", turn: state.activeTurn };
+    }
+    if (state.latestTurn?.clientRequestId === clientRequestId) {
+        return { action: "accepted", turn: state.latestTurn };
+    }
+    const activeTurnId = state.activeTurn?.turnId ?? state.activeTurnId ?? null;
+    if (state.turnPhase === "stopping" && activeTurnId === blockedByTurnId) {
+        return { action: "retry-deferred" };
+    }
+    if (!isRuntimeBusyUnion(state))
+        return { action: "send-now" };
+    return { action: "hold" };
+}
 export function createPendingSubmission(input) {
     let resolveOutcome;
     const outcomePromise = new Promise((resolve) => {

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

@@ -218,6 +218,9 @@ export function useChatSessions(params) {
                 messages: hydrated.messages,
                 toolCalls: hydrated.toolCalls,
                 streaming: Boolean(body.session.activeTurnId),
+                turnPhase: body.session.turnPhase ??
+                    (body.session.activeTurnId ? "running" : "idle"),
+                deferredTurn: body.session.deferredTurn ?? null,
             });
             window.localStorage.setItem(ACTIVE_CHAT_SESSION_STORAGE_KEY, sessionId);
             setActivePreviewPath(null);