pi-agent-browser-native 0.9.3 → 0.9.4

package/dist/extensions/agent-browser/lib/results/presentation/diagnostic-identity.js

@@ -0,0 +1,199 @@
+import { isRecord } from "../../parsing.js";
+import { redactSensitiveText } from "../../runtime.js";
+import { getArrayField, getStringField, redactModelFacingText, stringifyModelFacing, } from "./common.js";
+const AUTH_SHOW_SAFE_FIELDS = [
+    "name",
+    "profile",
+    "url",
+    "username",
+    "createdAt",
+    "updatedAt",
+];
+const SESSION_FIELDS = [
+    "session",
+    "namespace",
+    "socketDir",
+    "active",
+    "pid",
+    "version",
+    "runtimeError",
+];
+const RUNTIME_FIELDS = [
+    "session",
+    "namespace",
+    "socketDir",
+    "backgroundPid",
+    "browserLaunched",
+    "browser",
+    "recording",
+    "capabilities",
+    "pageCount",
+    "engine",
+    "launchHash",
+    "compatibilityStatus",
+    "restoreKey",
+    "restoreStatus",
+    "restoreLoadedPath",
+    "restoreValidationPending",
+    "restoreSave",
+    "saveStatus",
+    "restoreSavedPath",
+];
+function tabSelector(tab, label, index) {
+    if (typeof tab.tabId === "string" && tab.tabId.trim().length > 0) {
+        return tab.tabId.trim();
+    }
+    if (label !== undefined) {
+        return label;
+    }
+    return typeof tab.index === "number" ? String(tab.index) : String(index);
+}
+function tabLine(tab, index) {
+    if (!isRecord(tab)) {
+        return `${index}: <invalid tab>`;
+    }
+    const marker = tab.active === true ? "*" : "-";
+    const title = typeof tab.title === "string" ? tab.title : "(untitled)";
+    const url = typeof tab.url === "string" ? tab.url : "(no url)";
+    const label = getStringField(tab, "label");
+    const selector = tabSelector(tab, label, index);
+    const labelText = label !== undefined && label !== selector ? ` label=${redactModelFacingText(label)}` : "";
+    const target = getStringField(tab, "targetId");
+    const targetText = target !== undefined && target !== selector ? ` target=${redactModelFacingText(target)}` : "";
+    return `${marker} [${selector}]${labelText}${targetText} ${title} — ${url}`;
+}
+export function getTabSummary(data) {
+    const tabs = getArrayField(data, "tabs");
+    return tabs ? tabs.map(tabLine).join("\n") : undefined;
+}
+function sessionMetadata(item) {
+    const url = getStringField(item, "url");
+    const title = getStringField(item, "title");
+    const label = getStringField(item, "label");
+    const tabCount = typeof item.tabCount === "number"
+        ? `${item.tabCount} tab${item.tabCount === 1 ? "" : "s"}`
+        : undefined;
+    return [
+        `active=${item.active === true ? "true" : "false"}`,
+        label === undefined ? undefined : `label=${redactModelFacingText(label)}`,
+        title === undefined ? undefined : `title=${redactSensitiveText(title)}`,
+        url === undefined ? undefined : `url=${redactSensitiveText(url)}`,
+        tabCount,
+    ]
+        .filter(Boolean)
+        .join("; ");
+}
+function sessionLine(item, index) {
+    if (!isRecord(item)) {
+        return `${index + 1}. ${stringifyModelFacing(item)}`;
+    }
+    const name = redactModelFacingText(getStringField(item, "name") ??
+        getStringField(item, "session") ??
+        getStringField(item, "id") ??
+        `(session ${index + 1})`);
+    return `${index + 1}. name=${name}${item.active === true ? " *active*" : ""}; ${sessionMetadata(item)}`;
+}
+function nativeIdentityValue(value) {
+    if (value === undefined || value === null) {
+        return "unknown";
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    return stringifyModelFacing(value);
+}
+function formatRuntimeIdentity(data) {
+    const runtime = data.runtime;
+    const browser = isRecord(runtime) && isRecord(runtime.browser) ? runtime.browser : undefined;
+    const identity = [
+        `Daemon: ${data.active === true ? "active" : "inactive"}; PID: ${nativeIdentityValue(data.pid)}`,
+        `Browser: ${nativeIdentityValue(browser?.status)}; alive: ${nativeIdentityValue(browser?.alive)}; Chrome PID: ${nativeIdentityValue(browser?.pid)}`,
+        `Exact profile: ${nativeIdentityValue(browser?.userDataDir)}`,
+        `Native browser ownership: ${nativeIdentityValue(browser?.ownership)}; Pi cleanup ownership: ${nativeIdentityValue(data.piCleanupOwnership)}`,
+    ].join("\n");
+    return `${redactModelFacingText(identity)}\n\n${stringifyModelFacing({
+        ...Object.fromEntries(SESSION_FIELDS.map((key) => [key, data[key]])),
+        // Native runtime also includes restore check URLs, text and code; show status/identity only.
+        runtime: isRecord(runtime)
+            ? Object.fromEntries(RUNTIME_FIELDS.map((key) => [key, runtime[key]]))
+            : runtime,
+    })}`;
+}
+export function formatSessionText(data) {
+    const sessions = getArrayField(data, "sessions");
+    if (sessions) {
+        return sessions.length === 0 ? "No active sessions." : sessions.map(sessionLine).join("\n");
+    }
+    if (typeof data.active === "boolean") {
+        return formatRuntimeIdentity(data);
+    }
+    const session = getStringField(data, "session");
+    return session === undefined ? undefined : `Current session: ${redactModelFacingText(session)}`;
+}
+export function formatProfilesText(profiles, label) {
+    if (profiles.length === 0) {
+        return `No ${label}.`;
+    }
+    return profiles
+        .map((item, index) => {
+        if (!isRecord(item)) {
+            return `${index + 1}. ${stringifyModelFacing(item)}`;
+        }
+        const name = redactModelFacingText(getStringField(item, "name") ?? getStringField(item, "profile") ?? `(unnamed ${index + 1})`);
+        const directory = getStringField(item, "directory") ?? getStringField(item, "path");
+        return directory === undefined
+            ? `${index + 1}. ${name}`
+            : `${index + 1}. ${name} (${redactModelFacingText(directory)})`;
+    })
+        .join("\n");
+}
+export function formatAuthShowText(data) {
+    const lines = AUTH_SHOW_SAFE_FIELDS.flatMap((key) => {
+        const value = data[key];
+        return typeof value === "string" && value.trim().length > 0
+            ? [`${key}: ${redactModelFacingText(value.trim())}`]
+            : [];
+    });
+    return lines.length > 0 ? lines.join("\n") : undefined;
+}
+function stateLine(item, index) {
+    if (!isRecord(item)) {
+        return `${index + 1}. ${stringifyModelFacing(item)}`;
+    }
+    const name = getStringField(item, "name") ??
+        getStringField(item, "file") ??
+        getStringField(item, "path") ??
+        `(state ${index + 1})`;
+    const url = getStringField(item, "url");
+    return url === undefined
+        ? `${index + 1}. ${redactModelFacingText(name)}`
+        : `${index + 1}. ${redactModelFacingText(name)} — ${redactSensitiveText(url)}`;
+}
+function stateShowText(data) {
+    const filename = getStringField(data, "filename") ?? getStringField(data, "name") ?? "saved state";
+    const summary = getStringField(data, "summary");
+    const lines = [`Saved state: ${redactModelFacingText(filename)}`];
+    if (summary !== undefined) {
+        lines.push(`Summary: ${redactModelFacingText(summary)}`);
+    }
+    if (typeof data.encrypted === "boolean") {
+        lines.push(`Encrypted: ${data.encrypted ? "yes" : "no"}`);
+    }
+    if (typeof data.size === "number") {
+        lines.push(`Size: ${data.size} bytes`);
+    }
+    return lines.join("\n");
+}
+export function formatStateText(data, subcommand) {
+    if (subcommand === "show") {
+        return stateShowText(data);
+    }
+    const states = getArrayField(data, "states") ?? getArrayField(data, "files");
+    if (states) {
+        return states.length === 0 ? "No saved states." : states.map(stateLine).join("\n");
+    }
+    if (data.loaded === true) {
+        return `State loaded: ${redactModelFacingText(getStringField(data, "path") ?? getStringField(data, "name") ?? "ok")}`;
+    }
+    return data.cleared === true || data.clear === true ? "State cleared." : undefined;
+}

package/dist/extensions/agent-browser/lib/results/presentation/diagnostic-logs.js

@@ -0,0 +1,75 @@
+import { isRecord } from "../../parsing.js";
+import { firstLine, getArrayField, getStringField, redactModelFacingText, stringifyModelFacing, } from "./common.js";
+import { isClearDiagnosticCommand } from "./diagnostic-summary.js";
+const LOG_PREVIEW_LIMIT = 80;
+function consoleLine(item, index) {
+    if (!isRecord(item)) {
+        return `${index + 1}. ${stringifyModelFacing(item)}`;
+    }
+    const type = redactModelFacingText(getStringField(item, "type") ?? "message");
+    const text = getStringField(item, "text") ?? stringifyModelFacing(item);
+    return `${index + 1}. [${type}] ${firstLine(redactModelFacingText(text).replace(/\s+/g, " ").trim(), 220)}`;
+}
+export function formatConsoleText(data, command) {
+    const messages = getArrayField(data, "messages");
+    if (isClearDiagnosticCommand(command) && data.cleared === true && !messages) {
+        return "Console buffer cleared.";
+    }
+    if (!messages) {
+        return undefined;
+    }
+    if (isClearDiagnosticCommand(command)) {
+        return messages.length === 0
+            ? "Console buffer cleared; no prior message rows were returned. This reset output is not evidence of current-page console activity."
+            : `Console buffer cleared; upstream returned ${messages.length} cleared/stale message row${messages.length === 1 ? "" : "s"}. Treat these as reset output, not current-page console errors.`;
+    }
+    if (messages.length === 0) {
+        return "No console messages. Scope: upstream session aggregate unless the upstream command output says it was cleared or filtered for this page.";
+    }
+    const shown = [
+        "Scope: upstream session aggregate unless the upstream command output says it was cleared or filtered for this page; do not attribute old messages to the current page without URL/time evidence.",
+        ...messages.slice(0, LOG_PREVIEW_LIMIT).map(consoleLine),
+    ];
+    const previewedCount = Math.min(messages.length, LOG_PREVIEW_LIMIT);
+    if (messages.length > previewedCount) {
+        shown.push(`... (${messages.length - previewedCount} additional console messages omitted from preview)`);
+    }
+    return shown.join("\n");
+}
+function errorLine(item, index) {
+    if (!isRecord(item)) {
+        return `${index + 1}. ${stringifyModelFacing(item)}`;
+    }
+    const text = getStringField(item, "text") ?? stringifyModelFacing(item);
+    const location = [
+        getStringField(item, "url"),
+        typeof item.line === "number" ? `line ${item.line}` : undefined,
+        typeof item.column === "number" ? `column ${item.column}` : undefined,
+    ]
+        .filter((part) => part !== undefined && part.length > 0)
+        .map((part) => redactModelFacingText(part ?? ""))
+        .join(":");
+    const safeText = firstLine(redactModelFacingText(text), 220);
+    return location.length > 0
+        ? `${index + 1}. ${safeText} (${location})`
+        : `${index + 1}. ${safeText}`;
+}
+export function formatErrorsText(data, command) {
+    const errors = getArrayField(data, "errors");
+    if (!errors) {
+        return undefined;
+    }
+    if (isClearDiagnosticCommand(command)) {
+        return errors.length === 0
+            ? "Page error buffer cleared; no prior error rows were returned. This reset output is not evidence of current-page errors."
+            : `Page error buffer cleared; upstream returned ${errors.length} cleared/stale error row${errors.length === 1 ? "" : "s"}. Treat these as reset output, not current-page errors.`;
+    }
+    if (errors.length === 0) {
+        return "No page errors.";
+    }
+    const shown = errors.slice(0, LOG_PREVIEW_LIMIT).map(errorLine);
+    if (errors.length > shown.length) {
+        shown.push(`... (${errors.length - shown.length} additional errors omitted from preview)`);
+    }
+    return shown.join("\n");
+}

package/dist/extensions/agent-browser/lib/results/presentation/diagnostic-network-actions.js

@@ -0,0 +1,216 @@
+import { isRecord } from "../../parsing.js";
+import { redactSensitiveText } from "../../runtime.js";
+import { classifyNetworkRequestFailure, isApiLikeNetworkRequest, isNetworkArtifactNoiseRequest, } from "../network.js";
+import { withOptionalSessionArgs } from "../next-actions.js";
+import { getArrayField, getStringField } from "./common.js";
+const SENSITIVE_SEGMENT_TERMS = [
+    "apikey",
+    "api-key",
+    "api_key",
+    "authentication",
+    "authorization",
+    "bearer",
+    "credential",
+    "credentials",
+    "jwt",
+    "passwd",
+    "password",
+    "reset",
+    "secret",
+    "session",
+    "token",
+];
+const OPAQUE_SEGMENT_PATTERN = /^(?:[A-Fa-f0-9]{16,}|(?=.*[A-Za-z])(?=.*\d)[A-Za-z0-9_-]{16,})$/;
+function safeActionValue(value) {
+    if (value === undefined || value.length === 0) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length === 0 || redactSensitiveText(trimmed) !== trimmed ? undefined : trimmed;
+}
+function sensitivePathSegment(segment) {
+    const normalized = segment.toLowerCase();
+    return normalized === "auth" || SENSITIVE_SEGMENT_TERMS.some((term) => normalized.includes(term));
+}
+function decodePath(filter) {
+    try {
+        return decodeURIComponent(filter);
+    }
+    catch {
+        return filter;
+    } // Malformed native escapes still undergo literal segment checks.
+}
+function requestPath(url) {
+    try {
+        return new URL(url).pathname;
+    }
+    catch {
+        return url.split(/[?#]/, 1)[0];
+    } // Native patterns need not be absolute URLs.
+}
+function requestPathFilter(item) {
+    const url = getStringField(item, "url");
+    if (url === undefined) {
+        return undefined;
+    }
+    const filter = requestPath(url)?.trim();
+    if (filter === undefined || filter.length === 0 || filter === "/" || filter.length > 160) {
+        return undefined;
+    }
+    if (decodePath(filter)
+        .split("/")
+        .some((segment) => sensitivePathSegment(segment) || OPAQUE_SEGMENT_PATTERN.test(segment))) {
+        return undefined;
+    }
+    return safeActionValue(filter);
+}
+function candidateKind(item) {
+    const classification = classifyNetworkRequestFailure(item);
+    if (classification?.impact === "actionable") {
+        return "actionable";
+    }
+    if (classification?.impact === "benign") {
+        return "benign";
+    }
+    return isApiLikeNetworkRequest(item) ? "api" : "request";
+}
+function requestCandidate(item) {
+    if (!isRecord(item) || isNetworkArtifactNoiseRequest(item)) {
+        return [];
+    }
+    const requestId = safeActionValue(getStringField(item, "requestId") ?? getStringField(item, "id"));
+    return requestId === undefined
+        ? []
+        : [{ filter: requestPathFilter(item), item, kind: candidateKind(item), requestId }];
+}
+function chooseCandidate(candidates) {
+    return (candidates.find((candidate) => candidate.kind === "actionable") ??
+        candidates.find((candidate) => candidate.kind === "api") ??
+        candidates.find((candidate) => candidate.kind === "benign") ??
+        candidates[0]);
+}
+function actionDescriptor(candidate) {
+    const method = getStringField(candidate.item, "method") ?? "GET";
+    const status = typeof candidate.item.status === "number" ? String(candidate.item.status) : "pending";
+    return `${status} ${method}${candidate.filter === undefined ? "" : ` ${candidate.filter}`} [${candidate.requestId}]`;
+}
+function detailActionId(candidate) {
+    if (candidate.kind === "actionable") {
+        return "inspect-actionable-network-request";
+    }
+    return candidate.kind === "benign" ? "inspect-benign-network-request" : "inspect-network-request";
+}
+export function formatNetworkRouteDiagnosticsText(diagnostics) {
+    if (!diagnostics || diagnostics.length === 0) {
+        return undefined;
+    }
+    const lines = ["Network route diagnostics:"];
+    for (const diagnostic of diagnostics) {
+        const target = diagnostic.requestId !== undefined && diagnostic.requestId.length > 0
+            ? `[${diagnostic.requestId}] ${diagnostic.requestUrl ?? "request"}`
+            : (diagnostic.requestUrl ?? "request");
+        lines.push(`- ${diagnostic.reason}: ${target} matched route ${diagnostic.routePattern} (${diagnostic.mode}).`);
+    }
+    lines.push("If this route is intended as a mock, inspect the request/headers and treat failed, pending, or CORS-looking rows as unfulfilled until a mocked response is observed.");
+    return lines.join("\n");
+}
+function routeActions(diagnostics, sessionName) {
+    const diagnostic = diagnostics?.find((item) => item.requestId !== undefined && item.requestId.length > 0) ??
+        diagnostics?.[0];
+    if (!diagnostic) {
+        return [];
+    }
+    const actions = [];
+    if (diagnostic.requestId !== undefined && diagnostic.requestId.length > 0) {
+        actions.push({
+            id: "inspect-routed-network-request",
+            params: {
+                args: withOptionalSessionArgs(sessionName, ["network", "request", diagnostic.requestId]),
+            },
+            reason: `Inspect the routed request ${diagnostic.requestId} before assuming the route mock fulfilled normally.`,
+            safety: "Read-only request diagnostic; look for failed status, pending state, CORS/preflight errors, response body, and headers.",
+            tool: "agent_browser",
+        });
+    }
+    actions.push({
+        id: "start-network-har-capture-for-route-mock",
+        params: { args: withOptionalSessionArgs(sessionName, ["network", "har", "start"]) },
+        reason: "Capture a HAR before reproducing the route mock so pending/CORS behavior has request and response headers.",
+        safety: "HARs can contain URLs and headers; stop to an explicit path and avoid sharing sensitive captures.",
+        tool: "agent_browser",
+    });
+    return actions;
+}
+function candidateActions(selected, sessionName) {
+    const descriptor = actionDescriptor(selected);
+    const actions = [
+        {
+            id: detailActionId(selected),
+            params: {
+                args: withOptionalSessionArgs(sessionName, ["network", "request", selected.requestId]),
+            },
+            reason: `Inspect full request details for ${descriptor}.`,
+            safety: "Read-only network diagnostic; request inspection must not replace the active page/ref context.",
+            tool: "agent_browser",
+        },
+    ];
+    if (selected.kind === "actionable") {
+        actions.push({
+            id: "trace-actionable-network-source",
+            params: {
+                requestId: selected.requestId,
+                ...(sessionName !== undefined && sessionName.length > 0 ? { session: sessionName } : {}),
+            },
+            reason: `Look for local source candidates related to ${descriptor}.`,
+            safety: "Read-only experimental helper; enable network with agent_browser_tools when this tool is inactive. It reports bounded candidates and may miss bundled or dynamic call sites.",
+            tool: "agent_browser_network_source",
+        });
+    }
+    if (selected.filter !== undefined && selected.filter.length > 0) {
+        actions.push({
+            id: "filter-network-requests-by-path",
+            params: {
+                args: withOptionalSessionArgs(sessionName, [
+                    "network",
+                    "requests",
+                    "--filter",
+                    selected.filter,
+                ]),
+            },
+            reason: `List captured requests matching ${selected.filter}.`,
+            safety: "Read-only request-list filter; absence from a compact preview is not proof the request did not happen.",
+            tool: "agent_browser",
+        });
+    }
+    actions.push({
+        id: "clear-network-requests-before-repro",
+        params: { args: withOptionalSessionArgs(sessionName, ["network", "requests", "--clear"]) },
+        reason: "Clear the aggregate request buffer before reproducing the current-page network behavior.",
+        safety: "This mutates only diagnostic buffers for the session; capture or inspect needed old rows first.",
+        tool: "agent_browser",
+    });
+    actions.push({
+        id: "start-network-har-capture",
+        params: { args: withOptionalSessionArgs(sessionName, ["network", "har", "start"]) },
+        reason: "Start HAR capture before reproducing the network behavior again.",
+        safety: "HARs can contain URLs and headers; stop to an explicit path, inspect metadata, and avoid sharing sensitive captures.",
+        tool: "agent_browser",
+    });
+    return actions;
+}
+export function buildNetworkRequestsNextActions(data, sessionName, routeDiagnostics) {
+    if (!isRecord(data)) {
+        return undefined;
+    }
+    const requests = getArrayField(data, "requests");
+    if (!requests) {
+        return undefined;
+    }
+    const selected = chooseCandidate(requests.flatMap(requestCandidate));
+    return selected
+        ? [
+            ...routeActions(routeDiagnostics, sessionName),
+            ...candidateActions(selected, sessionName),
+        ].slice(0, 6)
+        : undefined;
+}

package/dist/extensions/agent-browser/lib/results/presentation/diagnostic-network.js

@@ -0,0 +1,124 @@
+import { isRecord } from "../../parsing.js";
+import { redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
+import { classifyNetworkRequestFailure, isNetworkArtifactNoiseRequest, summarizeNetworkFailures, } from "../network.js";
+import { stringifyUnknown, truncateText } from "../text.js";
+import { getArrayField, getStringField, stringifyModelFacing } from "./common.js";
+import { isClearDiagnosticCommand } from "./diagnostic-summary.js";
+const REQUEST_PREVIEW_LIMIT = 40;
+const PREVIEW_FIELDS = {
+    request: ["postData"],
+    response: ["responseBody"],
+    error: ["error", "failureText", "errorText"],
+};
+function previewCandidate(item, keys) {
+    for (const key of keys) {
+        const value = item[key];
+        if (value !== undefined && value !== null && value !== "") {
+            return value;
+        }
+    }
+    return undefined;
+}
+function networkPreview(item, keys, label, maxChars) {
+    const value = previewCandidate(item, keys);
+    if (value === undefined || value === null) {
+        return [];
+    }
+    const redacted = redactSensitiveValue(value);
+    const raw = typeof redacted === "string" ? redacted : stringifyUnknown(redacted);
+    const normalized = raw.replace(/\s+/g, " ").trim();
+    return normalized.length === 0
+        ? []
+        : [`   ${label}: ${truncateText(redactSensitiveText(normalized), maxChars)}`];
+}
+function networkRequestLine(item, index) {
+    const method = getStringField(item, "method") ?? "GET";
+    const status = typeof item.status === "number" ? String(item.status) : "pending";
+    const type = getStringField(item, "resourceType") ?? getStringField(item, "mimeType");
+    const url = getStringField(item, "url") ?? "(no url)";
+    const requestId = getStringField(item, "requestId") ?? getStringField(item, "id");
+    const idText = requestId === undefined ? "" : ` [${redactSensitiveText(requestId)}]`;
+    const classification = classifyNetworkRequestFailure(item);
+    const impactText = classification ? ` [${classification.impact}: ${classification.reason}]` : "";
+    return [
+        `${index + 1}. ${status} ${method} ${truncateText(redactSensitiveText(url), 180)}${type === undefined ? "" : ` (${type})`}${idText}${impactText}`,
+        ...networkPreview(item, PREVIEW_FIELDS.request, "Payload", 280),
+        ...networkPreview(item, PREVIEW_FIELDS.response, "Response", 280),
+        ...networkPreview(item, PREVIEW_FIELDS.error, "Error", 220),
+    ];
+}
+function failureRank(request) {
+    const classification = isRecord(request.item)
+        ? classifyNetworkRequestFailure(request.item)
+        : undefined;
+    return classification?.impact === "actionable" ? 0 : 1;
+}
+function prioritizeRequests(requests) {
+    const failed = [];
+    const normal = [];
+    for (const request of requests) {
+        if (isRecord(request.item) && classifyNetworkRequestFailure(request.item)) {
+            failed.push(request);
+        }
+        else {
+            normal.push(request);
+        }
+    }
+    failed.sort((left, right) => {
+        const rankDifference = failureRank(left) - failureRank(right);
+        return rankDifference === 0 ? left.index - right.index : rankDifference;
+    });
+    return [...failed, ...normal];
+}
+function requestPreview(request) {
+    return isRecord(request.item)
+        ? networkRequestLine(request.item, request.index)
+        : [`${request.index + 1}. ${stringifyModelFacing(request.item)}`];
+}
+function networkRequestsPreview(requests) {
+    const shown = [
+        "Scope: upstream session aggregate unless the upstream command output says it was cleared or filtered for this page; do not attribute old requests to the current page without URL/time evidence.",
+    ];
+    const indexed = requests.map((item, index) => ({ index, item }));
+    const preview = indexed.filter(({ item }) => !(isRecord(item) && isNetworkArtifactNoiseRequest(item)));
+    const noiseCount = indexed.length - preview.length;
+    const summary = summarizeNetworkFailures(preview.map(({ item }) => item));
+    if (summary.totalCount > 0) {
+        shown.push(`Network failure summary: ${summary.actionableCount} actionable, ${summary.benignCount} benign low-impact (${summary.totalCount} total).`);
+    }
+    if (noiseCount > 0) {
+        shown.push(`Diagnostic noise hidden from preview: ${noiseCount} data:image/artifact request row${noiseCount === 1 ? "" : "s"}; raw rows remain in details.data.requests.`);
+    }
+    const prioritized = prioritizeRequests(preview);
+    shown.push(...prioritized.slice(0, REQUEST_PREVIEW_LIMIT).flatMap(requestPreview));
+    const omittedCount = Math.max(0, prioritized.length - REQUEST_PREVIEW_LIMIT);
+    if (omittedCount > 0) {
+        shown.push(`... (${omittedCount} additional non-noise requests omitted from preview; failed requests are shown first when present)`);
+    }
+    return shown.join("\n");
+}
+export function formatNetworkRequestsText(data, command) {
+    const requests = getArrayField(data, "requests");
+    if (isClearDiagnosticCommand(command) && data.cleared === true && !requests) {
+        return "Network request buffer cleared.";
+    }
+    if (!requests) {
+        return undefined;
+    }
+    if (isClearDiagnosticCommand(command)) {
+        return requests.length === 0
+            ? "Network request buffer cleared; no prior request rows were returned. This reset output is not evidence of current-page network activity."
+            : `Network request buffer cleared; upstream returned ${requests.length} cleared/stale row${requests.length === 1 ? "" : "s"}. Treat these as reset output, not current-page request failures.`;
+    }
+    return requests.length === 0
+        ? "No network requests captured. Scope: upstream session aggregate unless the upstream command output says it was cleared or filtered for this page."
+        : networkRequestsPreview(requests);
+}
+export function formatNetworkRequestText(data) {
+    if (getStringField(data, "url") === undefined &&
+        getStringField(data, "requestId") === undefined &&
+        getStringField(data, "id") === undefined) {
+        return undefined;
+    }
+    return networkRequestLine(data, 0).join("\n");
+}

package/dist/extensions/agent-browser/lib/results/presentation/diagnostic-redaction.js

@@ -0,0 +1,64 @@
+import { isRecord } from "../../parsing.js";
+import { getUpstreamEffectiveBatchSteps } from "../../orchestration/batch-stdin.js";
+import { redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
+import { formatStorageValue, redactStorageData } from "./diagnostic-storage.js";
+function redactStatefulValues(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => redactStatefulValues(item));
+    }
+    if (!isRecord(value)) {
+        return redactSensitiveValue(value);
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [
+        key,
+        key.toLowerCase() === "value" ? "[REDACTED]" : redactStatefulValues(entryValue),
+    ]));
+}
+function storageTextKey(command) {
+    const operation = command.commandTokens?.[2];
+    if (operation === "get") {
+        return command.commandTokens?.[3];
+    }
+    return operation === "set" || operation === "clear" ? undefined : operation;
+}
+function redactStorageText(command, text) {
+    const key = storageTextKey(command);
+    if (key !== undefined && text.startsWith(`${key}: `)) {
+        const suffix = text.endsWith("\n") ? "\n" : "";
+        const value = text.slice(key.length + 2, suffix.length > 0 ? -1 : undefined);
+        return `${key}: ${formatStorageValue(key, value)}${suffix}`;
+    }
+    // ponytail: native all-entry/raw-batch text does not escape multiline values.
+    // Format heuristics cannot separate lookalike entries; use structured JSON for sensitive storage.
+    return text.replace(/^([^\r\n]*?): ([^\r\n]*)/gm, (_line, entryKey, value) => `${entryKey}: ${formatStorageValue(entryKey, value)}`);
+}
+function redactNativeContextText(command, text, stdin) {
+    if (command.command === "batch") {
+        const steps = getUpstreamEffectiveBatchSteps(command.commandTokens ?? ["batch"], stdin);
+        const cookieRedacted = steps.some((step) => step[0] === "cookies")
+            ? redactNativeContextText({ command: "cookies" }, text)
+            : text;
+        return steps.some((step) => step[0] === "storage")
+            ? redactNativeContextText({ command: "storage" }, cookieRedacted)
+            : cookieRedacted;
+    }
+    if (command.command === "cookies") {
+        return text.replace(/^([^=\r\n]*)=([^\r\n]*)/gm, "$1=[REDACTED]");
+    }
+    return command.command === "storage" ? redactStorageText(command, text) : text;
+}
+export function redactPresentationData(command, data, stdin) {
+    if (typeof data === "string") {
+        return redactSensitiveText(redactNativeContextText(command, data, stdin));
+    }
+    if (command.command === "cookies") {
+        return redactStatefulValues(data);
+    }
+    if (command.command === "storage") {
+        return redactStorageData(data);
+    }
+    if (command.command === "state" && command.subcommand === "show") {
+        return redactStatefulValues(data);
+    }
+    return redactSensitiveValue(data);
+}