pi-agent-browser-native 0.9.3 → 0.9.5

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

@@ -0,0 +1,227 @@
+import { randomUUID } from "node:crypto";
+import { appendBrowserTransition } from "../browser-transcript.js";
+import { appendBrowserRecord } from "../browser-journal.js";
+import { buildExecutionPlan, createFreshSessionName, redactInvocationArgs } from "../runtime.js";
+import { getAgentBrowserSessionIdentityKey } from "../argv-grammar.js";
+import { parseArgvDescriptor } from "../argv-descriptor.js";
+import { needsManagedSession } from "../command-policy.js";
+import { isRecord } from "../parsing.js";
+import { resolveAgentBrowserSocketDir } from "../process.js";
+import { getAgentBrowserProcessEnvironment } from "../process-environment.js";
+// Static ownership keeps the runner's host peers inside Pi's extension-module mapping.
+import { runAgentBrowserTool } from "./browser-run/index.js";
+import { getSessionContextKey } from "./browser-run/session-state.js";
+import { ELECTRON_POST_COMMAND_STATUS_SETTLE_MS, ELECTRON_PROFILE_ISOLATION_DETAILS, } from "./electron-host/index.js";
+import { browserExecutionFailure } from "./extension-result-state.js";
+import { isAttachedBrowserInvocation } from "./extension-resource-replay.js";
+import { BrowserCommandResult } from "./extension-command-result.js";
+function captureBrowserRunState(runtime) {
+    return {
+        activeRecordingReservations: runtime.recordings.active,
+        artifactManifest: runtime.artifacts.manifest,
+        attachedSessionKeys: runtime.sessions.attached,
+        closedManagedSessionNames: new Set(),
+        electronChildProcesses: runtime.electron.childProcesses,
+        electronLaunchRecords: runtime.electron.records,
+        ephemeralSessionSeed: runtime.ephemeralSessionSeed,
+        freshSessionOrdinal: runtime.managed.freshOrdinal,
+        managedSessionActive: runtime.managed.active,
+        managedSessionBaseName: runtime.managed.baseName,
+        managedSessionCompatibilityWorkaround: runtime.managed.compatibilityWorkaround,
+        managedSessionHeadedAutosaveDisabled: runtime.managed.headedAutosaveDisabled,
+        managedSessionHeadedAutosaveInterval: runtime.managed.headedAutosaveInterval,
+        managedSessionCwd: runtime.managed.cwd,
+        managedSessionName: runtime.managed.name,
+        managedSessionNamespace: runtime.managed.namespace,
+        managedSessionRestoreState: runtime.managed.restore,
+        networkRoutesBySession: runtime.sessions.routes,
+        ownedManagedSessions: runtime.managed.owned,
+        sessionPageState: runtime.sessions.pages.fork(),
+        traceOwners: runtime.sessions.traces,
+    };
+}
+function selectCommandPlan(state, call) {
+    return buildExecutionPlan(call.toolArgs, {
+        freshSessionName: createFreshSessionName(state.managedSessionBaseName, state.ephemeralSessionSeed, state.freshSessionOrdinal + 1),
+        managedSessionActive: state.managedSessionActive,
+        managedSessionCompatibilityWorkaround: state.managedSessionCompatibilityWorkaround,
+        managedSessionName: state.managedSessionName,
+        managedSessionNamespace: state.managedSessionNamespace,
+        sessionMode: call.compiledElectron?.action === "launch" ? "fresh" : (call.params.sessionMode ?? "auto"),
+        stdin: call.resolvedInput.toolStdin,
+        browserIndependentReadConfirmation: call.readConfirmation?.capabilities?.readRequiresConfirmation === true,
+    });
+}
+function affectsBrowser(plan, call) {
+    if (plan.plainTextInspection ||
+        (plan.commandInfo.command === "session" && plan.commandInfo.subcommand === "info")) {
+        return false;
+    }
+    return (needsManagedSession(parseArgvDescriptor(call.toolArgs), call.resolvedInput.toolStdin) ||
+        plan.startupScopedFlags.length > 0);
+}
+function createBeginRecord(call, identity) {
+    const wrapperManaged = identity.wrapperManaged;
+    return {
+        event: {
+            version: 1,
+            phase: "begin",
+            operationId: identity.operationId,
+            toolCallId: call.toolCallId,
+            commandIndex: call.commandIndex ?? 0,
+            isError: true,
+            state: {
+                args: redactInvocationArgs(call.toolArgs),
+                sessionName: identity.plan.sessionName,
+                namespace: identity.plan.namespace,
+                ownerSessionId: call.ctx.sessionManager.getSessionId(),
+                usedImplicitSession: identity.plan.usedImplicitSession,
+                wrapperManaged,
+                managedSessionCwd: call.browserCwd,
+                managedSessionSocketDir: resolveAgentBrowserSocketDir({
+                    ownedManagedSession: wrapperManaged,
+                }),
+            },
+            pages: [
+                {
+                    key: identity.selectedKey,
+                    confirmActions: identity.confirmActions ?? null,
+                    refs: { kind: "unknown" },
+                    unknown: true,
+                },
+            ],
+        },
+    };
+}
+function prepareBrowserCommand(runtime, call, executionSignal) {
+    runtime.recordings.flush();
+    const generationAtStart = runtime.branch.stateGeneration;
+    const browserRunState = captureBrowserRunState(runtime);
+    const workingPageState = browserRunState.sessionPageState;
+    const priorPages = workingPageState.views();
+    const sessionPageStateUpdate = workingPageState.beginUpdate();
+    const selectedPlan = selectCommandPlan(browserRunState, call);
+    const operationId = randomUUID();
+    const selectedKey = getAgentBrowserSessionIdentityKey(selectedPlan.sessionName ?? "default", selectedPlan.namespace);
+    browserRunState.confirmationPolicyIdentity = selectedKey;
+    const confirmActions = getAgentBrowserProcessEnvironment().AGENT_BROWSER_CONFIRM_ACTIONS;
+    workingPageState.setConfirmActions(selectedKey, confirmActions);
+    const begin = createBeginRecord(call, {
+        plan: selectedPlan,
+        operationId,
+        selectedKey,
+        confirmActions,
+        wrapperManaged: selectedPlan.managedSessionName !== undefined || runtime.managed.owned.has(selectedKey),
+    });
+    return {
+        generationAtStart,
+        browserRunState,
+        workingPageState,
+        priorPages,
+        sessionPageStateUpdate,
+        selectedPlan,
+        operationId,
+        selectedKey,
+        begin,
+        browserAffecting: affectsBrowser(selectedPlan, call),
+        executionSignal,
+    };
+}
+async function admitBrowserCommand(pi, pages, call, prepared) {
+    if (!prepared.browserAffecting) {
+        return undefined;
+    }
+    try {
+        if (!(await appendBrowserRecord(call.ctx.sessionManager, () => appendBrowserTransition(pi, prepared.begin), prepared.begin, call.branch)) ||
+            !call.branch.isCurrent()) {
+            throw new Error("The selected Pi branch changed before browser-command admission.");
+        }
+    }
+    catch (error) {
+        const failure = browserExecutionFailure(new Error("Could not persist browser-state begin; the browser command was not run.", {
+            cause: error,
+        }), prepared.executionSignal);
+        return {
+            ...failure,
+            details: {
+                ...(isRecord(failure.details) ? failure.details : {}),
+                browserStatePersistence: "begin-unconfirmed",
+            },
+        };
+    }
+    pages.applyBrowserRecord(prepared.begin);
+    return undefined;
+}
+function captureDispatch(attachedSessionKeys, call, prepared) {
+    const electronLaunch = call.resolvedInput.kind === "electron" &&
+        call.resolvedInput.compiledElectron.action === "launch";
+    const attachedSessionRequested = isAttachedBrowserInvocation(call.toolArgs) || electronLaunch;
+    const allocatesFreshManagedSession = call.explicitSessionName === undefined &&
+        (call.params.sessionMode === "fresh" || electronLaunch);
+    const reusableSessionKey = allocatesFreshManagedSession
+        ? undefined
+        : (getSessionContextKey(prepared.selectedPlan.sessionName, prepared.selectedPlan.namespace) ??
+            getSessionContextKey(prepared.browserRunState.managedSessionName, prepared.browserRunState.managedSessionNamespace));
+    return {
+        initialArtifactManifest: prepared.browserRunState.artifactManifest,
+        initialNetworkRoutesBySession: prepared.browserRunState.networkRoutesBySession,
+        attachedSessionRequested,
+        attachedSessionKnown: reusableSessionKey !== undefined && attachedSessionKeys.has(reusableSessionKey),
+    };
+}
+async function dispatchBrowserCommand(timeouts, call, prepared, dispatch) {
+    try {
+        return await runAgentBrowserTool({
+            daemonInactive: dispatch.daemonInactive,
+            ctx: call.ctx,
+            cwd: call.browserCwd,
+            operationCwd: call.operationCwd,
+            electronPostCommandStatusSettleMs: ELECTRON_POST_COMMAND_STATUS_SETTLE_MS,
+            electronProfileIsolationDetails: ELECTRON_PROFILE_ISOLATION_DETAILS,
+            implicitSessionCloseTimeoutMs: timeouts.close,
+            implicitSessionIdleTimeoutMs: timeouts.idle,
+            input: call.resolvedInput,
+            modelVisible: call.modelVisible,
+            onUpdate: call.onUpdate,
+            params: call.params,
+            establishAttachedBrowserSession: dispatch.attachedSessionRequested && !dispatch.attachedSessionKnown,
+            preserveAttachedBrowserSession: dispatch.attachedSessionRequested || dispatch.attachedSessionKnown,
+            promptPolicy: call.promptPolicy,
+            sessionPageStateUpdate: prepared.sessionPageStateUpdate,
+            signal: prepared.executionSignal,
+            state: prepared.browserRunState,
+        });
+    }
+    catch (error) {
+        const failure = browserExecutionFailure(error, prepared.executionSignal);
+        return {
+            ...failure,
+            details: {
+                ...prepared.browserRunState.observedBrowserEffects,
+                ...(isRecord(failure.details) ? failure.details : {}),
+            },
+        };
+    }
+}
+export async function runBrowserCommand(runtime, call, daemonInactive, executionSignal = call.signal) {
+    const prepared = prepareBrowserCommand(runtime, call, executionSignal);
+    const admissionFailure = await admitBrowserCommand(runtime.pi, runtime.sessions.pages, call, prepared);
+    if (admissionFailure) {
+        return admissionFailure;
+    }
+    const dispatch = captureDispatch(runtime.sessions.attached, call, prepared);
+    const result = await dispatchBrowserCommand({ close: runtime.implicitSessionCloseTimeoutMs, idle: runtime.implicitSessionIdleTimeoutMs }, call, prepared, {
+        ...dispatch,
+        daemonInactive,
+    });
+    const completion = new BrowserCommandResult(runtime, call, prepared, { ...dispatch, result });
+    completion.reconcileNativeIdentity();
+    completion.reconcileAttachments();
+    completion.mergeResultArtifacts();
+    completion.adoptRuntime();
+    const persistenceFailure = await completion.persistFinish();
+    if (persistenceFailure) {
+        return persistenceFailure;
+    }
+    return completion.complete();
+}

package/dist/extensions/agent-browser/lib/orchestration/extension-command-state.js

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

package/dist/extensions/agent-browser/lib/orchestration/extension-electron-ownership.js

@@ -0,0 +1,204 @@
+import { isRecord } from "../parsing.js";
+import { findElectronLaunchRecordForSession, getActiveElectronRecords, getSessionContextKey, } from "./browser-run/session-state.js";
+import { untrackOwnedManagedSession } from "./extension-managed-ownership.js";
+export function getTouchedElectronLaunchIds(sessionName, records, namespace) {
+    const record = findElectronLaunchRecordForSession(sessionName, records, namespace);
+    return record ? new Set([record.launchId]) : undefined;
+}
+/** Branch-visible launches, live cleanup ownership, and their native child handles. */
+export class BrowserElectronResources {
+    records = new Map();
+    ownedRecords = new Map();
+    branchOwnedIds = new Set();
+    childProcesses = new Map();
+    mergeActive(source, options = {}) {
+        const target = this.ownedRecords;
+        const branchOwned = this.branchOwnedIds;
+        for (const record of getActiveElectronRecords(source)) {
+            if (options.ownerSessionId !== undefined &&
+                record.ownerSessionId !== options.ownerSessionId) {
+                continue;
+            }
+            const alreadyRuntimeOwned = target.has(record.launchId) && !branchOwned.has(record.launchId);
+            target.set(record.launchId, record);
+            if (alreadyRuntimeOwned) {
+                continue;
+            }
+            if (options.markBranchOwned === true) {
+                branchOwned.add(record.launchId);
+            }
+            else if (options.touchedLaunchIds?.has(record.launchId) === true) {
+                branchOwned.delete(record.launchId);
+            }
+        }
+    }
+    removeInactive(source, activeRanks, cleanupRanks) {
+        const target = this.ownedRecords;
+        const branchOwned = this.branchOwnedIds;
+        const activeIds = new Set(getActiveElectronRecords(source).map((record) => record.launchId));
+        for (const id of new Set([...source.keys(), ...cleanupRanks.keys()])) {
+            if (!target.has(id) || !branchOwned.has(id)) {
+                continue;
+            }
+            const active = activeRanks.get(id), cleanup = cleanupRanks.get(id);
+            const inactive = source.has(id) && !activeIds.has(id);
+            const cleanupIsLatest = cleanup !== undefined && (active === undefined || cleanup > active);
+            if (!inactive && !cleanupIsLatest) {
+                continue;
+            }
+            target.delete(id);
+            branchOwned.delete(id);
+        }
+    }
+    replaceActive(source, cleanedLaunchIds) {
+        this.ownedRecords.clear();
+        if (cleanedLaunchIds) {
+            for (const id of cleanedLaunchIds) {
+                this.branchOwnedIds.delete(id);
+            }
+        }
+        else {
+            this.branchOwnedIds.clear();
+        }
+        this.mergeActive(source);
+    }
+    forHostInput(options) {
+        if (options.compiledElectron?.action === "cleanup") {
+            return new Map([...mergeElectronLaunchRecordMaps(this.records, this.ownedRecords)].filter(([, record]) => record.ownerSessionId === options.ownerSessionId));
+        }
+        if (options.compiledElectron?.action === "status" ||
+            (options.compiledElectron?.action === "probe" &&
+                options.compiledElectron.launchId !== undefined &&
+                options.compiledElectron.launchId !== "")) {
+            return mergeElectronLaunchRecordMaps(this.records, this.ownedRecords);
+        }
+        return this.records;
+    }
+    mergeCleanup(results) {
+        for (const record of getCleanupResultsElectronRecords(results)) {
+            this.records.set(record.launchId, record);
+        }
+    }
+    resetOwnership() {
+        this.ownedRecords = new Map();
+        this.branchOwnedIds = new Set();
+    }
+    reset() {
+        this.records = new Map();
+        this.resetOwnership();
+        this.childProcesses = new Map();
+    }
+}
+export function mergeElectronLaunchRecordMaps(...maps) {
+    const merged = new Map();
+    for (const map of maps) {
+        for (const [id, record] of map) {
+            merged.set(id, record);
+        }
+    }
+    return merged;
+}
+export function shouldSerializeElectronHostInput(compiledElectron) {
+    return (compiledElectron?.action === "status" ||
+        compiledElectron?.action === "probe" ||
+        compiledElectron?.action === "cleanup");
+}
+function cleanupIdentityField(step, record, field, fallback) {
+    const value = step[field];
+    if (typeof value === "string") {
+        return value;
+    }
+    const retained = record?.[field];
+    return typeof retained === "string" ? retained : fallback;
+}
+function isClosedManagedSessionStep(step) {
+    return (isRecord(step) &&
+        step.resource === "managed-session" &&
+        (step.state === "removed" || step.state === "already-gone"));
+}
+export function getCleanupResultClosedManagedSessionIdentities(result, fallbackNamespace) {
+    if (!isRecord(result) || !Array.isArray(result.steps)) {
+        return [];
+    }
+    const identities = new Map();
+    const record = isRecord(result.record) ? result.record : undefined;
+    for (const step of result.steps) {
+        if (!isClosedManagedSessionStep(step)) {
+            continue;
+        }
+        const sessionName = cleanupIdentityField(step, record, "sessionName");
+        if (sessionName === undefined || sessionName === "") {
+            continue;
+        }
+        const namespace = cleanupIdentityField(step, record, "namespace", fallbackNamespace);
+        identities.set(getSessionContextKey(sessionName, namespace) ?? sessionName, {
+            namespace,
+            sessionName,
+        });
+    }
+    return [...identities.values()];
+}
+export function getCleanupResultsClosedManagedSessionIdentities(results, fallbackNamespace) {
+    const identities = new Map();
+    for (const result of results) {
+        for (const identity of getCleanupResultClosedManagedSessionIdentities(result, fallbackNamespace)) {
+            identities.set(getSessionContextKey(identity.sessionName, identity.namespace) ?? identity.sessionName, identity);
+        }
+    }
+    return [...identities.values()];
+}
+function validElectronRecordIdentity(value) {
+    return (value.version === 1 &&
+        (value.namespace === undefined || typeof value.namespace === "string") &&
+        typeof value.launchId === "string" &&
+        typeof value.appName === "string");
+}
+export function isElectronLaunchRecord(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return (validElectronRecordIdentity(value) &&
+        value.launchedByWrapper === true &&
+        typeof value.executablePath === "string" &&
+        typeof value.userDataDir === "string" &&
+        typeof value.port === "number" &&
+        typeof value.createdAtMs === "number");
+}
+export function getCleanupResultsElectronRecords(results) {
+    return results
+        .map((result) => (isRecord(result) ? result.record : undefined))
+        .filter(isElectronLaunchRecord);
+}
+export function getCleanupResultsPreservedUserDataDirs(results) {
+    const dirs = new Set();
+    for (const result of results) {
+        if (!isRecord(result) ||
+            !Array.isArray(result.steps) ||
+            !isElectronLaunchRecord(result.record)) {
+            continue;
+        }
+        const step = result.steps.find((row) => isRecord(row) && row.resource === "user-data-dir");
+        if (!isRecord(step)) {
+            continue;
+        }
+        if (step.state === "skipped" || step.state === "failed") {
+            dirs.add(result.record.userDataDir);
+        }
+    }
+    return [...dirs];
+}
+export function syncElectronCleanupManagedSessions(sessions, results, fallbackNamespace) {
+    for (const identity of getCleanupResultsClosedManagedSessionIdentities(results, fallbackNamespace)) {
+        untrackOwnedManagedSession(sessions, identity.sessionName, identity.namespace);
+    }
+}
+export function getOffBranchOwnedElectronLaunchRecords(ownedRecords, branchRecords) {
+    const activeIds = new Set(getActiveElectronRecords(branchRecords).map((record) => record.launchId));
+    const offBranch = new Map();
+    for (const record of getActiveElectronRecords(ownedRecords)) {
+        if (!activeIds.has(record.launchId)) {
+            offBranch.set(record.launchId, record);
+        }
+    }
+    return offBranch;
+}

package/dist/extensions/agent-browser/lib/orchestration/extension-execution-locks.js

@@ -0,0 +1,139 @@
+import { buildExecutionPlan, createFreshSessionName, extractUpstreamCommandTokens, } from "../runtime.js";
+import { getAgentBrowserSessionIdentityKey, scanUpstreamGlobalFlagOccurrences, } from "../argv-grammar.js";
+import { getAgentBrowserProcessTimeoutMs } from "../process.js";
+import { getCommandAwareProcessTimeoutMs } from "./browser-run/prepare/wait-timeouts.js";
+import { withAgentBrowserProcessEnvironment } from "../process-environment.js";
+import { buildValidationFailureResult } from "./input-plan.js";
+import { resolveBrowserExecutionIdentity, withBrowserExecutionLocks, } from "../managed-session-policy-lock.js";
+import { getArtifactPreflightValidationError, commandTouchesArtifactLifecycle, } from "./extension-artifact-preflight.js";
+import { browserExecutionFailure } from "./extension-result-state.js";
+import { warnRecordingPersistence } from "./extension-recording.js";
+import { runBrowserCommand } from "./extension-command-run.js";
+class BrowserCommandCoordinator {
+    runtime;
+    call;
+    plan;
+    key;
+    constructor(runtime, call) {
+        this.runtime = runtime;
+        this.call = call;
+        // Electron's browser identity is known before its host supplies the CDP port.
+        this.plan = buildExecutionPlan(call.compiledElectron?.action === "launch" ? ["connect"] : call.toolArgs, {
+            freshSessionName: createFreshSessionName(runtime.managed.baseName, runtime.ephemeralSessionSeed, runtime.managed.freshOrdinal + 1),
+            managedSessionActive: runtime.managed.active,
+            managedSessionCompatibilityWorkaround: runtime.managed.compatibilityWorkaround,
+            managedSessionName: runtime.managed.name,
+            managedSessionNamespace: runtime.managed.namespace,
+            sessionMode: call.compiledElectron?.action === "launch"
+                ? "fresh"
+                : (call.params.sessionMode ?? "auto"),
+            stdin: call.resolvedInput.toolStdin,
+        });
+        this.key = getAgentBrowserSessionIdentityKey(this.plan.sessionName ?? "default", this.plan.namespace);
+    }
+    launchEnvironment() {
+        const owner = this.runtime.managed.owned.get(this.key);
+        const explicit = ["--confirm-actions", "--config"].some((flag) => scanUpstreamGlobalFlagOccurrences(this.call.toolArgs, flag).length > 0);
+        const retained = this.runtime.sessions.pages.get(this.key).confirmActions;
+        return {
+            ...(owner?.socketDir !== undefined && owner.socketDir !== ""
+                ? { PI_AGENT_BROWSER_SOCKET_DIR: owner.socketDir }
+                : {}),
+            AGENT_BROWSER_CONFIRM_ACTIONS: !explicit && retained !== undefined
+                ? retained
+                : this.call.resolvedInput.nativeConfirmActions,
+        };
+    }
+    execute(signal) {
+        return this.call.withLaunchDefaults
+            ? this.call.withLaunchDefaults((inactive) => runBrowserCommand(this.runtime, this.call, inactive, signal), signal)
+            : runBrowserCommand(this.runtime, this.call, undefined, signal);
+    }
+    async preflightAndExecute(signal) {
+        const error = getArtifactPreflightValidationError({
+            activeRecordingReservations: [...this.runtime.recordings.active.values()],
+            args: this.call.toolArgs,
+            cwd: this.call.operationCwd,
+            outputPath: this.call.outputPath,
+            stdin: this.call.resolvedInput.toolStdin,
+        });
+        if (error === undefined || error === "") {
+            return this.execute(signal);
+        }
+        this.runtime.recordings.flush();
+        return warnRecordingPersistence(this.runtime.recordings.dirty, buildValidationFailureResult({
+            ...this.call.resolvedInput,
+            attemptedKind: this.call.resolvedInput.kind,
+            kind: "invalid",
+            status: "invalid",
+            validationError: error,
+        }));
+    }
+    runCommand(signal = this.call.signal) {
+        if (!commandTouchesArtifactLifecycle(this.call.toolArgs, this.call.resolvedInput.toolStdin, this.call.outputPath)) {
+            return this.execute(signal);
+        }
+        return this.runtime.artifacts.queue.run(() => this.preflightAndExecute(signal));
+    }
+    needsIdentityLock() {
+        if (this.plan.validationError !== undefined && this.plan.validationError !== "") {
+            return false;
+        }
+        return ((this.plan.sessionName !== undefined && this.plan.sessionName !== "") ||
+            this.plan.commandInfo.command === "read" ||
+            this.call.closesAllSessions);
+    }
+    replacesManagedSession() {
+        return (this.runtime.managed.active &&
+            (this.call.params.sessionMode === "fresh" ||
+                this.call.compiledElectron?.action === "launch") &&
+            (this.call.explicitSessionName === undefined || this.call.explicitSessionName === ""));
+    }
+    async identities() {
+        const identities = [
+            await resolveBrowserExecutionIdentity({
+                namespace: this.plan.namespace,
+                ownedManagedSession: this.plan.managedSessionName !== undefined || this.runtime.managed.owned.has(this.key),
+                sessionName: this.call.closesAllSessions ? undefined : (this.plan.sessionName ?? "default"),
+            }),
+        ];
+        if (this.replacesManagedSession()) {
+            const previous = this.runtime.managed.owned.get(getAgentBrowserSessionIdentityKey(this.runtime.managed.name, this.runtime.managed.namespace));
+            identities.push(await resolveBrowserExecutionIdentity({
+                namespace: this.runtime.managed.namespace,
+                ownedManagedSession: true,
+                sessionName: this.runtime.managed.name,
+                env: previous?.socketDir !== undefined && previous.socketDir !== ""
+                    ? { AGENT_BROWSER_SOCKET_DIR: previous.socketDir }
+                    : undefined,
+            }));
+        }
+        return identities;
+    }
+    deadline() {
+        const url = this.runtime.sessions.pages.get(this.key).tabTarget?.url;
+        return (Date.now() +
+            (this.call.params.timeoutMs ??
+                getCommandAwareProcessTimeoutMs(extractUpstreamCommandTokens(this.call.toolArgs), this.call.resolvedInput.toolStdin, url) ??
+                getAgentBrowserProcessTimeoutMs()));
+    }
+    async runLocked() {
+        if (!this.needsIdentityLock()) {
+            return this.runCommand();
+        }
+        try {
+            const identities = await this.identities();
+            return await withBrowserExecutionLocks({ identities, signal: this.call.signal, deadline: this.deadline(), waitOnly: true }, (signal) => this.runCommand(signal));
+        }
+        catch (error) {
+            return browserExecutionFailure(error, this.call.signal);
+        }
+    }
+    run() {
+        // Retained settings are resolved inside the identity queue before daemon or page helpers.
+        return withAgentBrowserProcessEnvironment(this.launchEnvironment(), () => this.runLocked());
+    }
+}
+export function runWithLaunchDefaults(runtime, call) {
+    return new BrowserCommandCoordinator(runtime, call).run();
+}

package/dist/extensions/agent-browser/lib/orchestration/extension-execution-queue.js

@@ -0,0 +1,24 @@
+import { buildExecutionPlan, createFreshSessionName } from "../runtime.js";
+import { runWithLaunchDefaults } from "./extension-execution-locks.js";
+export function runWithinSessionQueue(runtime, call) {
+    if (call.closesAllSessions) {
+        return runtime.managedSessionExecutionQueue.run(() => {
+            const plan = buildExecutionPlan(call.toolArgs, {
+                freshSessionName: createFreshSessionName(runtime.managed.baseName, runtime.ephemeralSessionSeed, runtime.managed.freshOrdinal + 1),
+                managedSessionActive: runtime.managed.active,
+                managedSessionCompatibilityWorkaround: runtime.managed.compatibilityWorkaround,
+                managedSessionName: runtime.managed.name,
+                managedSessionNamespace: runtime.managed.namespace,
+                sessionMode: call.params.sessionMode ?? "auto",
+                stdin: call.resolvedInput.toolStdin,
+            });
+            return runtime.callerOwnedSessionExecutionQueues.runExclusive(plan.namespace, () => runWithLaunchDefaults(runtime, call));
+        });
+    }
+    if (call.serializeBrowserCommand) {
+        return runtime.managedSessionExecutionQueue.run(() => runWithLaunchDefaults(runtime, call), call.signal);
+    }
+    return call.callerOwnedSessionQueueKey !== undefined && call.callerOwnedSessionQueueKey !== ""
+        ? runtime.callerOwnedSessionExecutionQueues.run(call.callerOwnedSessionQueueKey, call.callerOwnedSessionNamespace, () => runWithLaunchDefaults(runtime, call), call.signal)
+        : runWithLaunchDefaults(runtime, call);
+}