pi-agent-browser-native 0.9.4 → 0.9.6

package/dist/extensions/agent-browser/lib/results/editable-ref-evidence.js

@@ -1,99 +0,0 @@
-const EDITABLE_REF_EVIDENCE_KEYS = [
-    "editable",
-    "contentEditable",
-    "contenteditable",
-    "isContentEditable",
-];
-const EDITABLE_FALSE_TEXT_PATTERN = /\b(?:contenteditable|editable)\s*=\s*["']?(?:false|0)["']?/i;
-const EDITABLE_ASSIGNMENT_TEXT_PATTERN = /\b(contenteditable|editable)\s*=\s*("[^"]*"|'[^']*'|[^\s,\]]+)/gi;
-const EDITABLE_BARE_TEXT_PATTERN = /\b(?:contenteditable|editable)\b(?!\s*=)/i;
-function parseEditableEvidenceValue(value) {
-    if (typeof value === "boolean") {
-        return value;
-    }
-    if (typeof value === "number") {
-        if (value === 1) {
-            return true;
-        }
-        if (value === 0) {
-            return false;
-        }
-        return undefined;
-    }
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const normalized = value
-        .trim()
-        .replace(/^["']|["']$/g, "")
-        .toLowerCase();
-    if (["false", "0", "no"].includes(normalized)) {
-        return false;
-    }
-    if (["", "true", "1", "yes", "plaintext-only"].includes(normalized)) {
-        return true;
-    }
-    return undefined;
-}
-function stripLeadingSnapshotAccessibleName(text) {
-    return text.replace(/^(\s*[-*]\s+\S+\s+)(?:"[^"]*"|'[^']*')/, "$1");
-}
-function parseEditableAssignments(markerText) {
-    let hasPositiveAssignment = false;
-    for (const match of markerText.matchAll(EDITABLE_ASSIGNMENT_TEXT_PATTERN)) {
-        const key = match[1]?.toLowerCase();
-        const evidence = parseEditableEvidenceValue(match[2]);
-        if (evidence === false) {
-            return false;
-        }
-        if (evidence === true && (key === "contenteditable" || key === "editable")) {
-            hasPositiveAssignment = true;
-        }
-    }
-    return hasPositiveAssignment ? true : undefined;
-}
-function parseEditableEvidenceText(text) {
-    if (text === undefined || text.length === 0) {
-        return undefined;
-    }
-    const markerText = stripLeadingSnapshotAccessibleName(text);
-    if (EDITABLE_FALSE_TEXT_PATTERN.test(markerText)) {
-        return false;
-    }
-    const assignment = parseEditableAssignments(markerText);
-    if (assignment !== undefined) {
-        return assignment;
-    }
-    return EDITABLE_BARE_TEXT_PATTERN.test(markerText) ? true : undefined;
-}
-function getStructuredEditableEvidence(ref) {
-    if (!ref) {
-        return undefined;
-    }
-    let hasPositiveEvidence = false;
-    for (const key of EDITABLE_REF_EVIDENCE_KEYS) {
-        const evidence = parseEditableEvidenceValue(ref[key]);
-        if (evidence === false) {
-            return false;
-        }
-        if (evidence === true) {
-            hasPositiveEvidence = true;
-        }
-    }
-    return hasPositiveEvidence ? true : undefined;
-}
-export function getEditableRefEvidence(options) {
-    const structuredEvidence = getStructuredEditableEvidence(options.ref);
-    if (structuredEvidence === false) {
-        return false;
-    }
-    let hasPositiveEvidence = structuredEvidence === true;
-    const textEvidence = parseEditableEvidenceText(options.text);
-    if (textEvidence === false) {
-        return false;
-    }
-    if (textEvidence === true) {
-        hasPositiveEvidence = true;
-    }
-    return hasPositiveEvidence ? true : undefined;
-}

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

@@ -1,83 +0,0 @@
-import { buildNextToolAction } from "./next-actions.js";
-function buildElectronToolAction(options) {
-    return {
-        id: options.id,
-        params: { action: options.action, launchId: options.launchId },
-        reason: options.reason,
-        ...(options.safety !== undefined && options.safety.length > 0
-            ? { safety: options.safety }
-            : {}),
-        tool: "agent_browser_electron",
-    };
-}
-function buildActiveLaunchActions(launchId) {
-    return [
-        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.",
-        }),
-    ];
-}
-function buildElectronSessionActions(sessionName) {
-    if (sessionName === undefined || sessionName.length === 0) {
-        return [];
-    }
-    return [
-        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.",
-        }),
-    ];
-}
-export function buildElectronNextActions(options) {
-    const launchId = options.electron?.launchId;
-    if (launchId === undefined || launchId.length === 0) {
-        return [];
-    }
-    if (options.resultCategory === "success" && options.electron?.status !== "cleaned") {
-        return [
-            ...buildActiveLaunchActions(launchId),
-            ...buildElectronSessionActions(options.electron?.sessionName),
-        ];
-    }
-    if (options.resultCategory === "failure" && options.failureCategory === "cleanup-failed") {
-        return [
-            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.",
-            }),
-        ];
-    }
-    return [];
-}

package/dist/extensions/agent-browser/lib/results/envelope-decoding.js

@@ -1,48 +0,0 @@
-import { isRecord } from "../parsing.js";
-function decodePluginList(value) {
-    const keys = Object.keys(value);
-    if (keys.length !== 1) {
-        return undefined;
-    }
-    if (keys[0] === "plugins" && Array.isArray(value.plugins)) {
-        return { success: true, data: { plugins: value.plugins } };
-    }
-    if (keys[0] === "plugin" && isRecord(value.plugin) && !Array.isArray(value.plugin)) {
-        return { success: true, data: { plugin: value.plugin } };
-    }
-    return undefined;
-}
-export function decodeAgentBrowserEnvelope(value) {
-    if (Array.isArray(value)) {
-        return {
-            envelope: {
-                success: value.every((item) => !isRecord(item) || item.success !== false),
-                data: value,
-            },
-        };
-    }
-    if (!isRecord(value)) {
-        return { parseError: "agent-browser returned JSON, but it was not an object envelope." };
-    }
-    const plugin = decodePluginList(value);
-    if (plugin) {
-        return { envelope: plugin };
-    }
-    if (!("success" in value)) {
-        return {
-            parseError: "agent-browser returned an invalid JSON envelope: missing boolean success field.",
-        };
-    }
-    if (typeof value.success !== "boolean") {
-        return {
-            parseError: "agent-browser returned an invalid JSON envelope: success field must be boolean.",
-        };
-    }
-    if (!Object.hasOwn(value, "data")) {
-        const { success, error, ...topLevelData } = value;
-        if (Object.keys(topLevelData).length > 0) {
-            return { envelope: { error, success, data: topLevelData } };
-        }
-    }
-    return { envelope: { ...value, success: value.success } };
-}

package/dist/extensions/agent-browser/lib/results/envelope.js

@@ -1,198 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { isRecord } from "../parsing.js";
-import { detectConfirmationRequired } from "./confirmation.js";
-import { decodeAgentBrowserEnvelope } from "./envelope-decoding.js";
-import { stringifyUnknown } from "./text.js";
-function hasStructuredBatchStepFailure(data) {
-    return Array.isArray(data) && data.some((item) => isRecord(item) && item.success === false);
-}
-async function readEnvelopeSource(options) {
-    if (options.stdoutPath === undefined || options.stdoutPath.length === 0) {
-        return options.stdout;
-    }
-    try {
-        return await readFile(options.stdoutPath, "utf8");
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : stringifyUnknown(error);
-        throw new Error(`agent-browser output spill file could not be read: ${message}`, {
-            cause: error,
-        });
-    }
-}
-export function extractEnvelopeErrorText(error) {
-    if (typeof error === "string") {
-        const trimmed = error.trim();
-        return trimmed.length > 0 ? trimmed : undefined;
-    }
-    if (typeof error === "number" || typeof error === "boolean") {
-        return String(error);
-    }
-    if (Array.isArray(error)) {
-        const parts = error
-            .map((item) => extractEnvelopeErrorText(item) ?? stringifyUnknown(item))
-            .filter((item) => item.length > 0);
-        return parts.length > 0 ? parts.join("\n") : undefined;
-    }
-    if (!isRecord(error)) {
-        return error === null || error === undefined ? undefined : stringifyUnknown(error);
-    }
-    return extractStructuredEnvelopeErrorText(error);
-}
-function extractStructuredEnvelopeErrorText(error) {
-    for (const key of ["message", "error", "details", "cause", "stderr"]) {
-        const value = extractEnvelopeErrorText(error[key]);
-        if ((value ?? "") !== "") {
-            return value;
-        }
-    }
-    const fallback = stringifyUnknown(error).trim();
-    return fallback.length > 0 && fallback !== "{}" ? fallback : undefined;
-}
-function getEnvelopeOutputMode(options) {
-    return typeof options === "string"
-        ? { plainText: false, textOutput: false }
-        : { plainText: options.plainText === true, textOutput: options.textOutput === true };
-}
-export async function parseAgentBrowserEnvelope(options) {
-    let stdout;
-    try {
-        stdout = typeof options === "string" ? options : await readEnvelopeSource(options);
-    }
-    catch (error) {
-        return { parseError: error instanceof Error ? error.message : stringifyUnknown(error) };
-    }
-    // ponytail: native text has no machine receipts; use JSON mode for structured evidence.
-    // JSON-looking page text must never become an envelope, confirmation, or batch row.
-    const { plainText, textOutput } = getEnvelopeOutputMode(options);
-    if (textOutput) {
-        return { envelope: { success: true, data: stdout } };
-    }
-    const trimmed = stdout.trim();
-    if (trimmed.length === 0 && !plainText) {
-        return { parseError: "agent-browser returned no JSON output." };
-    }
-    try {
-        const parsed = JSON.parse(trimmed);
-        return decodeAgentBrowserEnvelope(parsed);
-    }
-    catch (error) {
-        if (plainText) {
-            return { envelope: { success: true, data: trimmed } };
-        }
-        const message = error instanceof Error ? error.message : stringifyUnknown(error);
-        return { parseError: `agent-browser returned invalid JSON: ${message}` };
-    }
-}
-function buildInvocationLabel(options) {
-    if (options.effectiveArgs && options.effectiveArgs.length > 0) {
-        return `agent-browser ${options.effectiveArgs.join(" ")}`;
-    }
-    if (options.command !== undefined && options.command.trim().length > 0) {
-        return `agent-browser ${options.command.trim()}`;
-    }
-    return "agent-browser";
-}
-function appendWrapperRecoveryHint(message, wrapperRecoveryHint) {
-    const hint = wrapperRecoveryHint?.trim();
-    return hint !== undefined && hint.length > 0 ? `${message}\n${hint}` : message;
-}
-function buildFailureFallback(options) {
-    const invocation = buildInvocationLabel(options);
-    const exitSuffix = options.exitCode !== 0 ? ` (exit code ${options.exitCode})` : "";
-    return appendWrapperRecoveryHint(`${invocation} reported failure${exitSuffix}.`, options.wrapperRecoveryHint);
-}
-function buildExitCodeFallback(options) {
-    const invocation = buildInvocationLabel(options);
-    return appendWrapperRecoveryHint(`${invocation} exited with code ${options.exitCode}.`, options.wrapperRecoveryHint);
-}
-function buildWatchdogTimeoutMessage(options) {
-    const timeoutText = options.timeoutMs === undefined
-        ? "the wrapper watchdog"
-        : `the ${options.timeoutMs}ms wrapper watchdog`;
-    const ipcTiming = options.timeoutMs !== undefined && options.timeoutMs <= 30_000
-        ? "before the upstream CLI entered its 30s IPC retry path"
-        : "after waiting beyond the upstream CLI's 30s IPC retry window";
-    return [
-        `agent-browser exceeded ${timeoutText} and was stopped ${ipcTiming}.`,
-        "Prefer a condition wait or split long work into shorter calls; for legitimately long opens or captures, pass agent_browser timeoutMs with a bounded higher value and inspect details.timeoutPartialProgress before retrying.",
-    ].join(" ");
-}
-function isUpstreamIpcReadTimeoutMessage(message) {
-    return /Failed to read: Resource temporarily unavailable(?: \(os error \d+\))?.*daemon may be busy or unresponsive/i.test(message);
-}
-function buildUpstreamIpcReadTimeoutMessage() {
-    return [
-        "agent-browser hit the upstream CLI 30s IPC read timeout while waiting for the daemon response.",
-        'The daemon may still be alive; do not blindly retry a non-idempotent command. Prefer a shorter command, split long waits, or retry with sessionMode: "fresh" after checking tab list.',
-    ].join(" ");
-}
-function maybeAppendStaleRefHint(message, args) {
-    const usedRef = args?.some((arg) => /^@e\d+\b/.test(arg)) ?? false;
-    if (!usedRef || !/could not locate element|element not found|no element/i.test(message)) {
-        return message;
-    }
-    return [
-        message,
-        'This @ref may be stale after navigation, scrolling, or a DOM update. Run `agent_browser` with `{ "args": ["snapshot", "-i"] }` again and retry with a current ref, or use a stable `find` locator.',
-    ].join("\n");
-}
-function getTransportErrorText(options) {
-    if (options.timedOut === true) {
-        return buildWatchdogTimeoutMessage(options);
-    }
-    if (options.aborted) {
-        return "agent-browser was aborted.";
-    }
-    if (options.spawnError) {
-        return options.spawnError.message;
-    }
-    if ((options.parseError ?? "") !== "") {
-        return options.exitCode !== 0 && options.stderr.trim().length > 0
-            ? options.stderr.trim()
-            : options.parseError;
-    }
-    return undefined;
-}
-function getEnvelopeDataError(data) {
-    if (typeof data === "string") {
-        return data;
-    }
-    return isRecord(data) ? data.error : undefined;
-}
-function getFailedEnvelopeFallback(options, errorText) {
-    const stderr = options.stderr.trim();
-    return errorText ?? (stderr.length > 0 ? stderr : buildFailureFallback(options));
-}
-function getFailedEnvelopeErrorText(options, envelope) {
-    const explicitErrorText = extractEnvelopeErrorText(envelope.error);
-    if ((hasStructuredBatchStepFailure(envelope.data) || detectConfirmationRequired(envelope.data)) &&
-        explicitErrorText === undefined) {
-        return undefined;
-    }
-    const envelopeErrorText = explicitErrorText ?? extractEnvelopeErrorText(getEnvelopeDataError(envelope.data));
-    if (envelopeErrorText !== undefined &&
-        envelopeErrorText.length > 0 &&
-        isUpstreamIpcReadTimeoutMessage(envelopeErrorText)) {
-        return buildUpstreamIpcReadTimeoutMessage();
-    }
-    const fallback = getFailedEnvelopeFallback(options, envelopeErrorText);
-    return maybeAppendStaleRefHint(fallback, options.staleRefArgs ?? options.effectiveArgs);
-}
-export function getAgentBrowserErrorText(options) {
-    if (options.plainTextInspection) {
-        return undefined;
-    }
-    const transportErrorText = getTransportErrorText(options);
-    if (transportErrorText !== undefined) {
-        return transportErrorText;
-    }
-    if (options.envelope?.success === false) {
-        return getFailedEnvelopeErrorText(options, options.envelope);
-    }
-    if (options.exitCode !== 0) {
-        const stderr = options.stderr.trim();
-        return stderr.length > 0 ? stderr : buildExitCodeFallback(options);
-    }
-    return undefined;
-}

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

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

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

@@ -1,180 +0,0 @@
-import { isOpenNavigationCommand } from "../command-taxonomy.js";
-import { buildInspectOverlayStateAction, buildNextToolAction } from "./next-actions.js";
-import { AGENT_BROWSER_RECOVERY_NEXT_ACTION_IDS } from "./recovery-actions.js";
-import { buildMissingArtifactNextActions } from "./artifact-recommendations.js";
-function getExplicitDownloadWaitPath(args) {
-    const candidate = args.at(args.indexOf("--download") + 1);
-    return candidate !== undefined && candidate.length > 0 && !candidate.startsWith("-")
-        ? candidate
-        : undefined;
-}
-function getDownloadRetryPath(args, fallback) {
-    if (fallback !== undefined && fallback.length > 0) {
-        return fallback;
-    }
-    if (!args || args.length === 0) {
-        return undefined;
-    }
-    if (args.includes("--download")) {
-        return getExplicitDownloadWaitPath(args);
-    }
-    const downloadCommandIndex = args.indexOf("download");
-    return downloadCommandIndex >= 0 && args.length > downloadCommandIndex + 2
-        ? args.at(-1)
-        : undefined;
-}
-function buildConfirmationActions(id) {
-    if (id === undefined || id.length === 0) {
-        return [];
-    }
-    return [
-        buildNextToolAction({
-            args: ["confirm", id],
-            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", id],
-            id: "deny-confirmation",
-            reason: "Deny the pending upstream confirmation when the guarded action is unsafe or unintended.",
-        }),
-    ];
-}
-function buildDownloadFailureActions(options) {
-    const path = getDownloadRetryPath(options.args, options.savedFilePath);
-    return [
-        buildNextToolAction({
-            args: path !== undefined && path.length > 0
-                ? ["wait", "--download", path]
-                : ["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.",
-        }),
-    ];
-}
-function getTimeoutInspectionReason(command, textAssertion) {
-    if (textAssertion) {
-        return "Inspect the current page after the text assertion failed before concluding the expected text is absent.";
-    }
-    return 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.";
-}
-function buildTimeoutActions(options) {
-    if (options.command === "session" && options.subcommand === "info") {
-        return [
-            buildNextToolAction({
-                args: ["session", "info"],
-                id: "retry-session-info",
-                reason: "Retry the same session status check without opening a browser or inspecting its page.",
-            }),
-        ];
-    }
-    const textAssertion = options.command === "wait" && options.args?.includes("--text") === true;
-    const urlAssertion = options.command === "wait" && options.args?.includes("--url") === true;
-    const actions = [
-        buildNextToolAction({
-            args: ["snapshot", "-i"],
-            id: textAssertion ? "inspect-after-text-assertion-failure" : "inspect-after-timeout",
-            reason: getTimeoutInspectionReason(options.command, textAssertion),
-            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",
-        }));
-    }
-    return actions;
-}
-function buildUpstreamFailureActions(options) {
-    if (options.overlayBlockedClick === true) {
-        return [buildInspectOverlayStateAction(options.sessionName)];
-    }
-    return isOpenNavigationCommand(options.command)
-        ? [
-            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.",
-            }),
-        ]
-        : [];
-}
-function buildTabGoneActions() {
-    return [
-        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.",
-        }),
-    ];
-}
-function buildTabDriftActions(options) {
-    if (options.recovery?.kind === "about-blank" || options.recovery?.kind === "tab-drift") {
-        return [];
-    }
-    return [
-        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.",
-        }),
-    ];
-}
-export function buildFailureNextActions(options) {
-    switch (options.failureCategory) {
-        case "artifact-missing":
-            return buildMissingArtifactNextActions(options.artifacts);
-        case "confirmation-required":
-            return buildConfirmationActions(options.confirmationId);
-        case "stale-ref":
-        case "selector-not-found":
-        case "selector-unsupported":
-            return [
-                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.",
-                }),
-            ];
-        case "download-not-verified":
-            return buildDownloadFailureActions(options);
-        case "timeout":
-            return buildTimeoutActions(options);
-        case "upstream-error":
-            return buildUpstreamFailureActions(options);
-        case "tab-gone":
-            return buildTabGoneActions();
-        case "tab-drift":
-            return buildTabDriftActions(options);
-        case "aborted":
-        case "cleanup-failed":
-        case "missing-binary":
-        case "parse-failure":
-        case "policy-blocked":
-        case "qa-failure":
-        case "script-error":
-        case "validation-error":
-        case undefined:
-            return [];
-    }
-}