pi-agent-browser-native 0.9.3 → 0.9.4

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

@@ -0,0 +1,209 @@
+import { isRecord } from "../../parsing.js";
+import { redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
+import { getArrayField, getStringField, redactModelFacingText, stringifyModelFacing, } from "./common.js";
+const STORAGE_VALUE_PREVIEW_MAX_CHARS = 160;
+const STORAGE_SECRET_KEY_PATTERN = /(?:access(?:_|-)?token|account|api(?:_|-)?key|auth(?:orization)?|bearer|client(?:_|-)?secret|cookie|credential|csrf|email|id(?:_|-)?token|jwt|pass(?:word)?|private(?:_|-)?key|profile|refresh(?:_|-)?token|secret|session|sid|sig(?:nature)?|token|user(?:name)?|x(?:_|-)?api(?:_|-)?key|xsrf)/i;
+const STORAGE_BENIGN_KEY_PATTERN = /^(?:color(?:scheme)?|debug|dev|experiment|feature(?:flag)?|flag|language|layout|locale|mode|onboarding|sort|tab|theme|timezone|tour|variant|view)$/i;
+const STORAGE_TOKEN_VALUE_PATTERN = /(?:\bBearer\s+[A-Za-z0-9._~-]+|\bBasic\s+[A-Za-z0-9+/=]+|^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$|(?=.*[A-Za-z])(?=.*\d)[A-Za-z0-9_~+/=-]{32,})/;
+const STORAGE_SECRET_VALUE_WORD_PATTERN = /(?:secret|token|password|passwd|bearer|credential|authorization|cookie|session[-_ ]?id)/i;
+const STORAGE_EMAIL_VALUE_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const STORAGE_IDENTITY_VALUE_PATTERN = /(?:^|[\s:=/_-])(?:account|profile|session|sid|user(?:id|name)?)(?:[\s:=/_-]|$)/i;
+function storageTextContainsSecret(text) {
+    if (STORAGE_TOKEN_VALUE_PATTERN.test(text) ||
+        STORAGE_SECRET_VALUE_WORD_PATTERN.test(text) ||
+        STORAGE_EMAIL_VALUE_PATTERN.test(text) ||
+        STORAGE_IDENTITY_VALUE_PATTERN.test(text)) {
+        return true;
+    }
+    if (storageTextIsSensitiveUrl(text) || redactSensitiveText(text) !== text) {
+        return true;
+    }
+    try {
+        const parsed = JSON.parse(text);
+        return valueContainsStorageSecret(parsed);
+    }
+    catch {
+        // Non-JSON primitives remain eligible for the bounded benign-key preview.
+        return false;
+    }
+}
+function storageTextIsSensitiveUrl(text) {
+    try {
+        const url = new URL(text);
+        return (url.protocol === "http:" ||
+            url.protocol === "https:" ||
+            url.username.length > 0 ||
+            url.password.length > 0 ||
+            url.search.length > 0);
+    }
+    catch {
+        // Ordinary storage text need not be a URL; continue the other secret checks.
+        return false;
+    }
+}
+function valueContainsStorageSecret(value) {
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed.length > 0 && storageTextContainsSecret(trimmed);
+    }
+    if (Array.isArray(value)) {
+        return value.some((item) => valueContainsStorageSecret(item));
+    }
+    if (!isRecord(value)) {
+        return false;
+    }
+    return Object.entries(value).some(([key, entryValue]) => STORAGE_SECRET_KEY_PATTERN.test(key) || valueContainsStorageSecret(entryValue));
+}
+function shouldRevealStorageValue(key, value) {
+    if (key === undefined ||
+        key.length === 0 ||
+        STORAGE_SECRET_KEY_PATTERN.test(key) ||
+        !STORAGE_BENIGN_KEY_PATTERN.test(key)) {
+        return false;
+    }
+    if (valueContainsStorageSecret(value)) {
+        return false;
+    }
+    if (typeof value === "string") {
+        return value.length <= STORAGE_VALUE_PREVIEW_MAX_CHARS;
+    }
+    return value === null || typeof value === "number" || typeof value === "boolean";
+}
+export function formatStorageValue(key, value) {
+    if (!shouldRevealStorageValue(key, value)) {
+        return "[REDACTED]";
+    }
+    return typeof value === "string" ? redactModelFacingText(value) : stringifyModelFacing(value);
+}
+function storageRedactionReason(key) {
+    return key !== undefined && key.length > 0 && STORAGE_SECRET_KEY_PATTERN.test(key)
+        ? "sensitive-key"
+        : "sensitive-value";
+}
+function redactStorageEntryValue(item) {
+    const key = getStringField(item, "key") ?? getStringField(item, "name");
+    if (!Object.hasOwn(item, "value") || shouldRevealStorageValue(key, item.value)) {
+        return redactSensitiveValue(item);
+    }
+    const redacted = redactSensitiveValue({ ...item, value: undefined });
+    if (!isRecord(redacted)) {
+        throw new Error("Storage record redaction did not return a record");
+    }
+    return {
+        ...redacted,
+        value: "[REDACTED]",
+        valueRedacted: true,
+        valueRedactionReason: storageRedactionReason(key),
+    };
+}
+function redactStorageField(owner, key, value) {
+    if (key === "data" && isRecord(value)) {
+        return Object.fromEntries(Object.entries(value).map(([storageKey, storageValue]) => [
+            storageKey,
+            shouldRevealStorageValue(storageKey, storageValue)
+                ? redactSensitiveValue(storageValue)
+                : "[REDACTED]",
+        ]));
+    }
+    if ((key === "entries" || key === "items") && Array.isArray(value)) {
+        return value.map((item) => isRecord(item) ? redactStorageEntryValue(item) : redactSensitiveValue(item));
+    }
+    if (key === "value") {
+        const itemKey = getStringField(owner, "key") ?? getStringField(owner, "name");
+        return shouldRevealStorageValue(itemKey, value) ? redactSensitiveValue(value) : "[REDACTED]";
+    }
+    return redactSensitiveValue(value);
+}
+export function redactStorageData(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => redactStorageData(item));
+    }
+    if (!isRecord(value)) {
+        return redactSensitiveValue(value);
+    }
+    const entries = Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [
+        key,
+        redactStorageField(value, key, entryValue),
+    ]));
+    const key = getStringField(value, "key") ?? getStringField(value, "name");
+    if (Object.hasOwn(value, "value") && !shouldRevealStorageValue(key, value.value)) {
+        entries.valueRedacted = true;
+        entries.valueRedactionReason = storageRedactionReason(key);
+    }
+    return entries;
+}
+function formatStorageEntry(item, index) {
+    if (!isRecord(item)) {
+        return `${index + 1}. [REDACTED]`;
+    }
+    const rawKey = getStringField(item, "key") ?? getStringField(item, "name") ?? `(entry ${index + 1})`;
+    const key = redactModelFacingText(rawKey);
+    return Object.hasOwn(item, "value") ? `${key}: ${formatStorageValue(rawKey, item.value)}` : key;
+}
+function formatStorageMutationText(data, type) {
+    const key = getStringField(data, "key");
+    if (key !== undefined && Object.hasOwn(data, "value")) {
+        return `${type} ${redactModelFacingText(key)}: ${formatStorageValue(key, data.value)}`;
+    }
+    if (key !== undefined && data.set === true) {
+        return `${type} set: ${redactModelFacingText(key)}`;
+    }
+    return data.cleared === true || data.clear === true ? `${type} cleared.` : undefined;
+}
+export function formatStorageText(data) {
+    const type = getStringField(data, "type") ?? getStringField(data, "storage") ?? "storage";
+    if (isRecord(data.data)) {
+        const text = Object.entries(data.data)
+            .map(([key, value]) => `${redactModelFacingText(key)}: ${formatStorageValue(key, value)}`)
+            .join("\n");
+        return text.length > 0 ? text : `${type}: no entries.`;
+    }
+    const entries = getArrayField(data, "entries") ?? getArrayField(data, "items");
+    if (entries) {
+        return entries.length === 0
+            ? `${type}: no entries.`
+            : entries.map(formatStorageEntry).join("\n");
+    }
+    return formatStorageMutationText(data, type);
+}
+function formatCookieRecordText(item, fallbackName) {
+    const name = redactModelFacingText(getStringField(item, "name") ?? fallbackName);
+    const domain = getStringField(item, "domain");
+    const path = getStringField(item, "path");
+    const flags = [
+        item.httpOnly === true ? "httpOnly" : undefined,
+        item.secure === true ? "secure" : undefined,
+    ]
+        .filter(Boolean)
+        .join(", ");
+    const location = [domain, path].filter(Boolean).join("");
+    return [
+        name,
+        location.length > 0 ? `(${redactModelFacingText(location)})` : undefined,
+        flags.length > 0 ? `[${flags}]` : undefined,
+    ]
+        .filter(Boolean)
+        .join(" ");
+}
+export function formatCookiesText(data) {
+    const cookies = getArrayField(data, "cookies");
+    if (cookies) {
+        return cookies.length === 0
+            ? "No cookies."
+            : cookies
+                .map((item, index) => isRecord(item)
+                ? formatCookieRecordText(item, `(cookie ${index + 1})`)
+                : `${index + 1}. [REDACTED]`)
+                .join("\n");
+    }
+    if (getStringField(data, "name") !== undefined ||
+        getStringField(data, "domain") !== undefined ||
+        getStringField(data, "path") !== undefined ||
+        Object.hasOwn(data, "value")) {
+        return formatCookieRecordText(data, "cookie");
+    }
+    if (data.set === true) {
+        return "Cookie set.";
+    }
+    return data.cleared === true || data.clear === true ? "Cookies cleared." : undefined;
+}

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

@@ -0,0 +1,69 @@
+import { isRecord } from "../../parsing.js";
+import { withOptionalSessionArgs } from "../next-actions.js";
+function streamPortLines(data) {
+    return typeof data.port === "number"
+        ? [`Port: ${data.port}`, `WebSocket URL: ${getStreamWebSocketUrl(data.port)}`]
+        : [];
+}
+export function getStreamSummary(data) {
+    if (data.alreadyEnabled === true) {
+        return [
+            "Stream already enabled (idempotent no-op).",
+            ...streamPortLines(data),
+            "Run stream status for current connection details or stream disable when streaming is no longer needed.",
+        ].join("\n");
+    }
+    if (typeof data.enabled !== "boolean" || typeof data.connected !== "boolean") {
+        return undefined;
+    }
+    const lines = [
+        `Enabled: ${data.enabled}`,
+        `Connected: ${data.connected}`,
+        `Screencasting: ${data.screencasting === true}`,
+        ...streamPortLines(data),
+    ];
+    if (typeof data.port === "number") {
+        lines.push("Frame format: JSON messages with base64 JPEG frame data");
+    }
+    return lines.join("\n");
+}
+function getStreamWebSocketUrl(port) {
+    return `ws://127.0.0.1:${port}`;
+}
+export function enrichStreamStatusData(command, data) {
+    if (command.command !== "stream" ||
+        command.subcommand !== "status" ||
+        !isRecord(data) ||
+        typeof data.port !== "number") {
+        return data;
+    }
+    return {
+        ...data,
+        frameFormat: "JSON messages with base64 JPEG frame data",
+        wsUrl: getStreamWebSocketUrl(data.port),
+    };
+}
+export function buildStreamNextActions(command, data, sessionName) {
+    if (command.command !== "stream" ||
+        command.subcommand !== "enable" ||
+        !isRecord(data) ||
+        data.alreadyEnabled !== true) {
+        return undefined;
+    }
+    return [
+        {
+            id: "check-stream-status-after-noop",
+            params: { args: withOptionalSessionArgs(sessionName, ["stream", "status"]) },
+            reason: "Read current stream port and connection details after the idempotent enable no-op.",
+            safety: "Read-only stream diagnostic.",
+            tool: "agent_browser",
+        },
+        {
+            id: "disable-existing-stream-when-done",
+            params: { args: withOptionalSessionArgs(sessionName, ["stream", "disable"]) },
+            reason: "Disable the existing stream when it is no longer needed.",
+            safety: "Only run when no other workflow is relying on the current stream.",
+            tool: "agent_browser",
+        },
+    ];
+}

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

@@ -0,0 +1,222 @@
+import { redactSensitiveText } from "../../runtime.js";
+import { formatCount, getArrayField, getStringField } from "./common.js";
+export function isClearDiagnosticCommand(commandInfo) {
+    return (commandInfo.subcommand === "--clear" || commandInfo.commandTokens?.includes("--clear") === true);
+}
+function sessionSummary(data) {
+    const sessions = getArrayField(data, "sessions");
+    if (sessions) {
+        return `Sessions: ${sessions.length}`;
+    }
+    const session = getStringField(data, "session");
+    return session === undefined ? undefined : `Session: ${session}`;
+}
+function authSummary(command, data) {
+    const profiles = getArrayField(data, "profiles");
+    if (profiles) {
+        return `Auth profiles: ${profiles.length}`;
+    }
+    const name = getStringField(data, "name") ?? getStringField(data, "profile") ?? command.subcommand;
+    if (name === undefined || name.length === 0) {
+        return undefined;
+    }
+    if (command.subcommand === "show") {
+        return `Auth profile: ${name}`;
+    }
+    if (["save", "login", "delete"].includes(command.subcommand ?? "")) {
+        return `Auth ${command.subcommand ?? ""}: ${name}`;
+    }
+    return undefined;
+}
+function cookiesSummary(data) {
+    const cookies = getArrayField(data, "cookies");
+    if (cookies) {
+        return `Cookies: ${cookies.length}`;
+    }
+    const name = getStringField(data, "name");
+    if (name !== undefined) {
+        return name;
+    }
+    if (data.set === true) {
+        return "Cookie set";
+    }
+    return data.cleared === true || data.clear === true ? "Cookies cleared" : undefined;
+}
+function storageSummary(command, data) {
+    const entries = getArrayField(data, "entries") ?? getArrayField(data, "items");
+    if (entries) {
+        return `Storage entries: ${entries.length}`;
+    }
+    const key = getStringField(data, "key");
+    if (key !== undefined &&
+        (command.subcommand === "set" || data.set === true || Object.hasOwn(data, "value"))) {
+        return `Storage set: ${key}`;
+    }
+    return data.cleared === true || data.clear === true ? "Storage cleared" : undefined;
+}
+function dialogSummary(data) {
+    if (typeof data.open === "boolean") {
+        return data.open ? "Dialog open" : "No dialog open";
+    }
+    if (data.accepted === true) {
+        return "Dialog accepted";
+    }
+    return data.dismissed === true ? "Dialog dismissed" : undefined;
+}
+function stateName(command, data) {
+    return (getStringField(data, "name") ??
+        getStringField(data, "file") ??
+        getStringField(data, "filename") ??
+        getStringField(data, "path") ??
+        command.subcommand);
+}
+function stateSummary(command, data) {
+    const states = getArrayField(data, "states") ?? getArrayField(data, "files");
+    if (states) {
+        return `States: ${states.length}`;
+    }
+    if (command.subcommand === "load") {
+        return undefined;
+    }
+    const name = stateName(command, data);
+    return name === undefined || name.length === 0
+        ? undefined
+        : `State ${command.subcommand ?? "result"}: ${name}`;
+}
+function bufferSummary(command, data, field, label) {
+    const rows = getArrayField(data, field);
+    if (!rows) {
+        return undefined;
+    }
+    return isClearDiagnosticCommand(command)
+        ? `${field === "messages" ? "Console" : label} reset: ${rows.length} cleared`
+        : `${label}: ${rows.length}`;
+}
+function networkRouteSummary(data, operation) {
+    const target = getStringField(data, operation === "route" ? "routed" : "unrouted") ??
+        getStringField(data, "url") ??
+        getStringField(data, "pattern");
+    if (target !== undefined) {
+        return `Network ${operation}: ${redactSensitiveText(target)}`;
+    }
+    return operation === "route" ? "Network route configured" : "Network route removed";
+}
+function networkSummary(command, data) {
+    switch (command.subcommand ?? "") {
+        case "requests":
+            return bufferSummary(command, data, "requests", "Network requests");
+        case "route":
+            return networkRouteSummary(data, "route");
+        case "unroute":
+            return networkRouteSummary(data, "unroute");
+        case "har":
+            return `Network HAR: ${getStringField(data, "state") ?? getStringField(data, "status") ?? "har"}`;
+        default:
+            return undefined;
+    }
+}
+function streamSummary(command, data) {
+    if (command.subcommand === "disable") {
+        return "Stream disabled";
+    }
+    if (command.subcommand !== "enable") {
+        return undefined;
+    }
+    if (data.alreadyEnabled === true) {
+        return "Stream already enabled";
+    }
+    return `Stream enabled${typeof data.port === "number" ? ` on port ${data.port}` : ""}`;
+}
+function dashboardSummary(data) {
+    if (typeof data.port === "number") {
+        return `Dashboard running on port ${data.port}`;
+    }
+    if (data.stopped === true) {
+        return "Dashboard stopped";
+    }
+    if (data.stopped !== false) {
+        return undefined;
+    }
+    const reason = getStringField(data, "reason");
+    return reason === undefined ? "Dashboard not stopped" : `Dashboard not stopped: ${reason}`;
+}
+function doctorSummary(data) {
+    const status = getStringField(data, "status") ?? getStringField(data, "result");
+    if (status !== undefined) {
+        return `Doctor: ${status}`;
+    }
+    const checks = getArrayField(data, "checks") ??
+        getArrayField(data, "issues") ??
+        getArrayField(data, "problems");
+    return checks ? `Doctor: ${formatCount(checks.length, "item")}` : undefined;
+}
+function profilesSummary(data) {
+    const profiles = getArrayField(data, "profiles");
+    return profiles ? `Chrome profiles: ${profiles.length}` : undefined;
+}
+function frameSummary(command, data) {
+    const frame = getStringField(data, "frame") ??
+        getStringField(data, "name") ??
+        getStringField(data, "selector") ??
+        command.subcommand;
+    return frame === undefined || frame.length === 0 ? undefined : `Frame: ${frame}`;
+}
+function diffSummary(command) {
+    if (command.subcommand === "snapshot") {
+        return "Snapshot diff completed";
+    }
+    return command.subcommand === "url" ? "URL diff completed" : undefined;
+}
+function traceSummary(command, data) {
+    const state = getStringField(data, "state") ?? getStringField(data, "status") ?? command.subcommand;
+    return state === undefined || state.length === 0
+        ? undefined
+        : `${command.command === "trace" ? "Trace" : "Profiler"}: ${state}`;
+}
+export function formatDiagnosticSummary(command, data) {
+    switch (command.command ?? "") {
+        case "session":
+            return sessionSummary(data);
+        case "profiles":
+            return profilesSummary(data);
+        case "auth":
+            return authSummary(command, data);
+        case "cookies":
+            return cookiesSummary(data);
+        case "storage":
+            return storageSummary(command, data);
+        case "dialog":
+            return dialogSummary(data);
+        case "frame":
+            return frameSummary(command, data);
+        case "state":
+            return stateSummary(command, data);
+        case "network":
+            return networkSummary(command, data);
+        case "diff":
+            return diffSummary(command);
+        case "trace":
+        case "profiler":
+            return traceSummary(command, data);
+        case "highlight":
+            return "Element highlighted";
+        case "inspect":
+            return "DevTools inspect opened";
+        case "clipboard":
+            return `Clipboard ${command.subcommand ?? "completed"}`;
+        case "stream":
+            return streamSummary(command, data);
+        case "chat":
+            return "Chat response";
+        case "console":
+            return bufferSummary(command, data, "messages", "Console messages");
+        case "errors":
+            return bufferSummary(command, data, "errors", "Page errors");
+        case "dashboard":
+            return dashboardSummary(data);
+        case "doctor":
+            return doctorSummary(data);
+        default:
+            return undefined;
+    }
+}