pi-agent-browser-native 0.9.4 → 0.9.6

package/dist/extensions/agent-browser/lib/orchestration/script-mode.js

@@ -1,220 +0,0 @@
-import { stat } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { AGENT_BROWSER_SCRIPT_FINAL_OUTPUT_MAX_BYTES, createAgentBrowserScriptCloseArgs, isAgentBrowserScriptSessionName, } from "../input-modes/script.js";
-import { isRecord } from "../parsing.js";
-import { appendBrowserTransition, getBrowserRecord } from "../browser-transcript.js";
-import { redactSensitiveText } from "../runtime.js";
-import { attachInlineImage } from "../results/presentation/artifacts.js";
-import { projectAgentBrowserObservation } from "../results/presentation/content.js";
-import { redactPresentationData } from "../results/presentation/diagnostic-redaction.js";
-import { collectCodeArtifactReceipts, collectCodeFileArtifacts, } from "./code-artifact-observation.js";
-import { parseCodeImageObservation } from "./code-image-observation.js";
-// The offline converter retains outstanding isolated-session cleanup facts in canonical events.
-export function getScriptSessionLeasesFromBranch(branch, ownerSessionId) {
-    const leases = new Map();
-    for (const entry of branch) {
-        const lease = parseScriptLease(getBrowserRecord(entry)?.event.state.scriptLease, ownerSessionId);
-        if (lease !== undefined) {
-            leases.set(lease.sessionName, lease);
-        }
-    }
-    return leases;
-}
-function parseScriptLease(value, ownerSessionId) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    if (ownerSessionId !== undefined && value.ownerSessionId !== ownerSessionId) {
-        return undefined;
-    }
-    const { closeCommandArgs, launchAttempted, sessionName } = value;
-    const cleanup = ["active", "closed", "failed"].find((state) => state === value.cleanup);
-    if (!isAgentBrowserScriptSessionName(sessionName)) {
-        return undefined;
-    }
-    if (cleanup === undefined) {
-        return undefined;
-    }
-    const expected = createAgentBrowserScriptCloseArgs(sessionName);
-    if (launchAttempted !== true || !matchesCloseCommand(closeCommandArgs, expected)) {
-        return undefined;
-    }
-    return {
-        cleanup,
-        closeCommandArgs: expected,
-        launchAttempted: true,
-        sessionName,
-        ownerSessionId: typeof value.ownerSessionId === "string" ? value.ownerSessionId : undefined,
-    };
-}
-function matchesCloseCommand(value, expected) {
-    return (Array.isArray(value) &&
-        value.length === expected.length &&
-        value.every((token, index) => token === expected[index]));
-}
-export function appendScriptSessionLease(pi, sessionName, cleanup, ownerSessionId) {
-    appendBrowserTransition(pi, {
-        event: {
-            version: 1,
-            phase: "state",
-            operationId: randomUUID(),
-            toolCallId: "cleanup",
-            commandIndex: 0,
-            isError: cleanup !== "closed",
-            state: {
-                scriptLease: {
-                    cleanup,
-                    closeCommandArgs: createAgentBrowserScriptCloseArgs(sessionName),
-                    launchAttempted: true,
-                    sessionName,
-                    ownerSessionId,
-                },
-            },
-        },
-    });
-}
-class BrowserCodeOutput {
-    images = new Map();
-    selected = new Map();
-    receipts = new Map();
-    fileArtifacts = new Map();
-    selectedBytes = 0;
-    observe = async (result) => {
-        const details = isRecord(result.details) ? result.details : {};
-        const observation = projectAgentBrowserObservation(details, result.isError !== true);
-        for (const entry of collectCodeArtifactReceipts(observation.artifactVerification)) {
-            this.receipts.set(entry.absolutePath ?? entry.path, entry);
-        }
-        for (const artifact of collectCodeFileArtifacts(observation.artifacts)) {
-            this.fileArtifacts.set(artifact.absolutePath, artifact);
-        }
-        if (observation.imageObservations === undefined) {
-            return { ...observation, imageObservations: undefined };
-        }
-        if (!Array.isArray(observation.imageObservations)) {
-            throw new Error("Browser capture returned invalid image observations.");
-        }
-        const images = await Promise.all(observation.imageObservations.map(async (value) => {
-            const image = parseCodeImageObservation(value);
-            if (image === undefined) {
-                throw new Error("Browser capture returned invalid image observation geometry.");
-            }
-            const file = await stat(image.path);
-            const id = `image-${this.images.size + 1}`;
-            this.images.set(id, { observation: image, size: file.size, mtime: file.mtimeMs });
-            return { ...image, id };
-        }));
-        return { ...observation, imageObservations: images };
-    };
-    resolveImage(value) {
-        const id = isRecord(value) && typeof value.id === "string" ? value.id : undefined;
-        const image = id !== undefined && id.length > 0 ? this.images.get(id) : undefined;
-        if (id === undefined || id.length === 0 || !image) {
-            throw new Error("emitImage expects an imageObservations handle returned by browser() in this code call.");
-        }
-        return { id, image };
-    }
-    emitImage = async (value) => {
-        const { id, image } = this.resolveImage(value);
-        if (this.selected.has(id)) {
-            return;
-        }
-        if (this.selected.size >= 8 || this.selectedBytes + image.size > 20 * 1_024 * 1_024) {
-            throw new Error("Selected images exceed the code output limit (8 images / 20 MiB). Emit fewer images.");
-        }
-        const file = await stat(image.observation.path);
-        if (!file.isFile() || file.size !== image.size || file.mtimeMs !== image.mtime) {
-            throw new Error("The selected image changed since capture. Capture it again before emitting it.");
-        }
-        const presentation = await attachInlineImage({ content: [], summary: "Selected browser image" }, image.observation.path);
-        if (!presentation.content.some((item) => item.type === "image")) {
-            const reason = presentation.content
-                .filter((item) => item.type === "text")
-                .map((item) => item.text)
-                .join("\n");
-            throw new Error(reason.length > 0 ? reason : "The selected image could not be attached.");
-        }
-        this.selected.set(id, {
-            content: presentation.content.filter((item) => item.type === "image"),
-            observation: { ...image.observation, id },
-        });
-        this.selectedBytes += file.size;
-    };
-    artifactVerification() {
-        const artifacts = [...this.receipts.values()];
-        if (artifacts.length === 0) {
-            return undefined;
-        }
-        const count = (state) => artifacts.filter((entry) => entry.state === state).length;
-        return {
-            artifacts,
-            missingCount: count("missing"),
-            pendingCount: count("pending"),
-            unverifiedCount: count("unverified"),
-            verifiedCount: count("verified"),
-            verified: artifacts.every((entry) => entry.state === "verified"),
-        };
-    }
-    failureCategory(run, outputError) {
-        if (outputError !== undefined) {
-            return "validation-error";
-        }
-        return run.failureCategory ?? (run.rejectedCallCount > 0 ? "validation-error" : undefined);
-    }
-    observation(run, context, output) {
-        const failureCategory = this.failureCategory(run, output.error);
-        const success = run.ok && failureCategory === undefined;
-        return {
-            success,
-            resultCategory: success ? "success" : "failure",
-            failureCategory,
-            data: output.data,
-            error: output.error ??
-                (run.error !== undefined && run.error.length > 0
-                    ? redactSensitiveText(run.error)
-                    : undefined),
-            ...context,
-            codeRun: {
-                callCount: run.callCount,
-                emitCount: run.emitCount,
-                failedCallCount: run.steps.filter((step) => !step.ok).length,
-                rejectedCallCount: run.rejectedCallCount,
-                aborted: run.aborted,
-                timedOut: run.timedOut,
-            },
-            failures: run.failures !== undefined && run.failures.length > 0 ? run.failures : undefined,
-            artifactVerification: this.artifactVerification(),
-            artifacts: this.fileArtifacts.size > 0 ? [...this.fileArtifacts.values()] : undefined,
-            imageObservations: [...this.selected.values()].map((image) => image.observation),
-        };
-    }
-    finish = async (run, sessionName, namespace) => {
-        let data;
-        let error;
-        try {
-            data = redactPresentationData({ command: "code" }, run.data);
-            if (data !== undefined &&
-                Buffer.byteLength(JSON.stringify(data), "utf8") >
-                    AGENT_BROWSER_SCRIPT_FINAL_OUTPUT_MAX_BYTES) {
-                throw new Error("oversized");
-            }
-        }
-        catch {
-            data = undefined;
-            error = "Code output could not be rendered as bounded JSON.";
-        }
-        const observation = this.observation(run, { sessionName, namespace }, { data, error });
-        const success = observation.success === true;
-        const summary = success
-            ? `Browser code completed (${run.callCount} calls).`
-            : "Browser code failed.";
-        return {
-            content: [...this.selected.values()].flatMap((image) => image.content),
-            details: { ...observation, codeSteps: run.steps, summary },
-            isError: !success,
-        };
-    };
-}
-export function createBrowserCodeOutput() {
-    return new BrowserCodeOutput();
-}

package/dist/extensions/agent-browser/lib/owned-managed-session-context.js

@@ -1,55 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import { canonicalizeAgentBrowserNamespace, extractExplicitSessionName, resolveAgentBrowserNamespace, } from "./argv-grammar.js";
-const ownedManagedSessionStorage = new AsyncLocalStorage();
-export async function withOwnedManagedSessionContext(context, run) {
-    return await ownedManagedSessionStorage.run(context, run);
-}
-export function resolveOwnedManagedSessionContext(options) {
-    const namespace = canonicalizeAgentBrowserNamespace(options.namespace);
-    const currentNamespace = canonicalizeAgentBrowserNamespace(options.currentManagedSessionNamespace);
-    const recordedNamespace = canonicalizeAgentBrowserNamespace(options.recordedOwnedSession?.namespace);
-    if (options.recordedOwnedSession &&
-        options.sessionName === options.recordedOwnedSession.sessionName &&
-        namespace === recordedNamespace) {
-        return {
-            cwd: options.recordedOwnedSession.cwd,
-            namespace,
-            restoreState: options.restoreState,
-            sessionName: options.sessionName,
-        };
-    }
-    if (options.managedSessionName !== undefined && options.managedSessionName.length > 0) {
-        return {
-            cwd: options.cwd,
-            namespace,
-            restoreState: options.restoreState,
-            sessionName: options.managedSessionName,
-        };
-    }
-    if (options.sessionName !== undefined &&
-        options.sessionName.length > 0 &&
-        matchesCurrentContext(options, namespace, currentNamespace)) {
-        return {
-            cwd: options.cwd,
-            namespace,
-            restoreState: options.restoreState,
-            sessionName: options.sessionName,
-        };
-    }
-    return undefined;
-}
-function matchesCurrentContext(options, namespace, currentNamespace) {
-    return (options.sessionName === options.currentManagedSessionName && namespace === currentNamespace);
-}
-export function ownedContextMatches(sessionName, args) {
-    const owned = ownedManagedSessionStorage.getStore();
-    return owned &&
-        sessionName === owned.sessionName &&
-        canonicalizeAgentBrowserNamespace(resolveAgentBrowserNamespace(args, owned.namespace)) ===
-            owned.namespace
-        ? owned
-        : undefined;
-}
-export function isOwnedManagedSessionTarget(args) {
-    return ownedContextMatches(extractExplicitSessionName(args), args) !== undefined;
-}

package/dist/extensions/agent-browser/lib/page-target-batch.js

@@ -1,118 +0,0 @@
-import { parseArgvDescriptor } from "./argv-descriptor.js";
-import { parseBatchCommandArgument, parseUserBatchStdin, } from "./orchestration/batch-stdin.js";
-import { BATCH_UNVERIFIED_PAGE_MESSAGE, NON_BAIL_BATCH_NAVIGATION_MESSAGE, getUnverifiedPageError, } from "./page-target-guards.js";
-import { commandMayChangePageTarget, commandVerifiesPageTarget, getResultingPageState, } from "./page-target-navigation.js";
-export const UNSAFE_BATCH_ARGUMENT_MESSAGE = "Batch command arguments could not be inspected. Use batch stdin JSON command arrays instead.";
-export const NESTED_BATCH_ARGUMENT_MESSAGE = "Nested batch commands are not supported. Flatten the batch steps instead.";
-const MAX_NON_BAIL_BATCH_PAGE_STATES = 64;
-function inspectBatchArguments(commands) {
-    const steps = [];
-    for (const command of commands) {
-        const parsed = parseBatchCommandArgument(command);
-        if ((parsed.error !== undefined && parsed.error.length > 0) || parsed.step === undefined) {
-            return { error: parsed.error ?? UNSAFE_BATCH_ARGUMENT_MESSAGE, steps: [] };
-        }
-        if (parseArgvDescriptor(parsed.step).commandInfo.command === "batch") {
-            return { error: NESTED_BATCH_ARGUMENT_MESSAGE, steps: [] };
-        }
-        steps.push(parsed.step);
-    }
-    return { steps };
-}
-export function getBatchCommandSteps(args, stdin) {
-    const descriptor = parseArgvDescriptor(args);
-    if (descriptor.commandInfo.command !== "batch") {
-        return { steps: [] };
-    }
-    const argumentsToParse = descriptor.upstreamCommandTokens
-        .slice(1)
-        .filter((command) => command !== "--bail");
-    if (argumentsToParse.length > 0) {
-        return inspectBatchArguments(argumentsToParse);
-    }
-    const parsed = parseUserBatchStdin(stdin);
-    if (parsed.error !== undefined && parsed.error.length > 0) {
-        return { error: parsed.error, steps: [] };
-    }
-    const steps = (parsed.steps ?? []).filter((step) => step.length > 0);
-    return steps.some((step) => parseArgvDescriptor(step).commandInfo.command === "batch")
-        ? { error: NESTED_BATCH_ARGUMENT_MESSAGE, steps: [] }
-        : { steps };
-}
-function deduplicatePossibleBatchPageStates(states) {
-    const deduplicated = new Map();
-    for (const state of states) {
-        const key = `${state.pageUrlUnknown ? "unknown" : "known"}\0${state.currentPageUrl ?? ""}`;
-        const existing = deduplicated.get(key);
-        deduplicated.set(key, {
-            ...(existing ?? state),
-            retainedAfterFailedNavigation: state.retainedAfterFailedNavigation || existing?.retainedAfterFailedNavigation === true,
-        });
-    }
-    return [...deduplicated.values()];
-}
-function possibleStateError(states, step, options) {
-    if (options.allowsConfirmation) {
-        return undefined;
-    }
-    let failedNavigationHazard = false;
-    for (const state of states) {
-        const error = getUnverifiedPageError({
-            ...options,
-            args: step,
-            pageUrlUnknown: state.pageUrlUnknown,
-        });
-        if (error === undefined || error.length === 0) {
-            continue;
-        }
-        if (!state.retainedAfterFailedNavigation) {
-            return BATCH_UNVERIFIED_PAGE_MESSAGE;
-        }
-        failedNavigationHazard = true;
-    }
-    return failedNavigationHazard ? NON_BAIL_BATCH_NAVIGATION_MESSAGE : undefined;
-}
-function advancePossibleStates(states, step, trustedBatchTabSelection, bail) {
-    const mayChangePageTarget = commandMayChangePageTarget(step, trustedBatchTabSelection);
-    const verifiesPageTarget = commandVerifiesPageTarget(step);
-    const nextStates = [];
-    for (const state of states) {
-        if (nextStates.length >= MAX_NON_BAIL_BATCH_PAGE_STATES) {
-            return { states: [], error: NON_BAIL_BATCH_NAVIGATION_MESSAGE };
-        }
-        nextStates.push({
-            ...getResultingPageState({ args: step, ...state, trustedBatchTabSelection }),
-            retainedAfterFailedNavigation: mayChangePageTarget || verifiesPageTarget ? false : state.retainedAfterFailedNavigation,
-        });
-        if (!bail && (mayChangePageTarget || (verifiesPageTarget && state.pageUrlUnknown))) {
-            nextStates.push({ ...state, retainedAfterFailedNavigation: true });
-        }
-    }
-    return { states: deduplicatePossibleBatchPageStates(nextStates) };
-}
-export function validateBatchPageTargets(steps, bail, options) {
-    let states = [
-        {
-            currentPageUrl: options.currentPageUrl,
-            pageUrlUnknown: options.pageUrlUnknown ?? false,
-            retainedAfterFailedNavigation: false,
-        },
-    ];
-    for (const [index, step] of steps.entries()) {
-        const trustedBatchTabSelection = options.trustedFirstBatchTabSelection === true && index === 0;
-        const error = possibleStateError(states, step, {
-            allowUnverifiedPageTransitions: options.allowUnverifiedPageTransitions,
-            trustedBatchTabSelection,
-            allowsConfirmation: options.allowFirstBatchConfirmation === true && index === 0,
-        });
-        if (error !== undefined) {
-            return error;
-        }
-        const next = advancePossibleStates(states, step, trustedBatchTabSelection, bail);
-        if (next.error !== undefined) {
-            return next.error;
-        }
-        states = next.states;
-    }
-    return undefined;
-}

package/dist/extensions/agent-browser/lib/page-target-guards.js

@@ -1,50 +0,0 @@
-import { parseArgvDescriptor } from "./argv-descriptor.js";
-import { needsManagedSession } from "./command-policy.js";
-import { isUnverifiedPageTransitionCommand } from "./command-taxonomy.js";
-import { getExplicitNavigationTarget } from "./page-target-navigation.js";
-export const UNVERIFIED_PAGE_MESSAGE = "The active page became unverified after a tab, attachment, history, script, or state-load transition. Run get url or navigate explicitly before page-content inspection.";
-export const BATCH_UNVERIFIED_PAGE_MESSAGE = `${UNVERIFIED_PAGE_MESSAGE} In a batch, put get url after the transition before later content steps, or split the batch at that boundary.`;
-export const NON_BAIL_BATCH_NAVIGATION_MESSAGE = "Batches that change or re-verify the page target before page-content access must use exact batch --bail so a failed step cannot act on an unverified or prior page.";
-export function isRecoveringPageTransitionCommand(command, subcommand) {
-    return (command !== "eval" &&
-        !(command === "webmcp" && subcommand === "invoke") &&
-        isUnverifiedPageTransitionCommand(command, subcommand));
-}
-function canOperateWithoutVerifiedPage(command, subcommand) {
-    switch (command) {
-        case undefined:
-            return false;
-        case "close":
-        case "exit":
-        case "quit":
-            return true;
-        case "tab":
-            return subcommand !== undefined && subcommand !== "new";
-        case "get":
-            return subcommand === "url";
-        case "webmcp":
-            return ["result", "cancel"].includes(subcommand ?? "");
-        case "record":
-            return subcommand === "stop";
-        case "dialog":
-            return ["status", "accept", "dismiss"].includes(subcommand ?? "");
-        default:
-            return false;
-    }
-}
-export function getUnverifiedPageError(options) {
-    const descriptor = parseArgvDescriptor(options.args);
-    if (options.pageUrlUnknown !== true || !needsManagedSession(descriptor)) {
-        return undefined;
-    }
-    const { command, subcommand } = descriptor.commandInfo;
-    if (canOperateWithoutVerifiedPage(command, subcommand)) {
-        return undefined;
-    }
-    const transitionsPage = options.allowUnverifiedPageTransitions === true &&
-        isRecoveringPageTransitionCommand(command, subcommand);
-    const trustedTab = options.trustedBatchTabSelection === true && command === "tab";
-    return transitionsPage || trustedTab || getExplicitNavigationTarget(options.args) !== undefined
-        ? undefined
-        : UNVERIFIED_PAGE_MESSAGE;
-}

package/dist/extensions/agent-browser/lib/page-target-navigation.js

@@ -1,104 +0,0 @@
-import { parseArgvDescriptor } from "./argv-descriptor.js";
-import { GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES, VALUE_FLAGS } from "./argv-grammar.js";
-import { isUnverifiedPageTransitionCommand } from "./command-taxonomy.js";
-const EXPLICIT_NAVIGATION_COMMANDS = new Set([
-    "a11y",
-    "goto",
-    "navigate",
-    "open",
-    "pushstate",
-    "visit",
-    "vitals",
-    "web-vitals",
-]);
-const POSITIONAL_VALUE_FLAGS = new Set([...VALUE_FLAGS, "--llms"]);
-function isPositionalOperand(token) {
-    return !token.startsWith("-") || token.includes("/") || token.includes("\\");
-}
-function getPositionalOperands(commandTokens) {
-    const values = [];
-    for (let index = 1; index < commandTokens.length; index += 1) {
-        const token = commandTokens[index];
-        if (token.length === 0 || (token.includes("=") && token.startsWith("-"))) {
-            continue;
-        }
-        if (POSITIONAL_VALUE_FLAGS.has(token)) {
-            index += 1;
-            continue;
-        }
-        if (GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES.has(token)) {
-            index += ["true", "false"].includes(commandTokens[index + 1] ?? "") ? 1 : 0;
-            continue;
-        }
-        if (isPositionalOperand(token)) {
-            values.push(token);
-        }
-    }
-    return values;
-}
-export function getExplicitNavigationTarget(args) {
-    const descriptor = parseArgvDescriptor(args);
-    const positionals = getPositionalOperands(descriptor.upstreamCommandTokens);
-    const { command, subcommand } = descriptor.commandInfo;
-    if (EXPLICIT_NAVIGATION_COMMANDS.has(command ?? "")) {
-        return positionals[0];
-    }
-    if (command === "tab" && subcommand === "new") {
-        return positionals[1];
-    }
-    if (command === "window" && subcommand === "new") {
-        return "about:blank";
-    }
-    return command === "diff" && subcommand === "url"
-        ? descriptor.upstreamCommandTokens[3]
-        : undefined;
-}
-function getResultingExplicitNavigationTarget(args, currentPageUrl) {
-    const target = getExplicitNavigationTarget(args);
-    if (target === undefined || parseArgvDescriptor(args).commandInfo.command !== "pushstate") {
-        return target;
-    }
-    try {
-        return new URL(target).href;
-    }
-    catch {
-        if (currentPageUrl === undefined || currentPageUrl.length === 0) {
-            return undefined;
-        }
-        try {
-            return new URL(target, currentPageUrl).href;
-        }
-        catch {
-            return undefined;
-        }
-    }
-}
-export function commandMayChangePageTarget(args, trustedBatchTabSelection) {
-    const { command, subcommand } = parseArgvDescriptor(args).commandInfo;
-    return (getExplicitNavigationTarget(args) !== undefined ||
-        (isUnverifiedPageTransitionCommand(command, subcommand) &&
-            !(trustedBatchTabSelection && command === "tab")));
-}
-export function commandVerifiesPageTarget(args) {
-    const { command, subcommand } = parseArgvDescriptor(args).commandInfo;
-    return command === "get" && subcommand === "url";
-}
-export function getResultingPageState(options) {
-    const { command, subcommand } = parseArgvDescriptor(options.args).commandInfo;
-    if (command === "get" && subcommand === "url") {
-        return { currentPageUrl: options.currentPageUrl, pageUrlUnknown: false };
-    }
-    const rawExplicitTarget = getExplicitNavigationTarget(options.args);
-    const explicitTarget = getResultingExplicitNavigationTarget(options.args, options.currentPageUrl);
-    if (explicitTarget !== undefined) {
-        return { currentPageUrl: explicitTarget, pageUrlUnknown: false };
-    }
-    if (rawExplicitTarget !== undefined) {
-        return { pageUrlUnknown: true };
-    }
-    if (isUnverifiedPageTransitionCommand(command, subcommand) &&
-        !(options.trustedBatchTabSelection && command === "tab")) {
-        return { pageUrlUnknown: true };
-    }
-    return { currentPageUrl: options.currentPageUrl, pageUrlUnknown: options.pageUrlUnknown };
-}

package/dist/extensions/agent-browser/lib/page-target-validation.js

@@ -1,90 +0,0 @@
-import { parseArgvDescriptor } from "./argv-descriptor.js";
-import { isBrowserIndependentRead, needsManagedSession } from "./command-policy.js";
-import { isRecord } from "./parsing.js";
-import { detectConfirmationRequired } from "./results/confirmation.js";
-import { getBatchCommandSteps, validateBatchPageTargets, UNSAFE_BATCH_ARGUMENT_MESSAGE, NESTED_BATCH_ARGUMENT_MESSAGE, } from "./page-target-batch.js";
-import { UNVERIFIED_PAGE_MESSAGE, BATCH_UNVERIFIED_PAGE_MESSAGE, NON_BAIL_BATCH_NAVIGATION_MESSAGE, getUnverifiedPageError, isRecoveringPageTransitionCommand, } from "./page-target-guards.js";
-import { commandMayChangePageTarget, getResultingPageState, } from "./page-target-navigation.js";
-export { getExplicitNavigationTarget } from "./page-target-navigation.js";
-export function commandRequiresLivePageVerification(args, stdin) {
-    const { command } = parseArgvDescriptor(args).commandInfo;
-    if (command === "eval") {
-        return true;
-    }
-    if (command !== "batch") {
-        return false;
-    }
-    const batch = getBatchCommandSteps(args, stdin);
-    return (batch.error === undefined &&
-        batch.steps.some((step) => commandRequiresLivePageVerification(step)));
-}
-export function getResultingPageTargetState(options) {
-    let state = {
-        currentPageUrl: options.currentPageUrl,
-        pageUrlUnknown: options.pageUrlUnknown ?? false,
-    };
-    if (parseArgvDescriptor(options.args).commandInfo.command !== "batch") {
-        return {
-            ...getResultingPageState({ ...state, args: options.args, trustedBatchTabSelection: false }),
-            pageTargetMayHaveChanged: commandMayChangePageTarget(options.args, false),
-        };
-    }
-    let pageTargetMayHaveChanged = false;
-    for (const [index, step] of options.executedBatchSteps.entries()) {
-        const row = Array.isArray(options.batchResults)
-            ? options.batchResults[index]
-            : undefined;
-        if (isRecord(row) && detectConfirmationRequired(row.result)) {
-            continue;
-        }
-        pageTargetMayHaveChanged ||= commandMayChangePageTarget(step, false);
-        state = getResultingPageState({ ...state, args: step, trustedBatchTabSelection: false });
-    }
-    return { ...state, pageTargetMayHaveChanged };
-}
-export function getPageTargetValidationError(options) {
-    const descriptor = parseArgvDescriptor(options.args);
-    const command = descriptor.commandInfo.command;
-    if (isBrowserIndependentRead(descriptor.upstreamCommandTokens, options.stdin) ||
-        ["close", "exit", "quit"].includes(command ?? "")) {
-        return undefined;
-    }
-    if (command !== "batch") {
-        return getUnverifiedPageError({
-            ...options,
-            trustedBatchTabSelection: options.trustedFirstBatchTabSelection,
-        });
-    }
-    const rawArguments = descriptor.upstreamCommandTokens.slice(1);
-    if (rawArguments.some((token) => token.startsWith("--bail="))) {
-        return "Use exact batch --bail for fail-fast, or omit it to continue after errors. --bail=<value> is a raw command upstream; stdin is ignored when raw batch arguments are present.";
-    }
-    const batch = getBatchCommandSteps(options.args, options.stdin);
-    if (batch.error !== undefined && batch.error.length > 0) {
-        return batch.error.startsWith("agent_browser batch stdin") ||
-            batch.error === NESTED_BATCH_ARGUMENT_MESSAGE
-            ? batch.error
-            : UNSAFE_BATCH_ARGUMENT_MESSAGE;
-    }
-    return validateBatchPageTargets(batch.steps, rawArguments.includes("--bail"), options);
-}
-export function getExplicitSessionPageVerificationRequirement(options) {
-    const descriptor = parseArgvDescriptor(options.args);
-    if (!needsManagedSession(descriptor, options.stdin) ||
-        isRecoveringPageTransitionCommand(descriptor.commandInfo.command, descriptor.commandInfo.subcommand)) {
-        return undefined;
-    }
-    const validationError = getPageTargetValidationError({
-        args: options.args,
-        pageUrlUnknown: true,
-        stdin: options.stdin,
-        allowUnverifiedPageTransitions: true,
-    });
-    return [
-        UNVERIFIED_PAGE_MESSAGE,
-        BATCH_UNVERIFIED_PAGE_MESSAGE,
-        NON_BAIL_BATCH_NAVIGATION_MESSAGE,
-    ].includes(validationError ?? "")
-        ? UNVERIFIED_PAGE_MESSAGE
-        : undefined;
-}

package/dist/extensions/agent-browser/lib/parsing.js

@@ -1,30 +0,0 @@
-export function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
-/** Upstream native element::parse_ref accepts @eN, ref=eN and bare eN. */
-export function parseRefId(selector) {
-    const trimmed = selector.trim();
-    const prefixed = trimmed.startsWith("@") || trimmed.startsWith("ref=");
-    let candidate = trimmed;
-    if (trimmed.startsWith("@")) {
-        candidate = trimmed.slice(1);
-    }
-    else if (trimmed.startsWith("ref=")) {
-        candidate = trimmed.slice(4);
-    }
-    return (prefixed ? /^e\d*$/ : /^e\d+$/).test(candidate) ? candidate : undefined;
-}
-export function parsePositiveInteger(rawValue) {
-    if (typeof rawValue !== "string") {
-        return undefined;
-    }
-    const normalizedValue = rawValue.trim();
-    if (!/^\d+$/.test(normalizedValue)) {
-        return undefined;
-    }
-    const parsedValue = Number(normalizedValue);
-    if (!Number.isSafeInteger(parsedValue) || parsedValue <= 0) {
-        return undefined;
-    }
-    return parsedValue;
-}