pi-agent-browser-native 0.9.5 → 0.9.6

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

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

@@ -1,145 +0,0 @@
-import { GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES, VALUE_FLAGS } from "../../../argv-grammar.js";
-import { isOpenNavigationCommand } from "../../../command-taxonomy.js";
-import { getExplicitReadUrl, isBrowserIndependentRead } from "../../../command-policy.js";
-import { getAgentBrowserProcessTimeoutMs } from "../../../process.js";
-import { getUpstreamEffectiveBatchSteps } from "../../batch-stdin.js";
-const POSITIONAL_VALUE_FLAGS = new Set([...VALUE_FLAGS, "--llms"]);
-const COMMAND_PROCESS_TIMEOUT_GRACE_MS = 5_000;
-function parseMillisecondsToken(token) {
-    if (token === undefined || !/^\d+$/.test(token)) {
-        return undefined;
-    }
-    const parsed = Number(token);
-    return Number.isSafeInteger(parsed) ? parsed : undefined;
-}
-function supportsCommandTimeout(commandTokens) {
-    const [command, subcommand] = commandTokens;
-    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") {
-            return parseMillisecondsToken(commandTokens[index + 1]);
-        }
-        if (token.startsWith("--timeout=")) {
-            return parseMillisecondsToken(token.slice("--timeout=".length));
-        }
-    }
-    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("=")) {
-                index += 1;
-            }
-            continue;
-        }
-        if (GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES.has(flag) &&
-            ["true", "false"].includes(commandTokens[index + 1] ?? "")) {
-            index += 1;
-            continue;
-        }
-        if (!token.startsWith("-")) {
-            return token;
-        }
-    }
-    return undefined;
-}
-function readUsesActivePageUrl(commandTokens) {
-    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) {
-        return 1;
-    }
-    let url;
-    try {
-        url = new URL(target.includes("://") ? target : `https://${target}`);
-    }
-    catch {
-        return 1;
-    }
-    const ancestorCount = url.pathname.split("/").filter(Boolean).length + 1;
-    if (commandTokens.some((token) => token === "--llms" || token.startsWith("--llms="))) {
-        return ancestorCount;
-    }
-    if (commandTokens.includes("--raw")) {
-        return 1;
-    }
-    return ancestorCount + 3;
-}
-function commandTimeoutBudgetMs(commandTokens, activePageUrl) {
-    const timeoutMs = findCommandTimeoutMs(commandTokens);
-    if (timeoutMs === undefined) {
-        return undefined;
-    }
-    return commandTokens[0] === "read"
-        ? timeoutMs * readRequestBudget(commandTokens, activePageUrl)
-        : timeoutMs;
-}
-function findCommandTimeoutBudgetMs(commandTokens, stdin, activePageUrl) {
-    const directTimeout = commandTimeoutBudgetMs(commandTokens, activePageUrl);
-    if (directTimeout !== undefined) {
-        return directTimeout;
-    }
-    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])) {
-            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 activeReadNeedsPageUrl(commandTokens);
-    }
-    if (commandTokens[0] !== "batch") {
-        return false;
-    }
-    let hasKnownPageUrl = false;
-    for (const step of getUpstreamEffectiveBatchSteps(commandTokens, stdin)) {
-        if (isOpenNavigationCommand(step[0]) && (findFirstPositionalArgument(step) ?? "") !== "") {
-            hasKnownPageUrl = true;
-        }
-        if (!hasKnownPageUrl && activeReadNeedsPageUrl(step)) {
-            return true;
-        }
-    }
-    return false;
-}
-export function getCommandAwareProcessTimeoutMs(commandTokens, stdin, activePageUrl) {
-    const timeoutBudgetMs = findCommandTimeoutBudgetMs(commandTokens, stdin, activePageUrl);
-    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

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

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

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

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

@@ -1,93 +0,0 @@
-import { parseArgvDescriptor } from "../../argv-descriptor.js";
-import { needsManagedSession } from "../../command-policy.js";
-import { isCloseCommand } from "../../command-taxonomy.js";
-import { acquireOwnedManagedSessionDaemonPolicy, inspectManagedSessionDaemon, } from "./managed-session-daemon-policy.js";
-import { planHasValidationError, withPlanValidationError, } from "./prepare-session-plan.js";
-function daemonReuseError(plan, session, policy) {
-    if (policy.error !== undefined && policy.error !== "") {
-        return policy.error;
-    }
-    if (isCloseCommand(plan.commandInfo.command) || policy.daemonStatus !== "active") {
-        return undefined;
-    }
-    if (session.offCurrentLaunchScopedFlags.length > 0) {
-        return `This older wrapper-owned session is already running, so launch-scoped flags ${session.offCurrentLaunchScopedFlags.join(", ")} would replace or be ignored by upstream agent-browser. Close it first, or remove the explicit --session and retry with sessionMode: "fresh".`;
-    }
-    if (session.offCurrentCompatibilityUpgrade) {
-        return 'This older wrapper-owned session is already running without the user agent required by this site. Close it first, or remove the explicit --session and retry with sessionMode: "fresh".';
-    }
-    return undefined;
-}
-function applyColdCompatibility(plan, session, context, status) {
-    if (isCloseCommand(plan.commandInfo.command) ||
-        status !== "inactive" ||
-        session.compatibilityUserAgent === undefined ||
-        session.compatibilityUserAgent === "" ||
-        session.compatibilityUserAgentApplied) {
-        return { plan, ownedManagedSession: context };
-    }
-    return {
-        ownedManagedSession: { ...context, compatibilityUserAgent: session.compatibilityUserAgent },
-        plan: {
-            ...plan,
-            effectiveArgs: ["--user-agent", session.compatibilityUserAgent, ...plan.effectiveArgs],
-        },
-    };
-}
-export async function prepareDaemonPolicy(process, electronLaunchRecord, planning) {
-    const { plan, session } = planning;
-    const context = session.ownedManagedSession;
-    if (session.browserIndependent || planHasValidationError(plan) || !context) {
-        return { plan, session, policy: { inactive: false } };
-    }
-    const policy = await acquireOwnedManagedSessionDaemonPolicy({
-        context,
-        electronLaunchRecord,
-        electronVerificationTimeoutMs: process.timeoutMs,
-        mode: isCloseCommand(plan.commandInfo.command) ? "close" : "reuse",
-        signal: process.signal,
-    });
-    const error = daemonReuseError(plan, session, policy);
-    const resolved = error !== undefined && error !== ""
-        ? { plan: withPlanValidationError(plan, error), ownedManagedSession: context }
-        : applyColdCompatibility(plan, session, context, policy.daemonStatus);
-    return {
-        plan: resolved.plan,
-        session: { ...session, ownedManagedSession: resolved.ownedManagedSession },
-        policy: {
-            lock: policy.lock,
-            inactive: policy.daemonStatus === "inactive",
-            cleanupOnlyReason: policy.error !== undefined && policy.error !== "" ? policy.cleanupOnlyReason : undefined,
-        },
-    };
-}
-function chromeStartupEligible(facts, plan, request) {
-    return (facts.chromeStartupArgs !== undefined &&
-        facts.preserveAttachedBrowserSession !== true &&
-        !request.browserIndependent &&
-        !planHasValidationError(plan) &&
-        !isCloseCommand(plan.commandInfo.command) &&
-        needsManagedSession(parseArgvDescriptor(request.preparedArgs.args), request.stdin));
-}
-export async function prepareChromeStartupArgs(facts, planning, request) {
-    if (!chromeStartupEligible(facts, planning.plan, {
-        ...request,
-        browserIndependent: planning.session.browserIndependent,
-    })) {
-        return undefined;
-    }
-    const { plan, session, policy } = planning;
-    let inactive = policy.inactive;
-    if (!session.ownedManagedSession) {
-        inactive =
-            facts.daemonInactive ??
-                (plan.sessionName !== undefined &&
-                    (await inspectManagedSessionDaemon({
-                        cwd: facts.cwd,
-                        signal: facts.signal,
-                        sessionName: plan.sessionName,
-                        namespace: plan.namespace,
-                    })).status === "inactive");
-    }
-    return inactive || facts.configuredChromeLaunch === true ? facts.chromeStartupArgs : undefined;
-}