pi-agent-browser-native 0.9.3 → 0.9.4

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 {};

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

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

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

@@ -0,0 +1,42 @@
+import { buildAgentBrowserResultCategoryDetails } from "../../results/categories.js";
+import { buildSessionDetailFields } from "./session-state.js";
+export function preparationFailure(request) {
+    return {
+        kind: "early-result",
+        statePatch: request.statePatch,
+        result: {
+            content: [{ type: "text", text: request.message }],
+            details: { ...request.details },
+            isError: true,
+        },
+    };
+}
+export function preparationSessionDetails(restoreDisabled, plan) {
+    return buildSessionDetailFields(plan.sessionName, plan.usedImplicitSession, plan.namespace, restoreDisabled);
+}
+export function categorizedGuardFailure(restoreDisabled, request, failure) {
+    return preparationFailure({
+        message: failure.message,
+        statePatch: request.statePatch,
+        details: {
+            args: request.redactedArgs,
+            ...(failure.omitCommand === true ? {} : { command: request.plan.commandInfo.command }),
+            compatibilityWorkaround: request.plan.compatibilityWorkaround,
+            effectiveArgs: request.effectiveArgs,
+            sessionMode: request.sessionMode,
+            ...buildAgentBrowserResultCategoryDetails({
+                args: request.effectiveArgs,
+                command: request.plan.commandInfo.command,
+                errorText: failure.message,
+                failureCategory: failure.failureCategory,
+                succeeded: false,
+                validationError: failure.validationError,
+            }),
+            ...(failure.validationError !== undefined
+                ? { validationError: failure.validationError }
+                : {}),
+            ...preparationSessionDetails(restoreDisabled, request.plan),
+            ...failure.details,
+        },
+    });
+}