pi-agent-browser-native 0.9.4 → 0.9.6

package/dist/extensions/agent-browser/lib/orchestration/extension-version-check.js

@@ -1,54 +0,0 @@
-import { redactSensitiveText } from "../runtime.js";
-import { runAgentBrowserProcess } from "../process.js";
-import { getAgentBrowserProcessEnvironment } from "../process-environment.js";
-import { MINIMUM_AGENT_BROWSER_VERSION, SUPPORTED_AGENT_BROWSER_VERSION_LABEL, TARGET_AGENT_BROWSER_VERSION, getAgentBrowserVersionValidationError, parseAgentBrowserVersionOutput, } from "../upstream-version.js";
-function unavailableProbe(probe) {
-    const error = probe.spawnError;
-    return ((error !== undefined && "code" in error && error.code === "ENOENT") ||
-        probe.exitCode === 127 ||
-        probe.aborted);
-}
-function probeVersion(probe) {
-    if (probe.spawnError || probe.exitCode !== 0) {
-        const stderr = probe.stderr.trim();
-        const detail = redactSensitiveText(probe.spawnError?.message ?? (stderr !== "" ? stderr : `exit ${probe.exitCode}`));
-        return {
-            error: `agent-browser --version could not be validated (${detail}). Run pi-agent-browser-doctor before browser-backed calls.`,
-        };
-    }
-    return {
-        observedVersion: parseAgentBrowserVersionOutput(probe.stdout),
-        error: getAgentBrowserVersionValidationError(probe.stdout),
-    };
-}
-export async function validateUpstreamVersion(cache, cwd, signal) {
-    const env = getAgentBrowserProcessEnvironment();
-    const key = `${cwd}\0${env.PATH ?? env.Path ?? ""}`;
-    if (cache.has(key)) {
-        return undefined;
-    }
-    const probe = await runAgentBrowserProcess({ args: ["--version"], cwd, signal, timeoutMs: 5000 });
-    if (unavailableProbe(probe)) {
-        return undefined;
-    }
-    const { error, observedVersion } = probeVersion(probe);
-    if (error === undefined || error === "") {
-        cache.add(key);
-        return undefined;
-    }
-    return {
-        content: [{ type: "text", text: error }],
-        details: {
-            expectedVersion: TARGET_AGENT_BROWSER_VERSION,
-            failureCategory: "validation-error",
-            observedVersion,
-            resultCategory: "failure",
-            minimumSupportedVersion: MINIMUM_AGENT_BROWSER_VERSION,
-            versionValidation: {
-                expected: SUPPORTED_AGENT_BROWSER_VERSION_LABEL,
-                observed: observedVersion,
-            },
-        },
-        isError: true,
-    };
-}

package/dist/extensions/agent-browser/lib/orchestration/input-plan-types.js

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

package/dist/extensions/agent-browser/lib/orchestration/input-plan.js

@@ -1,313 +0,0 @@
-import { parseArgvDescriptor } from "../argv-descriptor.js";
-import { isRecord } from "../parsing.js";
-import { isStringArray } from "../input-modes/shared.js";
-import { normalizeUrlLessOpen } from "./batch-stdin.js";
-import { isPlainTextInspectionArgs, validateToolArgs, redactInvocationArgs } from "../runtime.js";
-import { buildAgentBrowserResultCategoryDetails } from "../results/categories.js";
-import { compileAgentBrowserElectron } from "../input-modes/electron.js";
-import { compileAgentBrowserQaPreset } from "../input-modes/job.js";
-import { compileAgentBrowserNetworkSourceLookup, compileAgentBrowserSourceLookup, } from "../input-modes/lookups.js";
-import { compileAgentBrowserSemanticAction } from "../input-modes/semantic-action.js";
-import { redactCompiledElectron, redactCompiledJob, redactCompiledNetworkSourceLookup, redactCompiledSourceLookup, } from "./input-redaction.js";
-function normalizeExplicitEvalStdinArgs(args, stdin) {
-    if (stdin !== undefined) {
-        return { args, stdin };
-    }
-    const descriptor = parseArgvDescriptor([...args]);
-    if (descriptor.commandInfo.command !== "eval") {
-        return { args, stdin };
-    }
-    const stdinIndex = descriptor.commandTokens.indexOf("--stdin");
-    if (stdinIndex < 0 || stdinIndex >= descriptor.commandTokens.length - 1) {
-        return { args, stdin };
-    }
-    const commandStartIndex = args.length - descriptor.commandTokens.length;
-    return {
-        args: [
-            ...args.slice(0, commandStartIndex),
-            ...descriptor.commandTokens.slice(0, stdinIndex + 1),
-        ],
-        stdin: descriptor.commandTokens.slice(stdinIndex + 1).join(" "),
-    };
-}
-function fieldShapeError(params) {
-    if (params.args !== undefined && !isStringArray(params.args)) {
-        return "args must be an array of strings when provided.";
-    }
-    if (params.stdin !== undefined && typeof params.stdin !== "string") {
-        return "stdin must be a string when provided.";
-    }
-    return undefined;
-}
-function outputPathError(value) {
-    if (value !== undefined && (typeof value !== "string" || value.trim().length === 0)) {
-        return "outputPath must be a non-empty string when provided.";
-    }
-    return undefined;
-}
-/** Compiles all requested modes once, then validates selection before exposing executable input. */
-class BrowserInputCompiler {
-    params;
-    preflight;
-    semanticAction;
-    qa;
-    sourceLookup;
-    networkSourceLookup;
-    electron;
-    modes;
-    constructor(params, preflight) {
-        this.params = params;
-        this.preflight = preflight;
-        this.semanticAction =
-            params.semanticAction === undefined
-                ? {}
-                : compileAgentBrowserSemanticAction(params.semanticAction);
-        this.qa = params.qa === undefined ? {} : compileAgentBrowserQaPreset(params.qa);
-        this.sourceLookup =
-            params.sourceLookup === undefined ? {} : compileAgentBrowserSourceLookup(params.sourceLookup);
-        this.networkSourceLookup =
-            params.networkSourceLookup === undefined
-                ? {}
-                : compileAgentBrowserNetworkSourceLookup(params.networkSourceLookup);
-        this.electron =
-            params.electron === undefined ? {} : compileAgentBrowserElectron(params.electron);
-        this.modes = this.projectModes();
-    }
-    projectModes() {
-        const compiledJob = this.qa.compiled;
-        const redactedCompiledJob = redactCompiledJob(compiledJob);
-        const compiledSemanticAction = this.semanticAction.compiled;
-        return {
-            compiledElectron: this.electron.compiled,
-            compiledGeneratedBatch: this.networkSourceLookup.compiled ?? this.sourceLookup.compiled ?? compiledJob,
-            compiledJob,
-            compiledNetworkSourceLookup: this.networkSourceLookup.compiled,
-            compiledQaPreset: this.qa.compiled,
-            compiledSemanticAction,
-            compiledSourceLookup: this.sourceLookup.compiled,
-            redactedCompiledElectron: redactCompiledElectron(this.electron.compiled),
-            redactedCompiledJob,
-            redactedCompiledNetworkSourceLookup: redactCompiledNetworkSourceLookup(this.networkSourceLookup.compiled),
-            redactedCompiledQaPreset: compiledJob !== undefined && redactedCompiledJob !== undefined
-                ? { ...redactedCompiledJob, checks: compiledJob.checks }
-                : undefined,
-            redactedCompiledSemanticAction: compiledSemanticAction === undefined
-                ? undefined
-                : {
-                    ...compiledSemanticAction,
-                    args: redactInvocationArgs([...compiledSemanticAction.args]),
-                },
-            redactedCompiledSourceLookup: redactCompiledSourceLookup(this.sourceLookup.compiled),
-        };
-    }
-    attemptedKind() {
-        if (this.electron.compiled !== undefined) {
-            return "electron";
-        }
-        if (this.networkSourceLookup.compiled !== undefined) {
-            return "networkSourceLookup";
-        }
-        if (this.sourceLookup.compiled !== undefined) {
-            return "sourceLookup";
-        }
-        if (this.qa.compiled !== undefined) {
-            return "qa";
-        }
-        if (this.semanticAction.compiled !== undefined) {
-            return "semanticAction";
-        }
-        return Array.isArray(this.params.args) ? "args" : undefined;
-    }
-    inputModeError() {
-        const selected = [
-            Array.isArray(this.params.args),
-            this.semanticAction.compiled !== undefined,
-            this.qa.compiled !== undefined,
-            this.sourceLookup.compiled !== undefined,
-            this.networkSourceLookup.compiled !== undefined,
-            this.electron.compiled !== undefined,
-        ].filter((active) => active).length;
-        return selected === 1
-            ? undefined
-            : "Provide exactly one of args, semanticAction, qa, sourceLookup, networkSourceLookup, or electron.";
-    }
-    generatedStdinError() {
-        if (this.params.stdin === undefined) {
-            return undefined;
-        }
-        if (this.modes.compiledGeneratedBatch !== undefined) {
-            return "Do not provide stdin with qa, sourceLookup, or networkSourceLookup; those modes generate their own batch stdin.";
-        }
-        return this.electron.compiled === undefined
-            ? undefined
-            : "Do not provide stdin with electron; electron mode is host-only or manages its own input.";
-    }
-    timeoutError() {
-        const value = this.params.timeoutMs;
-        if (value === undefined) {
-            return undefined;
-        }
-        if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
-            return "timeoutMs must be a positive integer when provided.";
-        }
-        if (this.electron.compiled === undefined) {
-            return undefined;
-        }
-        return this.electron.compiled.action === "list"
-            ? "electron.list has no configurable timeout; remove top-level timeoutMs."
-            : "Use electron.timeoutMs for this action; top-level timeoutMs applies only to browser CLI subprocess calls.";
-    }
-    attachedQaError() {
-        return this.qa.compiled?.checks.attached === true && this.params.sessionMode === "fresh"
-            ? "qa.attached cannot be used with sessionMode=fresh; attach or launch a session first, then run qa.attached with the current session."
-            : undefined;
-    }
-    validationError(args, stdin) {
-        const compilationError = this.compilationError();
-        const shapeError = fieldShapeError(this.params);
-        const modeError = this.inputModeError() ?? this.generatedStdinError();
-        const optionsError = this.optionsError();
-        const error = compilationError ?? shapeError ?? modeError ?? optionsError;
-        if (error !== undefined) {
-            return error;
-        }
-        return this.electron.compiled === undefined
-            ? (validateToolArgs([...args]) ?? this.preflight(args, stdin))
-            : undefined;
-    }
-    compilationError() {
-        return (this.semanticAction.error ??
-            this.qa.error ??
-            this.sourceLookup.error ??
-            this.networkSourceLookup.error ??
-            this.electron.error);
-    }
-    optionsError() {
-        return outputPathError(this.params.outputPath) ?? this.timeoutError() ?? this.attachedQaError();
-    }
-    validInput(base) {
-        const { compiledElectron, compiledSemanticAction, redactedCompiledElectron, redactedCompiledSemanticAction, } = this.modes;
-        if (compiledElectron !== undefined && redactedCompiledElectron !== undefined) {
-            return {
-                ...base,
-                compiledElectron,
-                kind: "electron",
-                redactedCompiledElectron,
-                status: "valid",
-            };
-        }
-        const generated = this.validGeneratedInput(base);
-        if (generated !== undefined) {
-            return generated;
-        }
-        if (compiledSemanticAction !== undefined && redactedCompiledSemanticAction !== undefined) {
-            return {
-                ...base,
-                compiledSemanticAction,
-                kind: "semanticAction",
-                redactedCompiledSemanticAction,
-                status: "valid",
-            };
-        }
-        return { ...base, kind: "args", status: "valid" };
-    }
-    validGeneratedInput(base) {
-        const { compiledNetworkSourceLookup, compiledSourceLookup, compiledQaPreset, redactedCompiledNetworkSourceLookup, redactedCompiledSourceLookup, redactedCompiledQaPreset, redactedCompiledJob, } = this.modes;
-        if (compiledNetworkSourceLookup !== undefined &&
-            redactedCompiledNetworkSourceLookup !== undefined) {
-            return {
-                ...base,
-                compiledGeneratedBatch: compiledNetworkSourceLookup,
-                compiledNetworkSourceLookup,
-                kind: "networkSourceLookup",
-                redactedCompiledNetworkSourceLookup,
-                status: "valid",
-            };
-        }
-        if (compiledSourceLookup !== undefined && redactedCompiledSourceLookup !== undefined) {
-            return {
-                ...base,
-                compiledGeneratedBatch: compiledSourceLookup,
-                compiledSourceLookup,
-                kind: "sourceLookup",
-                redactedCompiledSourceLookup,
-                status: "valid",
-            };
-        }
-        if (compiledQaPreset !== undefined &&
-            redactedCompiledJob !== undefined &&
-            redactedCompiledQaPreset !== undefined) {
-            return {
-                ...base,
-                compiledGeneratedBatch: compiledQaPreset,
-                compiledJob: compiledQaPreset,
-                compiledQaPreset,
-                kind: "qa",
-                redactedCompiledJob,
-                redactedCompiledQaPreset,
-                status: "valid",
-            };
-        }
-        return undefined;
-    }
-    explicitInput() {
-        return normalizeExplicitEvalStdinArgs(isStringArray(this.params.args) ? this.params.args : [], typeof this.params.stdin === "string" ? this.params.stdin : undefined);
-    }
-    executionInput() {
-        const explicit = this.explicitInput();
-        return {
-            args: this.electron.compiled === undefined
-                ? (this.semanticAction.compiled?.args ??
-                    this.modes.compiledGeneratedBatch?.args ??
-                    explicit.args)
-                : [],
-            stdin: this.modes.compiledGeneratedBatch?.stdin ?? explicit.stdin,
-        };
-    }
-    resolve() {
-        const { args, stdin } = this.executionInput();
-        const redactedArgs = redactInvocationArgs([...args]);
-        const validationError = this.validationError(args, stdin);
-        const normalized = validationError !== undefined || isPlainTextInspectionArgs([...args])
-            ? { args, stdin }
-            : normalizeUrlLessOpen([...args], stdin);
-        const base = { redactedArgs, toolArgs: normalized.args, toolStdin: normalized.stdin };
-        if (validationError !== undefined) {
-            return {
-                ...base,
-                ...this.modes,
-                attemptedKind: this.attemptedKind(),
-                kind: "invalid",
-                status: "invalid",
-                validationError,
-            };
-        }
-        return this.validInput(base);
-    }
-}
-export function resolveAgentBrowserInput(options) {
-    const params = isRecord(options.params) ? options.params : {};
-    return new BrowserInputCompiler(params, options.getBatchPreflightValidationError).resolve();
-}
-export function buildValidationFailureResult(input) {
-    return {
-        content: [{ type: "text", text: input.validationError }],
-        details: {
-            args: input.redactedArgs,
-            compiledElectron: input.redactedCompiledElectron,
-            compiledJob: input.redactedCompiledJob,
-            compiledQaPreset: input.redactedCompiledQaPreset,
-            compiledSourceLookup: input.redactedCompiledSourceLookup,
-            compiledNetworkSourceLookup: input.redactedCompiledNetworkSourceLookup,
-            compiledSemanticAction: input.redactedCompiledSemanticAction,
-            ...buildAgentBrowserResultCategoryDetails({
-                args: [...input.redactedArgs],
-                errorText: input.validationError,
-                succeeded: false,
-                validationError: input.validationError,
-            }),
-            validationError: input.validationError,
-        },
-        isError: true,
-    };
-}

package/dist/extensions/agent-browser/lib/orchestration/input-redaction.js

@@ -1,62 +0,0 @@
-import { redactInvocationArgs, redactSensitiveText } from "../runtime.js";
-import { redactNetworkSourceLookupArgs, redactNetworkSourceLookupUrl, } from "../input-modes/lookups.js";
-export function redactCompiledElectron(compiled) {
-    if (compiled === undefined) {
-        return undefined;
-    }
-    if (compiled.action === "list") {
-        return {
-            ...compiled,
-            query: compiled.query !== undefined && compiled.query.length > 0
-                ? redactSensitiveText(compiled.query)
-                : undefined,
-        };
-    }
-    if (compiled.action === "launch") {
-        return {
-            ...compiled,
-            appArgs: compiled.appArgs === undefined ? undefined : redactInvocationArgs([...compiled.appArgs]),
-        };
-    }
-    return { ...compiled };
-}
-export function redactCompiledJob(compiled) {
-    if (compiled === undefined) {
-        return undefined;
-    }
-    const steps = compiled.steps.map((step) => ({
-        ...step,
-        args: redactInvocationArgs([...step.args]),
-    }));
-    return { ...compiled, stdin: JSON.stringify(steps.map((step) => step.args)), steps };
-}
-export function redactCompiledSourceLookup(compiled) {
-    if (compiled === undefined) {
-        return undefined;
-    }
-    const steps = compiled.steps.map((step) => ({
-        ...step,
-        args: redactInvocationArgs([...step.args]),
-    }));
-    return { ...compiled, stdin: JSON.stringify(steps.map((step) => step.args)), steps };
-}
-export function redactCompiledNetworkSourceLookup(compiled) {
-    if (compiled === undefined) {
-        return undefined;
-    }
-    const steps = compiled.steps.map((step) => ({
-        ...step,
-        args: redactNetworkSourceLookupArgs([...step.args]),
-    }));
-    return {
-        ...compiled,
-        args: redactNetworkSourceLookupArgs([...compiled.args]),
-        query: {
-            ...compiled.query,
-            filter: redactNetworkSourceLookupUrl(compiled.query.filter),
-            url: redactNetworkSourceLookupUrl(compiled.query.url),
-        },
-        stdin: JSON.stringify(steps.map((step) => step.args)),
-        steps,
-    };
-}

package/dist/extensions/agent-browser/lib/orchestration/native-config.js

@@ -1,144 +0,0 @@
-import { readFile, rm } from "node:fs/promises";
-import { isRecord } from "../parsing.js";
-import { isUpstreamEnvFlagEnabled } from "../argv-grammar.js";
-import { runAgentBrowserProcess } from "../process.js";
-import { parseAgentBrowserEnvelope } from "../results/envelope.js";
-// Native local launch defaults must keep their launch-time argument policy stable.
-const VALUE_DEFAULTS = [
-    "executablePath",
-    "profile",
-    "state",
-    "proxy",
-    "args",
-    "userAgent",
-    "caCert",
-    "colorScheme",
-    "downloadPath",
-    "engine",
-    "allowedDomains",
-];
-const BOOLEAN_DEFAULTS = ["headed", "allowFileAccess", "webgpu", "noWebmcp"];
-const ARRAY_DEFAULTS = ["extensions", "initScripts", "enable"];
-export function nativeEnvName(key) {
-    return `AGENT_BROWSER_${key.replace(/[A-Z]/g, (letter) => `_${letter}`).toUpperCase()}`;
-}
-function nativeBooleanDefault(config, env, key) {
-    const value = env[nativeEnvName(key)];
-    if (key === "hideScrollbars") {
-        return value === undefined ? config[key] === false : !isUpstreamEnvFlagEnabled(value);
-    }
-    return value === undefined ? config[key] === true : isUpstreamEnvFlagEnabled(value);
-}
-export function hasLocalLaunchDefaults(config, env) {
-    return (VALUE_DEFAULTS.some((key) => env[nativeEnvName(key)] !== undefined || config[key] !== undefined) ||
-        BOOLEAN_DEFAULTS.some((key) => isUpstreamEnvFlagEnabled(env[nativeEnvName(key)]) || config[key] === true) ||
-        ARRAY_DEFAULTS.some((key) => (env[nativeEnvName(key)] ?? "").length > 0 ||
-            (Array.isArray(config[key]) && config[key].length > 0)) ||
-        nativeBooleanDefault(config, env, "clearCaCert") ||
-        nativeBooleanDefault(config, env, "hideScrollbars") ||
-        ["HTTP_PROXY", "http_proxy", "HTTPS_PROXY", "https_proxy", "ALL_PROXY", "all_proxy"].some((key) => env[key] !== undefined));
-}
-function localFlag(key) {
-    switch (key) {
-        case "extensions":
-            return "--extension";
-        case "initScripts":
-            return "--init-script";
-        case "clearCaCert":
-            return "--no-ca-cert";
-        default:
-            return `--${key.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}`;
-    }
-}
-export const LOCAL_LAUNCH_DEFAULT_FLAGS = [
-    ...VALUE_DEFAULTS,
-    ...BOOLEAN_DEFAULTS,
-    ...ARRAY_DEFAULTS,
-    "hideScrollbars",
-    "clearCaCert",
-].map(localFlag);
-function requestsLaunch(config, options) {
-    const browserLaunch = options.browserCommand &&
-        (hasLocalLaunchDefaults(config, {}) ||
-            ["cdp", "autoConnect", "provider"].some((key) => config[key] !== undefined));
-    const rootLaunch = options.rootFallback &&
-        ["restore", "sessionName", "state", "allowedDomains", "profile", "executablePath"].some((key) => config[key] !== undefined);
-    return browserLaunch || rootLaunch;
-}
-async function readConfigFile(path) {
-    try {
-        const config = JSON.parse(await readFile(path, "utf8"));
-        if (!isRecord(config)) {
-            return undefined;
-        }
-        // Only identity is interpreted here; native validates every launch/config field.
-        return {
-            ...config,
-            session: typeof config.session === "string" ? config.session : undefined,
-            namespace: typeof config.namespace === "string" ? config.namespace : undefined,
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-function needsIdentityInspection(config, options) {
-    return (requestsLaunch(config, options) ||
-        config.confirmActions !== undefined ||
-        config.session !== undefined ||
-        config.namespace !== undefined);
-}
-function resolvedIdentity(config, data) {
-    if (!isRecord(data) || typeof data.session !== "string") {
-        throw new Error("Native agent-browser session inspection returned no session name; the browser command was not run.");
-    }
-    const { session: _session, namespace: _namespace, ...defaults } = config;
-    return {
-        ...defaults,
-        ...(config.session !== undefined ? { session: data.session } : {}),
-        ...(config.namespace !== undefined ? { namespace: config.namespace } : {}),
-    };
-}
-// Native `session` reports resolution, not whether a name was configured.
-async function readNativeIdentity(path, options) {
-    const config = await readConfigFile(path);
-    if (config === undefined) {
-        return {};
-    }
-    if (!needsIdentityInspection(config, options)) {
-        return {};
-    }
-    const result = await runAgentBrowserProcess({
-        args: ["--config", path, "--json", "session"],
-        cwd: options.cwd,
-        signal: options.signal,
-        timeoutMs: 5_000,
-    });
-    try {
-        if (result.aborted || result.timedOut || result.spawnError !== undefined) {
-            throw new Error("Could not resolve native agent-browser session configuration; the browser command was not run.");
-        }
-        if (result.exitCode !== 0) {
-            return {};
-        } // Discovered invalid files are native-ignored; explicit paths fail on the real command.
-        const parsed = await parseAgentBrowserEnvelope({
-            stdout: result.stdout,
-            stdoutPath: result.stdoutSpillPath,
-        });
-        return resolvedIdentity(config, parsed.envelope?.data);
-    }
-    finally {
-        if (result.stdoutSpillPath !== undefined && result.stdoutSpillPath.length > 0) {
-            await rm(result.stdoutSpillPath, { force: true });
-        }
-    }
-}
-export async function loadNativeIdentity(paths, options) {
-    const identity = {};
-    for (const path of paths) {
-        // Project defaults override global defaults; native validation must finish in that layer order.
-        // oxlint-disable-next-line no-await-in-loop
-        Object.assign(identity, await readNativeIdentity(path, options));
-    }
-    return identity;
-}

package/dist/extensions/agent-browser/lib/orchestration/native-root-launch.js

@@ -1,77 +0,0 @@
-import { scanUpstreamGlobalFlagOccurrences } from "../argv-grammar.js";
-import { withAgentBrowserProcessEnvironment } from "../process-environment.js";
-import { withChromeStartupArgs } from "../process.js";
-import { buildValidationFailureResult } from "./input-plan.js";
-import { inspectManagedSessionDaemon } from "./browser-run/managed-session-daemon-policy.js";
-import { buildMissingBinaryMessage } from "./browser-run/final-result-missing-binary.js";
-function cliValue(args, flag) {
-    return scanUpstreamGlobalFlagOccurrences([...args], flag).at(-1)?.value;
-}
-function bootstrapProfile(policy, bootstrap) {
-    const allowed = bootstrap &&
-        policy.chromeEngine &&
-        policy.restoreEligible &&
-        policy.identity.profile === undefined &&
-        policy.env.AGENT_BROWSER_PROFILE === undefined;
-    return (cliValue(policy.input.toolArgs, "--profile") ?? (allowed ? policy.defaultProfile : undefined));
-}
-function bootstrapExecutable(policy, bootstrap) {
-    const allowed = bootstrap &&
-        policy.chromeEngine &&
-        policy.identity.executablePath === undefined &&
-        policy.env.AGENT_BROWSER_EXECUTABLE_PATH === undefined;
-    return (cliValue(policy.input.toolArgs, "--executable-path") ??
-        (allowed ? policy.defaultExecutable : undefined));
-}
-function rootRestoreKey(policy, status, restoreKey) {
-    if (!policy.restoreEligible) {
-        return undefined;
-    }
-    if (status === "active") {
-        return restoreKey ?? undefined;
-    }
-    return status === "inactive" ? policy.rootName : undefined;
-}
-export async function withRootBrowserLaunch(policy, browserRun, signal) {
-    const daemon = await inspectManagedSessionDaemon({
-        cwd: policy.cwd,
-        signal,
-        sessionName: policy.rootName,
-        namespace: cliValue(policy.input.toolArgs, "--namespace") ?? policy.namespace,
-        timeoutMs: 5_000,
-    });
-    if (daemon.status === "missing-binary") {
-        return {
-            content: [{ type: "text", text: buildMissingBinaryMessage() }],
-            details: {
-                agentBrowserStarted: false,
-                args: policy.input.redactedArgs,
-                sessionName: policy.rootName,
-                resultCategory: "failure",
-                failureCategory: "missing-binary",
-            },
-            isError: true,
-        };
-    }
-    if (policy.input.kind === "qa" &&
-        policy.input.compiledQaPreset.checks.attached &&
-        daemon.status !== "active") {
-        return buildValidationFailureResult({
-            ...policy.input,
-            attemptedKind: "qa",
-            kind: "invalid",
-            status: "invalid",
-            validationError: "qa.attached requires an active attached session. Open the root browser first, or select an existing native session.",
-        });
-    }
-    // Active native daemons own their launch choices; defaults may only bootstrap or preserve explicit local options.
-    const bootstrap = daemon.status === "inactive";
-    const restore = rootRestoreKey(policy, daemon.status, daemon.status === "active" ? daemon.restoreKey : undefined);
-    const profile = bootstrapProfile(policy, bootstrap);
-    const executablePath = bootstrapExecutable(policy, bootstrap);
-    return withAgentBrowserProcessEnvironment({
-        ...(restore !== undefined ? { AGENT_BROWSER_RESTORE: restore } : {}),
-        ...(profile !== undefined ? { AGENT_BROWSER_PROFILE: profile } : {}),
-        ...(executablePath !== undefined ? { AGENT_BROWSER_EXECUTABLE_PATH: executablePath } : {}),
-    }, () => withChromeStartupArgs(bootstrap || policy.configuredChromeLaunch ? policy.chromeStartupArgs : undefined, () => browserRun(bootstrap)));
-}