pi-agent-browser-native 0.9.3 → 0.9.5

package/dist/extensions/agent-browser/lib/redaction-json.js

@@ -0,0 +1,149 @@
+import { isSensitiveFieldName } from "./redaction-fields.js";
+function nextQuotePosition(options) {
+    // Inside a string, backslash skips one character; outside, it is ordinary text.
+    if (options.char === '"') {
+        return options.index;
+    }
+    return options.char === "\\" ? options.quoteAfterNext : options.quoteAtNext;
+}
+function buildJsonBoundaries(text) {
+    // Resolve each suffix once: skip strings and balanced groups to its first unmatched closer.
+    const boundaries = new Int32Array(text.length + 1).fill(-1);
+    let quoteAtNext = -1;
+    let quoteAfterNext = -1;
+    for (let index = text.length - 1; index >= 0; index -= 1) {
+        const char = text[index];
+        switch (char) {
+            case "}":
+            case "]":
+                boundaries[index] = index;
+                break;
+            case '"':
+                boundaries[index] = quoteAtNext < 0 ? -1 : boundaries[quoteAtNext + 1];
+                break;
+            case "{":
+            case "[": {
+                const end = boundaries[index + 1];
+                boundaries[index] =
+                    end >= 0 && text[end] === (char === "{" ? "}" : "]") ? boundaries[end + 1] : -1;
+                break;
+            }
+            default:
+                boundaries[index] = boundaries[index + 1];
+        }
+        const quote = nextQuotePosition({ char, index, quoteAtNext, quoteAfterNext });
+        quoteAfterNext = quoteAtNext;
+        quoteAtNext = quote;
+    }
+    return boundaries;
+}
+function createBalancedJsonEndFinder(text) {
+    let boundaries;
+    return (startIndex) => {
+        const opener = text[startIndex];
+        if (opener !== "{" && opener !== "[") {
+            return;
+        }
+        boundaries ??= buildJsonBoundaries(text);
+        const end = boundaries[startIndex + 1];
+        return end >= 0 && text[end] === (opener === "{" ? "}" : "]") ? end : undefined;
+    };
+}
+function parseJsonString(token) {
+    const value = JSON.parse(token);
+    if (typeof value !== "string") {
+        throw new Error("Expected a JSON string token");
+    }
+    return value;
+}
+function isSerializedJson(text) {
+    if (text === "[REDACTED]" || !/^\s*[[{"\d\-tfn]/.test(text)) {
+        return false;
+    }
+    // Validate grammar only; rebuilding parsed values loses duplicates and numeric spelling.
+    try {
+        JSON.parse(text);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function findJsonValueEnd(text, start, findEnd) {
+    const balancedEnd = findEnd(start);
+    if (balancedEnd !== undefined) {
+        return balancedEnd + 1;
+    }
+    if (text[start] === '"') {
+        const strings = /"(?:\\.|[^"\\])*"/g;
+        strings.lastIndex = start;
+        const fieldValue = strings.exec(text);
+        if (fieldValue === null) {
+            throw new Error("Expected a validated JSON string field value");
+        }
+        return parseJsonString(fieldValue[0]) === "[REDACTED]" ? undefined : strings.lastIndex;
+    }
+    let end = start;
+    while (end < text.length && !/[\s,\]}]/.test(text[end])) {
+        end += 1;
+    }
+    return end;
+}
+export function redactSerializedJson(text, redact) {
+    if (!isSerializedJson(text)) {
+        return;
+    }
+    let output = "";
+    let cursor = 0;
+    const findEnd = createBalancedJsonEndFinder(text);
+    const strings = /"(?:\\.|[^"\\])*"/g;
+    let match;
+    while ((match = strings.exec(text)) !== null) {
+        const end = strings.lastIndex;
+        const value = parseJsonString(match[0]);
+        const redacted = redact(value);
+        if (redacted !== value) {
+            output += text.slice(cursor, match.index) + JSON.stringify(redacted);
+            cursor = end;
+        }
+        const separator = /^\s*:\s*/.exec(text.slice(end));
+        if (separator === null || !isSensitiveFieldName(value)) {
+            continue;
+        }
+        const valueStart = end + separator[0].length;
+        const valueEnd = findJsonValueEnd(text, valueStart, findEnd);
+        if (valueEnd === undefined) {
+            // Skip the already-redacted string as the original scanner did.
+            strings.lastIndex = valueStart;
+            strings.exec(text);
+            continue;
+        }
+        output += text.slice(cursor, valueStart) + '"[REDACTED]"';
+        cursor = valueEnd;
+        strings.lastIndex = valueEnd;
+    }
+    return output + text.slice(cursor);
+}
+export function redactEmbeddedStructuredText(text, redact) {
+    let output = "";
+    let cursor = 0;
+    const findEnd = createBalancedJsonEndFinder(text);
+    while (cursor < text.length) {
+        const char = text[cursor];
+        if (char !== "{" && char !== "[") {
+            output += char;
+            cursor += 1;
+            continue;
+        }
+        const endIndex = findEnd(cursor);
+        if (endIndex === undefined) {
+            output += char;
+            cursor += 1;
+            continue;
+        }
+        const candidate = text.slice(cursor, endIndex + 1);
+        output += redactSerializedJson(candidate, redact) ?? candidate;
+        cursor = endIndex + 1;
+    }
+    return output;
+}

package/dist/extensions/agent-browser/lib/redaction-url.js

@@ -0,0 +1,88 @@
+import { isSensitiveFieldName } from "./redaction-fields.js";
+const SENSITIVE_QUERY_PARAM_PATTERN = /^(?:access(?:_|-)?token|api(?:_|-)?key|auth|authorization|authorization(?:_|-)?session(?:_|-)?id|bearer|client(?:_|-)?secret|code|cookie|id(?:_|-)?token|key|pass(?:word)?|refresh(?:_|-)?token|relay(?:_|-)?state|saml(?:_|-)?request|saml(?:_|-)?response|secret|sentry(?:_|-)?key|session(?:_|-)?id|sig(?:nature)?|token|write(?:_|-)?key)$/i;
+const AUTH_STATE_QUERY_PARAM_PATTERN = /^(?:nonce|state)$/i;
+const AUTH_URL_CONTEXT_PATTERN = /(?:^|[./_-])(?:auth|authorize|callback|login|oauth2?|oidc|saml|sso)(?:[./?#_-]|$)/i;
+function shouldRedactQueryParam(name) {
+    return SENSITIVE_QUERY_PARAM_PATTERN.test(name) || isSensitiveFieldName(name);
+}
+function isSensitiveParameter(name, authContext) {
+    return shouldRedactQueryParam(name) || (authContext && AUTH_STATE_QUERY_PARAM_PATTERN.test(name));
+}
+function redactParameters(params, authContext) {
+    let mutated = false;
+    for (const [name] of params) {
+        if (isSensitiveParameter(name, authContext)) {
+            params.set(name, "[REDACTED]");
+            mutated = true;
+        }
+    }
+    return mutated;
+}
+function getHashParameters(hash) {
+    const text = hash.startsWith("#") ? hash.slice(1) : hash;
+    return text.includes("=") ? new URLSearchParams(text) : undefined;
+}
+export function redactUrlToken(token) {
+    let parsed;
+    try {
+        parsed = new URL(token);
+    }
+    catch {
+        return token;
+    }
+    const originalHref = parsed.href;
+    if (parsed.username.length > 0) {
+        parsed.username = "[REDACTED]";
+    }
+    if (parsed.password.length > 0) {
+        parsed.password = "[REDACTED]";
+    }
+    const hashParams = getHashParameters(parsed.hash);
+    const authContext = AUTH_URL_CONTEXT_PATTERN.test(`${parsed.hostname}${parsed.pathname}`) ||
+        [...parsed.searchParams.keys(), ...(hashParams?.keys() ?? [])].some(shouldRedactQueryParam);
+    redactParameters(parsed.searchParams, authContext);
+    if (hashParams && redactParameters(hashParams, authContext)) {
+        parsed.hash = `#${hashParams.toString()}`;
+    }
+    return parsed.href === originalHref ? token : parsed.href;
+}
+function decodeParameterName(raw) {
+    try {
+        return decodeURIComponent(raw.replace(/\+/g, " "));
+    }
+    catch {
+        return raw;
+    }
+}
+function redactLooseUrlParameterText(text) {
+    return text.replace(/(?<![^\s"'`<>\])}])[^\s"'`<>\])}]*[?#&][^\s"'`<>\])}]*/g, (token) => {
+        const queryNames = [...token.matchAll(/[?#&]([^=&#\s"'`<>\])}]+)=/g)].map((match) => decodeParameterName(match[1]));
+        const authContext = AUTH_URL_CONTEXT_PATTERN.test(token) || queryNames.some(shouldRedactQueryParam);
+        return token.replace(/([?#&])([^=&#\s"'`<>\])}]+)=([^&#\s"'`<>\])}]*)/g, (match, separator, rawName, rawValue) => {
+            if (rawValue === "[REDACTED" ||
+                rawValue === "[REDACTED]" ||
+                /%5Bredacted%5D/i.test(rawValue)) {
+                return match;
+            }
+            if (!isSensitiveParameter(decodeParameterName(rawName), authContext)) {
+                return match;
+            }
+            return `${separator}${rawName}=[REDACTED]`;
+        });
+    });
+}
+function redactLooseUrlUserinfo(text) {
+    return text.replace(/\b([A-Za-z][A-Za-z0-9+.-]*:\/\/)([^\s"'`/@]+)@([^\s"'`]+)/g, (match, prefix, userinfo, suffix) => {
+        if (/%5Bredacted%5D/i.test(userinfo)) {
+            return match;
+        }
+        if (userinfo.includes("[REDACTED]")) {
+            return redactLooseUrlParameterText(match);
+        }
+        return redactLooseUrlParameterText(`${prefix}${userinfo.includes(":") ? "[REDACTED]:[REDACTED]" : "[REDACTED]"}@${suffix}`);
+    });
+}
+export function redactLooseUrls(text) {
+    const urls = text.replace(/\b[A-Za-z][A-Za-z0-9+.-]*:\/\/[^\s"'`<>\])]+/g, (match) => redactUrlToken(match));
+    return redactLooseUrlParameterText(redactLooseUrlUserinfo(urls));
+}

package/dist/extensions/agent-browser/lib/results/action-contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/extensions/agent-browser/lib/results/action-recommendations.js

@@ -1,281 +1,38 @@
 import { isOpenNavigationCommand, isPageMutationCommand } from "../command-taxonomy.js";
-import { isPendingRecordingArtifact } from "./artifact-manifest.js";
-import { applySessionToNextActions, buildInspectOverlayStateAction, buildNextToolAction } from "./next-actions.js";
-import { AGENT_BROWSER_RECOVERY_NEXT_ACTION_IDS, buildRecoveryNextActions, } from "./recovery-actions.js";
-function buildArtifactAction(path) {
-    return {
-        artifactPath: path,
-        id: "use-saved-artifact",
-        reason: "Use the saved artifact path from the structured result instead of scraping it from text.",
-        safety: "Verify artifact metadata such as exists/status before treating the file as durable.",
-        tool: "agent_browser",
-    };
-}
-function buildArtifactVerificationAction(artifact) {
-    return {
-        artifactPath: artifact.path,
-        id: "verify-artifact-path",
-        reason: "The wrapper has artifact metadata but did not verify this file as present on disk.",
-        safety: "Check details.artifactVerification and the filesystem before treating the artifact as durable.",
-        tool: "agent_browser",
-    };
-}
-function buildElectronToolAction(options) {
-    return {
-        id: options.id,
-        params: { action: options.action, launchId: options.launchId },
-        reason: options.reason,
-        ...(options.safety ? { safety: options.safety } : {}),
-        tool: "agent_browser_electron",
-    };
-}
-function getDownloadRetryPath(args, fallback) {
-    if (fallback)
-        return fallback;
-    if (!args || args.length === 0)
-        return undefined;
-    const downloadFlagIndex = args.indexOf("--download");
-    if (downloadFlagIndex >= 0) {
-        const candidate = args[downloadFlagIndex + 1];
-        return candidate && !candidate.startsWith("-") ? candidate : undefined;
-    }
-    const downloadCommandIndex = args.indexOf("download");
-    if (downloadCommandIndex >= 0 && args.length > downloadCommandIndex + 2) {
-        return args[args.length - 1];
-    }
-    return undefined;
-}
-export function buildAgentBrowserNextActions(options) {
-    const actions = [];
-    if (options.recovery) {
-        actions.push(...buildRecoveryNextActions(options.recovery));
-    }
-    if (options.electron?.launchId) {
-        const { launchId, sessionName, status } = options.electron;
-        if (options.resultCategory === "success" && status !== "cleaned") {
-            actions.push(buildElectronToolAction({
-                action: "status",
-                id: "status-electron-launch",
-                launchId,
-                reason: "Check the wrapper-tracked Electron launch liveness and current CDP targets without mutating the app.",
-            }), buildElectronToolAction({
-                action: "probe",
-                id: "probe-electron-launch",
-                launchId,
-                reason: "Probe the attached Electron managed session and carry the wrapper launchId for follow-up diagnostics.",
-            }), buildElectronToolAction({
-                action: "cleanup",
-                id: "cleanup-electron-launch",
-                launchId,
-                reason: "Clean the wrapper-owned Electron process and isolated userDataDir when the run is complete.",
-                safety: "Only operates on the launchId created by electron.launch; explicit artifacts and manually launched apps remain host-owned.",
-            }));
-            if (sessionName) {
-                actions.push(buildNextToolAction({
-                    args: ["--session", sessionName, "tab", "list"],
-                    id: "list-electron-tabs",
-                    reason: "Inspect attached Electron page/webview targets before choosing the active tab.",
-                }), buildNextToolAction({
-                    args: ["--session", sessionName, "snapshot", "-i"],
-                    id: "snapshot-electron-session",
-                    reason: "Refresh interactive refs for the attached Electron session.",
-                    safety: "Use current Electron refs only after a fresh snapshot for this session.",
-                }));
-            }
-        }
-        else if (options.resultCategory === "failure" && options.failureCategory === "cleanup-failed") {
-            actions.push(buildElectronToolAction({
-                action: "status",
-                id: "status-electron-launch",
-                launchId,
-                reason: "Inspect which wrapper-tracked Electron resources remain after partial cleanup.",
-            }), buildElectronToolAction({
-                action: "cleanup",
-                id: "retry-electron-cleanup",
-                launchId,
-                reason: "Retry cleanup for the same wrapper-owned Electron launch after reviewing remaining resources.",
-                safety: "Only retry for the same launchId; do not use cleanup for manually launched Electron apps.",
-            }));
-        }
-    }
-    if (options.resultCategory === "success") {
-        if (isOpenNavigationCommand(options.command)) {
-            actions.push(buildNextToolAction({
+import { applySessionToNextActions, buildNextToolAction } from "./next-actions.js";
+import { buildRecoveryNextActions } from "./recovery-actions.js";
+import { buildElectronNextActions } from "./electron-recommendations.js";
+import { buildPendingRecordingNextActions, buildSavedArtifactNextActions, } from "./artifact-recommendations.js";
+import { buildFailureNextActions } from "./failure-recommendations.js";
+function buildSuccessNavigationActions(options) {
+    if (isOpenNavigationCommand(options.command)) {
+        return [
+            buildNextToolAction({
                 args: ["snapshot", "-i"],
                 id: "inspect-opened-page",
                 reason: "Inspect the opened page before choosing interactive refs.",
-            }));
-        }
-        else if (isPageMutationCommand(options.command, options.subcommand)) {
-            actions.push(buildNextToolAction({
+            }),
+        ];
+    }
+    return isPageMutationCommand(options.command, options.subcommand)
+        ? [
+            buildNextToolAction({
                 args: ["snapshot", "-i"],
                 id: "inspect-after-mutation",
                 reason: "Refresh interactive refs after a browser mutation, navigation, scroll, or rerender.",
                 safety: "Do not reuse prior @refs until a fresh snapshot confirms they still exist.",
-            }));
-        }
-        const artifacts = options.artifacts ?? [];
-        const savedFileArtifact = options.savedFilePath ? artifacts.find((artifact) => artifact.path === options.savedFilePath) : undefined;
-        if (options.savedFilePath && savedFileArtifact?.exists !== false) {
-            actions.push(buildArtifactAction(options.savedFilePath));
-        }
-        for (const artifact of artifacts) {
-            if (isPendingRecordingArtifact(artifact))
-                continue;
-            if (artifact.exists === false) {
-                if (artifact.kind === "download") {
-                    actions.push(buildNextToolAction({
-                        args: ["wait", "--download", artifact.path],
-                        id: "wait-for-download",
-                        reason: "Upstream reported a download path, but the wrapper did not verify the file on disk.",
-                        safety: "Use an explicit wait timeout; if you set top-level timeoutMs, keep it above the wait duration plus a small grace window.",
-                    }));
-                }
-                else {
-                    actions.push(buildArtifactVerificationAction(artifact));
-                }
-                continue;
-            }
-            if (artifact.path !== options.savedFilePath) {
-                actions.push(buildArtifactAction(artifact.path));
-            }
-        }
-    }
-    else {
-        switch (options.failureCategory) {
-            case "artifact-missing":
-                for (const artifact of options.artifacts ?? []) {
-                    if (isPendingRecordingArtifact(artifact) || (artifact.exists !== false && artifact.status !== "stale"))
-                        continue;
-                    if (artifact.kind === "download") {
-                        actions.push(buildNextToolAction({
-                            args: ["wait", "--download", artifact.path],
-                            id: "wait-for-download",
-                            reason: "The requested download artifact was not found on disk after upstream reported completion.",
-                            safety: "Use an explicit wait timeout; if you set top-level timeoutMs, keep it above the wait duration plus a small grace window.",
-                        }));
-                    }
-                    else {
-                        actions.push(buildArtifactVerificationAction(artifact));
-                    }
-                }
-                break;
-            case "confirmation-required":
-                if (options.confirmationId) {
-                    actions.push(buildNextToolAction({
-                        args: ["confirm", options.confirmationId],
-                        id: "approve-confirmation",
-                        reason: "Approve the pending upstream confirmation when the requested action is safe.",
-                        safety: "Only confirm after reviewing the guarded action shown in the result.",
-                    }), buildNextToolAction({
-                        args: ["deny", options.confirmationId],
-                        id: "deny-confirmation",
-                        reason: "Deny the pending upstream confirmation when the guarded action is unsafe or unintended.",
-                    }));
-                }
-                break;
-            case "stale-ref":
-            case "selector-not-found":
-            case "selector-unsupported":
-                actions.push(buildNextToolAction({
-                    args: ["snapshot", "-i"],
-                    id: "refresh-interactive-refs",
-                    reason: "Get current interactive refs before retrying the element action.",
-                    safety: "Prefer a current @ref or a stable find locator; do not retry stale refs blindly.",
-                }));
-                break;
-            case "download-not-verified":
-                {
-                    const retryPath = getDownloadRetryPath(options.args, options.savedFilePath);
-                    actions.push(buildNextToolAction({
-                        args: retryPath ? ["wait", "--download", retryPath] : ["wait", "--download"],
-                        id: "wait-for-download",
-                        reason: "Wait for the browser download and let the wrapper verify saved-file metadata.",
-                        safety: "Use an explicit wait timeout; if you set top-level timeoutMs, keep it above the wait duration plus a small grace window.",
-                    }));
-                }
-                break;
-            case "timeout":
-                {
-                    if (options.command === "session" && options.subcommand === "info") {
-                        actions.push(buildNextToolAction({
-                            args: ["session", "info"],
-                            id: "retry-session-info",
-                            reason: "Retry the same session status check without opening a browser or inspecting its page.",
-                        }));
-                        break;
-                    }
-                    const textAssertion = options.command === "wait" && options.args?.includes("--text") === true;
-                    const urlAssertion = options.command === "wait" && options.args?.includes("--url") === true;
-                    actions.push(buildNextToolAction({
-                        args: ["snapshot", "-i"],
-                        id: textAssertion ? "inspect-after-text-assertion-failure" : "inspect-after-timeout",
-                        reason: textAssertion
-                            ? "Inspect the current page after the text assertion failed before concluding the expected text is absent."
-                            : options.command === "wait"
-                                ? "Inspect the current page after the wait condition timed out before retrying with a different selector or timeout."
-                                : "Inspect the current page after the timed-out browser operation.",
-                        safety: textAssertion
-                            ? "Read-only snapshot; use current refs or visible text from this page before retrying the assertion."
-                            : "Read-only snapshot; do not assume the timed-out interaction completed.",
-                    }));
-                    if (urlAssertion) {
-                        actions.push(buildNextToolAction({
-                            args: ["open", "about:blank"],
-                            id: "fresh-session-after-url-wait-timeout",
-                            reason: "If a preceding click or form submit reported success but the page never navigated, upstream click dispatch may have silently missed (observed with agent-browser 0.34 after many spaced commands); replace about:blank with the target URL and replay the flow as one batch in a fresh session instead of retrying the wait.",
-                            safety: "Abandons the current browser session; capture page evidence with the inspect action first, and only abandon when the wait target is not simply wrong or slow.",
-                            sessionMode: "fresh",
-                        }));
-                    }
-                }
-                break;
-            case "upstream-error":
-                if (options.overlayBlockedClick) {
-                    actions.push(buildInspectOverlayStateAction(options.sessionName));
-                }
-                else if (isOpenNavigationCommand(options.command)) {
-                    actions.push(buildNextToolAction({
-                        args: ["get", "url"],
-                        id: "inspect-page-after-navigation-error",
-                        reason: "Check which page, if any, remains active after the navigation or network error.",
-                        safety: "Read-only URL inspection; verify connectivity and the target URL before retrying navigation.",
-                    }));
-                }
-                break;
-            case "tab-gone":
-                actions.push(buildNextToolAction({
-                    args: ["tab", "list"],
-                    id: AGENT_BROWSER_RECOVERY_NEXT_ACTION_IDS.tabGoneListTabs,
-                    reason: "The pinned bound tab is gone; inspect remaining tabs before acting on a neighbor.",
-                    safety: "Read-only. Prefer a listed tab id, label, or CDP targetId, or open a new tab to rebind.",
-                }), buildNextToolAction({
-                    args: ["tab", "new"],
-                    id: AGENT_BROWSER_RECOVERY_NEXT_ACTION_IDS.tabGoneNewTab,
-                    reason: "Bind a fresh tab after tab_gone instead of continuing on another session's page.",
-                    safety: "Opens a new tab in this session and rebinds the pin; pass a URL if you know the intended page.",
-                }));
-                break;
-            case "tab-drift":
-                if (options.recovery?.kind === "about-blank" || options.recovery?.kind === "tab-drift") {
-                    break;
-                }
-                actions.push(buildNextToolAction({
-                    args: ["tab", "list"],
-                    id: AGENT_BROWSER_RECOVERY_NEXT_ACTION_IDS.genericTabDriftListTabs,
-                    reason: "Inspect available tabs before selecting the intended target.",
-                    safety: "Read-only. Retry snapshot only after selecting or confirming the intended stable tab.",
-                }));
-                break;
-        }
-    }
-    if ((options.artifacts ?? []).some(isPendingRecordingArtifact)) {
-        actions.push(buildNextToolAction({
-            args: ["record", "stop"],
-            id: "stop-pending-recording",
-            reason: "Stop the active recording so the requested video can be finalized and verified on disk.",
-            safety: "The file remains pending until record stop succeeds; verify details.artifactVerification afterward.",
-        }));
-    }
+            }),
+        ]
+        : [];
+}
+export function buildAgentBrowserNextActions(options) {
+    const actions = [
+        ...(options.recovery ? buildRecoveryNextActions(options.recovery) : []),
+        ...buildElectronNextActions(options),
+        ...(options.resultCategory === "success"
+            ? [...buildSuccessNavigationActions(options), ...buildSavedArtifactNextActions(options)]
+            : buildFailureNextActions(options)),
+        ...buildPendingRecordingNextActions(options.artifacts),
+    ];
     return applySessionToNextActions(actions.length > 0 ? actions : undefined, options.sessionName);
 }

package/dist/extensions/agent-browser/lib/results/artifact-contracts.js

@@ -0,0 +1 @@
+export {};