pi-agent-browser-native 0.9.2 → 0.9.4

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 {};

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

@@ -0,0 +1,133 @@
+import { isRecord } from "../parsing.js";
+function finiteNonnegative(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function safeCount(value) {
+    return finiteNonnegative(value) && Number.isSafeInteger(value);
+}
+function optionalStrings(value, keys) {
+    return keys.every((key) => value[key] === undefined || typeof value[key] === "string");
+}
+function nullableStrings(value, keys) {
+    return keys.every((key) => value[key] === null || typeof value[key] === "string");
+}
+function nullableNumbers(value, keys) {
+    return keys.every((key) => value[key] === null || finiteNonnegative(value[key]));
+}
+function nullableBoolean(value) {
+    return value === null || typeof value === "boolean";
+}
+function captureIsValid(value) {
+    return (nullableStrings(value, [
+        "startedAt",
+        "endedAt",
+        "firstFrameAt",
+        "lastFrameAt",
+        "timestampSource",
+    ]) &&
+        nullableNumbers(value, [
+            "durationMs",
+            "firstFrameAfterMs",
+            "lastFrameAfterMs",
+            "averageFps",
+            "maxFrameGapMs",
+        ]));
+}
+function outputIsValid(value) {
+    return (nullableStrings(value, ["durationSource"]) &&
+        nullableNumbers(value, [
+            "frames",
+            "fps",
+            "encodedFrames",
+            "durationMs",
+            "heldFrames",
+            "droppedFrames",
+            "skippedFrames",
+        ]) &&
+        nullableBoolean(value.encoderSucceeded));
+}
+function recordingIsValid(value) {
+    if (!isRecord(value) ||
+        !isRecord(value.capture) ||
+        !isRecord(value.output) ||
+        !isRecord(value.file)) {
+        return false;
+    }
+    return (recordingScalarsAreValid(value) &&
+        captureIsValid(value.capture) &&
+        outputIsValid(value.output) &&
+        nullableBoolean(value.file.exists) &&
+        nullableNumbers(value.file, ["sizeBytes"]));
+}
+function recordingScalarsAreValid(value) {
+    return (typeof value.warning === "string" &&
+        typeof value.path === "string" &&
+        nullableStrings(value, ["recordingId", "error"]) &&
+        nullableBoolean(value.success) &&
+        nullableNumbers(value, ["frames", "capturedFrames", "fps"]));
+}
+function optionalNumbersAreValid(value) {
+    return (["evictedAtMs", "recordingStartedAtMs"].every((key) => value[key] === undefined || (typeof value[key] === "number" && Number.isFinite(value[key]))) &&
+        (value.sizeBytes === undefined || finiteNonnegative(value.sizeBytes)));
+}
+function optionalRecordingIsValid(value) {
+    return ((value.recordingState === undefined || value.recordingState === "openRecording") &&
+        (value.recording === undefined || recordingIsValid(value.recording)) &&
+        (value.status === undefined ||
+            [
+                "failed",
+                "missing",
+                "pending",
+                "repaired-from-temp",
+                "saved",
+                "stale",
+                "unverified",
+                "upstream-temp-only",
+            ].some((status) => status === value.status)));
+}
+function optionalEvidenceIsValid(value) {
+    return (optionalStrings(value, [
+        "absolutePath",
+        "command",
+        "cwd",
+        "extension",
+        "mediaType",
+        "namespace",
+        "requestedPath",
+        "session",
+        "subcommand",
+    ]) &&
+        (value.exists === undefined || typeof value.exists === "boolean") &&
+        optionalNumbersAreValid(value) &&
+        optionalRecordingIsValid(value));
+}
+function isManifestEntry(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return (typeof value.path === "string" &&
+        value.path.trim().length > 0 &&
+        typeof value.createdAtMs === "number" &&
+        Number.isFinite(value.createdAtMs) &&
+        ["evicted", "ephemeral", "live", "missing"].some((state) => state === value.retentionState) &&
+        ["explicit-path", "persistent-session", "process-temp"].some((scope) => scope === value.storageScope) &&
+        ["download", "file", "har", "image", "pdf", "profile", "trace", "video", "spill"].some((kind) => kind === value.kind) &&
+        optionalEvidenceIsValid(value));
+}
+function manifestCountsAreValid(value) {
+    return (safeCount(value.maxEntries) &&
+        value.maxEntries !== 0 &&
+        safeCount(value.liveCount) &&
+        safeCount(value.evictedCount));
+}
+export function isSessionArtifactManifest(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return (value.version === 1 &&
+        Array.isArray(value.entries) &&
+        value.entries.every(isManifestEntry) &&
+        typeof value.updatedAtMs === "number" &&
+        Number.isFinite(value.updatedAtMs) &&
+        manifestCountsAreValid(value));
+}