@tea-agent/loop-agent 0.38.2 → 0.38.4

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/loop-agent/loop-agent-client.js

@@ -292,9 +292,13 @@ function assertControllerIdentityUnchangedBeforeSpawn(identity) {
     }
 }
 function controllerIdentityDriftError(message, cause) {
-    return new Error(`controller identity changed before spawn: ${message}`, {
-        cause,
-    });
+    // Preserve the raw drift detail verbatim; the actionable suffix serves
+    // every consumer surface — operation errorMessage, SSE events, and agent/
+    // API callers that never reach the UI translation layer — with the exact
+    // recovery step: the running Console holds a stale controller fingerprint
+    // after rebuilds or commits touching fingerprint-scoped paths
+    // (package.json, bin/**, dist/**, skills/**).
+    return new Error(`controller identity changed before spawn: ${message}. Fix: restart the Console process so it re-resolves the current build, then retry the operation; avoid rebuilding or committing fingerprint-scoped files (package.json, bin/**, dist/**, skills/**) mid-session.`, { cause });
 }
 /**
  * Detect whether loopAgentBin is a Node-like executable and baseArgs

package/dist/worker/observe/node-input.js

@@ -2,7 +2,8 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
 import { resolveDagNodeSkills } from "../../workflows/dag/skills.js";
-import { resolveDagNodePromptRedacted, resolveDagRunJson, } from "./dag-run-artifacts.js";
+import { resolveDagNodePromptRedacted, resolveDagRunArtifact, resolveDagRunJson, } from "./dag-run-artifacts.js";
+import { namedShellHandlers } from "./shell-handler-keys.js";
 export const NODE_INPUT_SCHEMA_VERSION = 1;
 export const NODE_INPUT_PREVIEW_MAX_BYTES = 64 * 1024;
 const SHELL_GATE_KEYS = [
@@ -33,6 +34,7 @@ function unavailableBody(dagRunId, nodeId, reason, warnings = []) {
         executorInput: null,
         boundaries: null,
         promptFingerprint: null,
+        piExtensionRunFacts: null,
         warnings,
     };
 }
@@ -137,7 +139,7 @@ function resolveModelHint(spec, task) {
     }
     return null;
 }
-function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warnings) {
+function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExtensionRunFacts, warnings) {
     const defaults = spec.defaults && typeof spec.defaults === "object"
         ? spec.defaults
         : undefined;
@@ -216,6 +218,7 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
                 : null,
             failFast: typeof shellRaw.failFast === "boolean" ? shellRaw.failFast : null,
             gates: shellGateNames(shellRaw),
+            handlers: namedShellHandlers(shellRaw),
         }
         : null;
     const staticPreview = staticRaw && typeof staticRaw.resultMarkdown === "string"
@@ -268,6 +271,7 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
             kind,
             skills,
             modelHint: resolveModelHint(spec, task),
+            piExtensions: redactStringList(task.piExtensions),
             shell,
             static: staticBlock,
         },
@@ -284,9 +288,72 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
                 : null,
         },
         promptFingerprint: fingerprint,
+        piExtensionRunFacts,
         warnings,
     };
 }
+/**
+ * Load run-time Pi extension facts from <node>/pi-extensions.json (plan
+ * 2026-08-22 R2). Returns null when the node declares no piExtensions
+ * (no expected artifact). Never throws: unreadable/corrupt artifacts degrade
+ * to parseError stubs so the node-input endpoint stays 200.
+ */
+async function loadPiExtensionRunFacts(repoRoot, dagRunId, nodeId, declared, warnings) {
+    if (declared.length === 0)
+        return null;
+    const artifact = path.posix.join(nodeId, "pi-extensions.json");
+    const resolved = resolveDagRunArtifact(repoRoot, dagRunId, [
+        nodeId,
+        "pi-extensions.json",
+    ]);
+    if (!resolved.ok) {
+        if (resolved.reason === "ambiguous") {
+            warnings.push("Ambiguous pi-extensions.json lifecycle copies.");
+        }
+        return {
+            artifact,
+            exists: false,
+            requested: [...declared],
+            resolved: [],
+            missing: [],
+        };
+    }
+    const empty = {
+        artifact,
+        exists: false,
+        requested: [...declared],
+        resolved: [],
+        missing: [],
+    };
+    try {
+        const raw = JSON.parse(await readFile(resolved.result.absolutePath, "utf-8"));
+        const resolvedList = Array.isArray(raw.resolved) ? raw.resolved : [];
+        const missingList = Array.isArray(raw.missing) ? raw.missing : [];
+        const projected = resolvedList
+            .filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry))
+            .map((entry) => ({
+            id: redactSecrets(String(entry.id ?? "")),
+            packageName: redactSecrets(String(entry.packageName ?? "")),
+            version: redactSecrets(String(entry.version ?? "")),
+        }));
+        const missingProjected = missingList
+            .filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry))
+            .map((entry) => ({
+            id: redactSecrets(String(entry.id ?? "")),
+            reason: redactSecrets(String(entry.reason ?? "")),
+        }));
+        return {
+            artifact,
+            exists: true,
+            requested: redactStringList(raw.requested ?? declared),
+            resolved: projected,
+            missing: missingProjected,
+        };
+    }
+    catch {
+        return { ...empty, parseError: "read-failed" };
+    }
+}
 async function loadPromptFingerprint(repoRoot, dagRunId, nodeId, warnings) {
     const resolved = resolveDagNodePromptRedacted(repoRoot, dagRunId, nodeId);
     if (!resolved.ok) {
@@ -415,8 +482,12 @@ export async function buildDagNodeInput(repoRoot, dagRunId, nodeId) {
     }
     const warnings = [];
     const fingerprint = await loadPromptFingerprint(repoRoot, dagRunId, nodeId, warnings);
+    const declaredPiExtensions = Array.isArray(task.piExtensions)
+        ? task.piExtensions.filter((item) => typeof item === "string")
+        : [];
+    const piExtensionRunFacts = await loadPiExtensionRunFacts(repoRoot, dagRunId, nodeId, declaredPiExtensions, warnings);
     // Reject unknown nested leakage by projecting only through allowlist helpers.
-    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, warnings);
+    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, piExtensionRunFacts, warnings);
     // Defense-in-depth: ensure raw task never sneaks in.
     if ("task" in body) {
         return {