pi-agent-browser-native 0.9.2 → 0.9.4

package/dist/extensions/agent-browser/lib/orchestration/browser-run/prepare/snapshot-rendered-text.js

@@ -0,0 +1,147 @@
+import { isRecord } from "../../../parsing.js";
+import { redactSensitiveText } from "../../../runtime-redaction.js";
+const RENDERED_TEXT_SEARCH_MAX_MATCHES = 8;
+export function buildRenderedTextSearchEval(search) {
+    return `(() => {
+  const query = ${JSON.stringify(search.trim().toLowerCase())};
+  const limit = ${RENDERED_TEXT_SEARCH_MAX_MATCHES};
+  const normalize = (value) => String(value ?? "").replace(/\\s+/g, " ").trim();
+  const attributeTextOf = (element) => [element.getAttribute("aria-label"), element.getAttribute("title"), element.getAttribute("placeholder")].filter(Boolean).join(" ");
+  const searchableTextOf = (element) => normalize([attributeTextOf(element), element.textContent].filter(Boolean).join(" "));
+  const renderedTextOf = (element) => normalize([attributeTextOf(element), element instanceof HTMLElement ? element.innerText : element.textContent].filter(Boolean).join(" "));
+  const isRendered = (element) => {
+    if (!(element instanceof Element) || element.getClientRects().length === 0) return false;
+    const visibility = getComputedStyle(element).visibility;
+    if (visibility === "hidden" || visibility === "collapse") return false;
+    for (let current = element; current; current = current.parentElement) {
+      if (Number(getComputedStyle(current).opacity) === 0) return false;
+    }
+    return true;
+  };
+  const validationPattern = /(?:^|[-_\\s])(?:error|invalid|validation|warning)(?:$|[-_\\s])/i;
+  const validationAncestor = (element) => {
+    for (let current = element; current && current !== document.body; current = current.parentElement) {
+      const role = current.getAttribute("role");
+      const live = current.getAttribute("aria-live");
+      const descriptor = [current.id, current.className, current.getAttribute("data-testid")].map(normalize).join(" ");
+      if (["alert", "alertdialog", "status"].includes(role || "") || current.getAttribute("aria-invalid") === "true" || (live && live !== "off") || validationPattern.test(descriptor)) return current;
+    }
+    return null;
+  };
+  const candidates = Array.from(document.querySelectorAll("body *")).filter((element) => searchableTextOf(element).toLowerCase().includes(query));
+  const candidateSet = new Set(candidates);
+  const minimal = candidates.filter((element) => !Array.from(element.children).some((child) => candidateSet.has(child)));
+  const rendered = minimal.filter((element) => isRendered(element) && renderedTextOf(element).toLowerCase().includes(query));
+  const matches = rendered.map((element, index) => {
+    const semantic = validationAncestor(element);
+    const source = semantic || element;
+    const text = renderedTextOf(element);
+    const matchIndex = text.toLowerCase().indexOf(query);
+    const start = Math.max(0, matchIndex - 80);
+    const snippet = text.slice(start, start + 240);
+    const rect = element.getBoundingClientRect();
+    const name = normalize(element.getAttribute("aria-label") || element.getAttribute("title") || element.getAttribute("placeholder")) || undefined;
+    return {
+      index,
+      kind: semantic ? "validation" : "text",
+      name,
+      offscreen: rect.bottom < 0 || rect.right < 0 || rect.top > innerHeight || rect.left > innerWidth,
+      role: source.getAttribute("role") || undefined,
+      tagName: element.tagName.toLowerCase(),
+      text: snippet,
+    };
+  }).sort((left, right) => (left.kind === right.kind ? left.index - right.index : left.kind === "validation" ? -1 : 1));
+  const unique = [];
+  const seen = new Set();
+  for (const match of matches) {
+    const key = [match.kind, match.role, match.name, match.text].join("\\n");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const { index, ...visible } = match;
+    unique.push(visible);
+  }
+  return { matches: unique.slice(0, limit), totalMatches: unique.length, truncated: unique.length > limit };
+})()`;
+}
+export function extractRenderedTextSearchResult(data) {
+    const result = isRecord(data) && isRecord(data.result) ? data.result : data;
+    if (!isRecord(result) || !Array.isArray(result.matches)) {
+        return undefined;
+    }
+    const matches = result.matches
+        .flatMap((value) => {
+        if (!isRecord(value) ||
+            (value.kind !== "text" && value.kind !== "validation") ||
+            typeof value.offscreen !== "boolean" ||
+            typeof value.tagName !== "string" ||
+            typeof value.text !== "string") {
+            return [];
+        }
+        return [
+            {
+                kind: value.kind,
+                ...(typeof value.name === "string" ? { name: redactSensitiveText(value.name) } : {}),
+                offscreen: value.offscreen,
+                ...(typeof value.role === "string" ? { role: value.role } : {}),
+                tagName: value.tagName,
+                text: redactSensitiveText(value.text),
+            },
+        ];
+    })
+        .slice(0, RENDERED_TEXT_SEARCH_MAX_MATCHES);
+    const totalMatches = typeof result.totalMatches === "number" &&
+        Number.isInteger(result.totalMatches) &&
+        result.totalMatches >= matches.length
+        ? result.totalMatches
+        : matches.length;
+    return {
+        matches,
+        totalMatches,
+        truncated: result.truncated === true || totalMatches > matches.length,
+    };
+}
+export function attachRenderedTextMatchRefs(matches, snapshotData) {
+    if (!isRecord(snapshotData) || !isRecord(snapshotData.refs)) {
+        return [...matches];
+    }
+    const refs = snapshotData.refs;
+    return matches.map((match) => {
+        if (match.name === undefined || match.name === "") {
+            return match;
+        }
+        const normalizedName = match.name.replace(/\s+/g, " ").trim().toLowerCase();
+        const candidates = Object.entries(refs).filter(([, value]) => {
+            if (!isRecord(value) || typeof value.name !== "string") {
+                return false;
+            }
+            const nameMatches = value.name.replace(/\s+/g, " ").trim().toLowerCase() === normalizedName;
+            return (nameMatches &&
+                (match.role === undefined ||
+                    match.role === "" ||
+                    typeof value.role !== "string" ||
+                    value.role.toLowerCase() === match.role.toLowerCase()));
+        });
+        return candidates.length === 1 ? { ...match, ref: candidates[0][0] } : match;
+    });
+}
+export function formatRenderedTextSearchMatches(result) {
+    if (!result || result.matches.length === 0) {
+        return undefined;
+    }
+    const lines = result.matches.map((match) => {
+        const context = [
+            match.kind === "validation" ? "validation" : undefined,
+            match.offscreen ? "outside viewport" : undefined,
+            match.role,
+            match.tagName,
+            match.ref !== undefined && match.ref !== "" ? `@${match.ref}` : undefined,
+        ]
+            .filter(Boolean)
+            .join(", ");
+        return `- ${JSON.stringify(match.text)}${context !== "" ? ` (${context})` : ""}`;
+    });
+    if (result.truncated) {
+        lines.push(`- ... (${result.totalMatches - result.matches.length} additional rendered-text matches omitted)`);
+    }
+    return ["Rendered page text matches:", ...lines].join("\n");
+}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/prepare/wait-timeouts.js

@@ -12,45 +12,62 @@ function parseMillisecondsToken(token) {
     const parsed = Number(token);
     return Number.isSafeInteger(parsed) ? parsed : undefined;
 }
-function findCommandTimeoutMs(commandTokens) {
+function supportsCommandTimeout(commandTokens) {
     const [command, subcommand] = commandTokens;
-    if (command !== "wait" && command !== "read" && !(command === "webmcp" && ["invoke", "result"].includes(subcommand ?? "")))
+    return (command === "wait" ||
+        command === "read" ||
+        (command === "webmcp" && ["invoke", "result"].includes(subcommand)));
+}
+function findCommandTimeoutMs(commandTokens) {
+    if (!supportsCommandTimeout(commandTokens)) {
         return undefined;
+    }
     for (let index = 1; index < commandTokens.length; index += 1) {
         const token = commandTokens[index];
-        if (token === "--timeout")
+        if (token === "--timeout") {
             return parseMillisecondsToken(commandTokens[index + 1]);
-        if (token.startsWith("--timeout="))
+        }
+        if (token.startsWith("--timeout=")) {
             return parseMillisecondsToken(token.slice("--timeout=".length));
+        }
     }
-    const firstWaitArgument = commandTokens[0] === "wait" ? commandTokens[1] : undefined;
-    return firstWaitArgument && !firstWaitArgument.startsWith("-") ? parseMillisecondsToken(firstWaitArgument) : undefined;
+    const firstWaitArgument = commandTokens[0] === "wait" ? commandTokens.at(1) : undefined;
+    return firstWaitArgument !== undefined &&
+        firstWaitArgument !== "" &&
+        !firstWaitArgument.startsWith("-")
+        ? parseMillisecondsToken(firstWaitArgument)
+        : undefined;
 }
 export function findFirstPositionalArgument(commandTokens) {
     for (let index = 1; index < commandTokens.length; index += 1) {
         const token = commandTokens[index];
         const flag = token.split("=", 1)[0];
         if (POSITIONAL_VALUE_FLAGS.has(flag)) {
-            if (!token.includes("="))
+            if (!token.includes("=")) {
                 index += 1;
+            }
             continue;
         }
-        if (GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES.has(flag) && ["true", "false"].includes(commandTokens[index + 1] ?? "")) {
+        if (GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES.has(flag) &&
+            ["true", "false"].includes(commandTokens[index + 1] ?? "")) {
             index += 1;
             continue;
         }
-        if (!token.startsWith("-"))
+        if (!token.startsWith("-")) {
             return token;
+        }
     }
     return undefined;
 }
 function readUsesActivePageUrl(commandTokens) {
-    return !isBrowserIndependentRead(commandTokens) && commandTokens.some((token) => token === "--require-md" || token === "--llms" || token.startsWith("--llms="));
+    return (!isBrowserIndependentRead(commandTokens) &&
+        commandTokens.some((token) => token === "--require-md" || token === "--llms" || token.startsWith("--llms=")));
 }
 function readRequestBudget(commandTokens, activePageUrl) {
     const target = getExplicitReadUrl(commandTokens) ?? activePageUrl;
-    if (target === undefined)
+    if (target === undefined) {
         return 1;
+    }
     let url;
     try {
         url = new URL(target.includes("://") ? target : `https://${target}`);
@@ -59,51 +76,69 @@ function readRequestBudget(commandTokens, activePageUrl) {
         return 1;
     }
     const ancestorCount = url.pathname.split("/").filter(Boolean).length + 1;
-    if (commandTokens.some((token) => token === "--llms" || token.startsWith("--llms=")))
+    if (commandTokens.some((token) => token === "--llms" || token.startsWith("--llms="))) {
         return ancestorCount;
-    if (commandTokens.includes("--raw"))
+    }
+    if (commandTokens.includes("--raw")) {
         return 1;
+    }
     return ancestorCount + 3;
 }
 function commandTimeoutBudgetMs(commandTokens, activePageUrl) {
     const timeoutMs = findCommandTimeoutMs(commandTokens);
-    if (timeoutMs === undefined)
+    if (timeoutMs === undefined) {
         return undefined;
-    return commandTokens[0] === "read" ? timeoutMs * readRequestBudget(commandTokens, activePageUrl) : timeoutMs;
+    }
+    return commandTokens[0] === "read"
+        ? timeoutMs * readRequestBudget(commandTokens, activePageUrl)
+        : timeoutMs;
 }
 function findCommandTimeoutBudgetMs(commandTokens, stdin, activePageUrl) {
     const directTimeout = commandTimeoutBudgetMs(commandTokens, activePageUrl);
-    if (directTimeout !== undefined)
+    if (directTimeout !== undefined) {
         return directTimeout;
-    if (commandTokens[0] !== "batch")
+    }
+    if (commandTokens[0] !== "batch") {
         return undefined;
+    }
     let batchTimeoutTotal = 0;
     let batchPageUrl = activePageUrl;
     for (const step of getUpstreamEffectiveBatchSteps(commandTokens, stdin)) {
         batchTimeoutTotal += commandTimeoutBudgetMs(step, batchPageUrl) ?? 0;
-        if (isOpenNavigationCommand(step[0]))
+        if (isOpenNavigationCommand(step[0])) {
             batchPageUrl = findFirstPositionalArgument(step);
+        }
     }
     return batchTimeoutTotal === 0 ? undefined : batchTimeoutTotal;
 }
+function activeReadNeedsPageUrl(commandTokens) {
+    return (commandTokens[0] === "read" &&
+        findCommandTimeoutMs(commandTokens) !== undefined &&
+        readUsesActivePageUrl(commandTokens));
+}
 export function commandTimeoutNeedsActivePageUrl(commandTokens, stdin) {
-    if (commandTokens[0] === "read")
-        return findCommandTimeoutMs(commandTokens) !== undefined && readUsesActivePageUrl(commandTokens);
-    if (commandTokens[0] !== "batch")
+    if (commandTokens[0] === "read") {
+        return activeReadNeedsPageUrl(commandTokens);
+    }
+    if (commandTokens[0] !== "batch") {
         return false;
+    }
     let hasKnownPageUrl = false;
     for (const step of getUpstreamEffectiveBatchSteps(commandTokens, stdin)) {
-        if (isOpenNavigationCommand(step[0]) && findFirstPositionalArgument(step))
+        if (isOpenNavigationCommand(step[0]) && (findFirstPositionalArgument(step) ?? "") !== "") {
             hasKnownPageUrl = true;
-        if (!hasKnownPageUrl && findCommandTimeoutMs(step) !== undefined && step[0] === "read" && readUsesActivePageUrl(step))
+        }
+        if (!hasKnownPageUrl && activeReadNeedsPageUrl(step)) {
             return true;
+        }
     }
     return false;
 }
 export function getCommandAwareProcessTimeoutMs(commandTokens, stdin, activePageUrl) {
     const timeoutBudgetMs = findCommandTimeoutBudgetMs(commandTokens, stdin, activePageUrl);
-    if (timeoutBudgetMs === undefined)
+    if (timeoutBudgetMs === undefined) {
         return undefined;
+    }
     const neededTimeoutMs = timeoutBudgetMs + COMMAND_PROCESS_TIMEOUT_GRACE_MS;
     const defaultProcessTimeoutMs = getAgentBrowserProcessTimeoutMs();
     return neededTimeoutMs > defaultProcessTimeoutMs ? neededTimeoutMs : undefined;

package/dist/extensions/agent-browser/lib/orchestration/browser-run/prepare-artifacts.js

@@ -0,0 +1,159 @@
+import { copyFile, mkdir } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { projectUpstreamGlobalFlags } from "../../argv-grammar.js";
+import { pathExists } from "../../fs-utils.js";
+import { extractCommandTokens, extractUpstreamCommandTokens, parseWaitCommandTokens, } from "../../runtime.js";
+import { getUpstreamEffectiveBatchSteps, parseBatchStdinJsonArray } from "../batch-stdin.js";
+import { getScreenshotPathTokenIndex } from "./artifact-paths.js";
+function getArtifactParentPathTokenIndex(commandTokens) {
+    if (commandTokens[0] === "download" && commandTokens.length >= 3) {
+        return 2;
+    }
+    if (commandTokens[0] === "pdf" && commandTokens.length >= 2) {
+        return 1;
+    }
+    if (commandTokens[0] === "state" && commandTokens[1] === "save" && commandTokens.length >= 3) {
+        return 2;
+    }
+    if (commandTokens[0] === "wait") {
+        return parseWaitCommandTokens(commandTokens).downloadPathIndex;
+    }
+    return undefined;
+}
+async function ensureArtifactParentDirectory(commandTokens, cwd) {
+    const pathIndex = getArtifactParentPathTokenIndex(commandTokens);
+    if (pathIndex === undefined) {
+        return;
+    }
+    const requestedPath = commandTokens.at(pathIndex);
+    if (requestedPath === undefined || requestedPath === "") {
+        return;
+    }
+    await mkdir(dirname(resolve(cwd, requestedPath)), { recursive: true });
+}
+function screenshotPathIndex(commandTokens, batchStep) {
+    if (batchStep) {
+        return getScreenshotPathTokenIndex(commandTokens);
+    }
+    const projection = projectUpstreamGlobalFlags(commandTokens);
+    const index = getScreenshotPathTokenIndex(projection.tokens);
+    return index === undefined ? undefined : projection.indices[index];
+}
+async function normalizeScreenshotPathInTokens(commandTokens, cwd, batchStep = false) {
+    const pathIndex = screenshotPathIndex(commandTokens, batchStep);
+    if (pathIndex === undefined) {
+        return { tokens: [...commandTokens] };
+    }
+    const requestedPath = commandTokens[pathIndex];
+    const absolutePath = resolve(cwd, requestedPath);
+    await mkdir(dirname(absolutePath), { recursive: true });
+    const tokens = [...commandTokens];
+    tokens[pathIndex] = absolutePath;
+    const terminatorIndex = batchStep ? -1 : tokens.indexOf("--");
+    if (terminatorIndex >= 0) {
+        tokens.splice(terminatorIndex, 1);
+    }
+    return { request: { absolutePath, path: requestedPath }, tokens };
+}
+async function prepareRawBatchDirectories(steps, cwd) {
+    for (const step of steps) {
+        // Preserve native row ordering and fail at the first unwritable directory.
+        // oxlint-disable-next-line no-await-in-loop
+        await ensureArtifactParentDirectory(step, cwd);
+        if (step[0] === "screenshot") {
+            // Resolve only for mkdir: native raw row strings must remain unchanged.
+            // oxlint-disable-next-line no-await-in-loop
+            await normalizeScreenshotPathInTokens(step, cwd, true);
+        }
+    }
+}
+function isStringRow(value) {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    const items = value;
+    return items.every((item) => typeof item === "string");
+}
+async function prepareBatchScreenshotPaths(args, stdin, cwd) {
+    const commandTokens = extractUpstreamCommandTokens(args);
+    if (commandTokens[0] !== "batch") {
+        return undefined;
+    }
+    const argumentSteps = getUpstreamEffectiveBatchSteps(commandTokens, undefined);
+    if (argumentSteps.length > 0) {
+        await prepareRawBatchDirectories(argumentSteps, cwd);
+        return undefined;
+    }
+    if (stdin === undefined) {
+        return undefined;
+    }
+    const parsed = parseBatchStdinJsonArray(stdin);
+    if (parsed.error !== undefined && parsed.error !== "") {
+        return undefined;
+    }
+    if (parsed.steps === undefined) {
+        return undefined;
+    }
+    const batchScreenshotPathRequests = [];
+    const preparedSteps = await Promise.all(parsed.steps.map(async (step, index) => {
+        if (!isStringRow(step)) {
+            return step;
+        }
+        await ensureArtifactParentDirectory(step, cwd);
+        if (step[0] !== "screenshot") {
+            return step;
+        }
+        const normalized = await normalizeScreenshotPathInTokens(step, cwd, true);
+        batchScreenshotPathRequests[index] = normalized.request;
+        return normalized.tokens;
+    }));
+    if (!batchScreenshotPathRequests.some((request) => request !== undefined)) {
+        return undefined;
+    }
+    return {
+        args: [...args],
+        batchScreenshotPathRequests: parsed.steps.flatMap((step, index) => Array.isArray(step) && step.length === 0 ? [] : [batchScreenshotPathRequests[index]]),
+        stdin: JSON.stringify(preparedSteps),
+    };
+}
+export async function prepareAgentBrowserArgs(args, stdin, cwd) {
+    const preparedBatch = await prepareBatchScreenshotPaths(args, stdin, cwd);
+    if (preparedBatch) {
+        return preparedBatch;
+    }
+    const commandTokens = extractCommandTokens(args);
+    await ensureArtifactParentDirectory(extractUpstreamCommandTokens(args), cwd);
+    const normalized = await normalizeScreenshotPathInTokens(commandTokens, cwd);
+    if (!normalized.request) {
+        return { args: [...args] };
+    }
+    const commandStartIndex = args.length - commandTokens.length;
+    return {
+        args: [...args.slice(0, commandStartIndex), ...normalized.tokens],
+        screenshotPathRequest: normalized.request,
+    };
+}
+export async function repairScreenshotData(options) {
+    const { cwd, data, request } = options;
+    if (data.changed === false) {
+        return { data };
+    }
+    const reportedPath = typeof data.path === "string" ? data.path : undefined;
+    const reportedAbsolutePath = reportedPath !== undefined && reportedPath !== "" ? resolve(cwd, reportedPath) : undefined;
+    let status = (await pathExists(request.absolutePath))
+        ? "saved"
+        : "missing";
+    let tempPath;
+    if (reportedAbsolutePath !== undefined && reportedAbsolutePath !== request.absolutePath) {
+        tempPath = reportedAbsolutePath;
+        if (status === "missing" && (await pathExists(reportedAbsolutePath))) {
+            await mkdir(dirname(request.absolutePath), { recursive: true });
+            await copyFile(reportedAbsolutePath, request.absolutePath);
+            status = "repaired-from-temp";
+        }
+    }
+    return {
+        data: { ...data, path: request.absolutePath },
+        request: { ...request, status, tempPath },
+    };
+}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/prepare-command.js

@@ -0,0 +1,131 @@
+import { prepareAgentBrowserSpawnArgs } from "../../process.js";
+import { redactInvocationArgs } from "../../runtime-redaction.js";
+import { getBooleanFlagValue } from "../../argv-grammar.js";
+import { prepareClickDispatchProbe } from "./click-dispatch.js";
+import { collectScrollPositionSnapshot } from "./diagnostics.js";
+import { preparationSessionDetails } from "./prepare-failure.js";
+import { buildInvocationPreview } from "./prepare-input.js";
+import { prepareProcessTimeout } from "./prepare-timeouts.js";
+function shouldProbeScrollNoop(managedSessionActive, context) {
+    const plan = context.semantic.selection.executionPlan;
+    const amount = Number(context.semantic.commandTokens.find((token) => /^\d+(?:\.\d+)?$/.test(token)));
+    return (plan.commandInfo.command === "scroll" &&
+        plan.startupScopedFlags.length === 0 &&
+        (managedSessionActive || context.sessionMode === "fresh") &&
+        (!Number.isFinite(amount) || amount >= 500));
+}
+function redactedSemanticAction(context) {
+    const compiled = context.input.redactedCompiledSemanticAction;
+    return context.semantic.resolution && compiled?.action === "select"
+        ? { ...compiled, args: redactInvocationArgs(context.semantic.resolution.args) }
+        : compiled;
+}
+async function nativeCommandEvidence(facts, context) {
+    const plan = context.semantic.selection.executionPlan;
+    const page = context.semantic.selection.page;
+    const promptSnapshot = context.semantic.resolvedSnapshot ?? page.priorRefSnapshotState;
+    const processStdin = context.preparedArgs.stdin ?? context.stdin;
+    const processTimeoutMs = await prepareProcessTimeout(facts, {
+        commandTokens: context.semantic.commandTokens,
+        namespace: plan.namespace,
+        sessionName: plan.sessionName,
+        stdin: processStdin,
+        pageUrl: page.priorSessionTabTarget?.url,
+        refSnapshot: promptSnapshot,
+    });
+    const clickDispatchProbe = context.input.compiledElectron === undefined
+        ? await prepareClickDispatchProbe({
+            commandTokens: [...context.semantic.commandTokens],
+            cwd: facts.cwd,
+            namespace: plan.namespace,
+            refSnapshot: promptSnapshot,
+            sessionName: plan.sessionName,
+            signal: facts.signal,
+            timeoutMs: processTimeoutMs,
+        })
+        : undefined;
+    const redactedProcessArgs = redactInvocationArgs(prepareAgentBrowserSpawnArgs(plan.effectiveArgs, context.session.ownedManagedSession?.compatibilityUserAgent, facts.preserveAttachedBrowserSession, context.chromeStartupArgs));
+    const probeScroll = shouldProbeScrollNoop(facts.managedSessionActive, context);
+    const scrollPositionBefore = probeScroll
+        ? await collectScrollPositionSnapshot({
+            cwd: facts.cwd,
+            namespace: plan.namespace,
+            sessionName: plan.sessionName,
+            signal: facts.signal,
+        })
+        : undefined;
+    facts.onUpdate?.({
+        content: [
+            {
+                type: "text",
+                text: `Running agent-browser ${buildInvocationPreview(redactedProcessArgs)}`,
+            },
+        ],
+        details: {
+            compatibilityWorkaround: plan.compatibilityWorkaround,
+            effectiveArgs: redactedProcessArgs,
+            sessionMode: context.sessionMode,
+            sessionTabCorrection: context.semantic.selection.sessionTabCorrection,
+            ...preparationSessionDetails(facts.isRestoreDisabled(), plan),
+        },
+    });
+    return {
+        processArgs: plan.effectiveArgs,
+        processStdin,
+        processTimeoutMs,
+        clickDispatchProbe,
+        redactedProcessArgs,
+        shouldProbeScrollNoop: probeScroll,
+        scrollPositionBefore,
+    };
+}
+export async function prepareNativeCommand(facts, context, evidence) {
+    const native = await nativeCommandEvidence(facts, context);
+    const plan = context.semantic.selection.executionPlan;
+    const page = context.semantic.selection.page;
+    const input = context.input;
+    return {
+        kind: "ready",
+        prepared: {
+            compiledElectron: input.compiledElectron,
+            compiledJob: input.compiledJob,
+            compiledNetworkSourceLookup: input.compiledNetworkSourceLookup,
+            compiledQaPreset: input.compiledQaPreset,
+            compiledSemanticAction: input.compiledSemanticAction,
+            compiledSourceLookup: input.compiledSourceLookup,
+            redactedArgs: input.redactedArgs,
+            redactedCompiledElectron: input.redactedCompiledElectron,
+            redactedCompiledJob: input.redactedCompiledJob,
+            redactedCompiledNetworkSourceLookup: input.redactedCompiledNetworkSourceLookup,
+            redactedCompiledQaPreset: input.redactedCompiledQaPreset,
+            redactedCompiledSourceLookup: input.redactedCompiledSourceLookup,
+            ...native,
+            chromeStartupArgs: context.chromeStartupArgs,
+            commandTokens: [...context.semantic.commandTokens],
+            headedLaunch: context.session.headedLaunch,
+            providerLaunch: context.session.providerLaunch,
+            managedSessionPolicyLock: context.policy.lock,
+            compatibilityWorkaround: plan.compatibilityWorkaround,
+            electronLaunch: context.electronLaunch,
+            exactSensitiveValues: [...evidence.exactSensitiveValues],
+            executionPlan: plan,
+            ownedManagedSessionContext: context.session.ownedManagedSession,
+            preparedArgs: context.preparedArgs,
+            readConfirmation: context.session.readConfirmation,
+            priorRefSnapshotState: page.priorRefSnapshotState,
+            priorSessionTabTarget: page.priorSessionTabTarget,
+            priorSessionTabTargetUnknown: page.priorSessionTabTargetUnknown,
+            redactedCompiledSemanticAction: redactedSemanticAction(context),
+            redactedEffectiveArgs: [...evidence.redactedEffectiveArgs],
+            redactedRecoveryHint: evidence.redactedRecoveryHint,
+            resolvedSemanticActionRefSnapshot: context.semantic.resolvedSnapshot,
+            runtimeToolArgs: [...context.runtimeToolArgs],
+            runtimeToolStdin: context.stdin,
+            sessionMode: context.sessionMode,
+            sessionTabCorrection: context.semantic.selection.sessionTabCorrection,
+            sessionTabPinningReason: page.sessionTabPinningReason,
+            statePatch: evidence.statePatch,
+            userRequestedJson: getBooleanFlagValue(context.runtimeToolArgs, "--json") === true,
+        },
+    };
+}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/prepare-contracts.js

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