pi-agent-browser-native 0.9.5 → 0.9.7

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

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

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

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

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

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

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