pi-agent-browser-native 0.9.3 → 0.9.5

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

@@ -6,112 +6,215 @@ import { appendBrowserTransition, getBrowserRecord } from "../browser-transcript
 import { redactSensitiveText } from "../runtime.js";
 import { attachInlineImage } from "../results/presentation/artifacts.js";
 import { projectAgentBrowserObservation } from "../results/presentation/content.js";
-import { redactPresentationData } from "../results/presentation/diagnostics.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 = getBrowserRecord(entry)?.event.state.scriptLease;
-        if (!isRecord(lease))
-            continue;
-        if (ownerSessionId !== undefined && lease.ownerSessionId !== ownerSessionId)
-            continue;
-        const { cleanup, closeCommandArgs, launchAttempted, sessionName } = lease;
-        if (!isAgentBrowserScriptSessionName(sessionName))
-            continue;
-        const expected = createAgentBrowserScriptCloseArgs(sessionName);
-        if ((cleanup !== "active" && cleanup !== "closed" && cleanup !== "failed") || launchAttempted !== true
-            || !Array.isArray(closeCommandArgs) || closeCommandArgs.length !== expected.length
-            || !closeCommandArgs.every((token, index) => token === expected[index]))
-            continue;
-        leases.set(sessionName, { cleanup, closeCommandArgs: expected, launchAttempted: true, sessionName, ownerSessionId: typeof lease.ownerSessionId === "string" ? lease.ownerSessionId : undefined });
+        const lease = parseScriptLease(getBrowserRecord(entry)?.event.state.scriptLease, ownerSessionId);
+        if (lease !== undefined) {
+            leases.set(lease.sessionName, lease);
+        }
     }
     return leases;
 }
-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 } } } });
-}
-export function createBrowserCodeOutput() {
-    const images = new Map();
-    const selected = new Map();
-    const receipts = new Map();
-    const fileArtifacts = new Map();
-    let selectedBytes = 0;
+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 {
-        async observe(result) {
-            const details = isRecord(result.details) ? result.details : {};
-            const observation = projectAgentBrowserObservation(details, result.isError !== true);
-            for (const entry of observation.artifactVerification?.artifacts ?? [])
-                receipts.set(entry.absolutePath ?? entry.path, entry);
-            for (const artifact of observation.artifacts ?? [])
-                fileArtifacts.set(artifact.absolutePath, artifact);
-            if (observation.imageObservations) {
-                observation.imageObservations = await Promise.all(observation.imageObservations.map(async (image) => {
-                    const file = await stat(image.path);
-                    const id = `image-${images.size + 1}`;
-                    images.set(id, { observation: image, size: file.size, mtime: file.mtimeMs });
-                    return { ...image, id };
-                }));
-            }
-            return observation;
-        },
-        async emitImage(value) {
-            const id = isRecord(value) && typeof value.id === "string" ? value.id : undefined;
-            const image = id ? images.get(id) : undefined;
-            if (!id || !image)
-                throw new Error("emitImage expects an imageObservations handle returned by browser() in this code call.");
-            if (selected.has(id))
-                return;
-            if (selected.size >= 8 || 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")) {
-                throw new Error(presentation.content.filter(item => item.type === "text").map(item => item.text).join("\n") || "The selected image could not be attached.");
-            }
-            selected.set(id, presentation.content.filter(item => item.type === "image"));
-            selectedBytes += file.size;
+        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,
+                },
+            },
         },
-        async finish(run, sessionName, namespace) {
-            let data;
-            let outputError;
-            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");
+    });
+}
+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.");
             }
-            catch {
-                data = undefined;
-                outputError = "Code output could not be rendered as bounded JSON.";
+            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");
             }
-            const failureCategory = outputError ? "validation-error" : run.failureCategory
-                ?? (run.rejectedCallCount > 0 ? "validation-error" : undefined);
-            const success = run.ok && failureCategory === undefined;
-            const artifacts = [...receipts.values()];
-            const count = (state) => artifacts.filter(entry => entry.state === state).length;
-            const artifactVerification = artifacts.length ? {
-                artifacts, missingCount: count("missing"), pendingCount: count("pending"), unverifiedCount: count("unverified"),
-                verifiedCount: count("verified"), verified: artifacts.every(entry => entry.state === "verified"),
-            } : undefined;
-            const observation = {
-                success, resultCategory: success ? "success" : "failure", failureCategory, data,
-                error: outputError ?? (run.error ? redactSensitiveText(run.error) : undefined),
-                sessionName, namespace,
-                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?.length ? run.failures : undefined,
-                artifactVerification,
-                artifacts: fileArtifacts.size ? [...fileArtifacts.values()] : undefined,
-                imageObservations: [...selected.keys()].map(id => ({ ...images.get(id).observation, id })),
-            };
-            const summary = success ? `Browser code completed (${run.callCount} calls).` : "Browser code failed.";
-            return {
-                content: [...selected.values()].flat(),
-                details: { ...observation, codeSteps: run.steps, summary },
-                isError: !success,
-            };
-        },
+        }
+        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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,104 @@
+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 };
+}