pi-agent-browser-native 0.9.2 → 0.9.4

package/dist/extensions/agent-browser/lib/orchestration/extension-branch-restore.js

@@ -0,0 +1,275 @@
+import { format } from "node:util";
+import { SessionPageState } from "../session-page-state.js";
+import { getBrowserRecord } from "../browser-transcript.js";
+import { readBrowserEntries } from "../browser-journal.js";
+import { createFreshSessionName, isRestorableManagedSessionName, restoreManagedSessionStateFromBranch, } from "../runtime.js";
+import { getAgentBrowserSessionIdentityKey } from "../argv-grammar.js";
+import { getActiveElectronRecords, getSessionContextKey } from "./browser-run/session-state.js";
+import { restoreElectronLaunchRecordsFromBranch, } from "./electron-host/index.js";
+import { restoreArtifactManifestFromBranch } from "./extension-result-state.js";
+import { trackOwnedManagedSession, untrackOwnedManagedSessionFromBranchClose, } from "./extension-managed-ownership.js";
+import { collectBranchManagedResourceEvents } from "./extension-resource-replay.js";
+import { collectPendingOwnedBrowserIntents } from "./extension-intent-replay.js";
+import { restoreAttachedSessionKeysFromBranch } from "./extension-attachment-replay.js";
+async function readBranchForRestore(runtime, ctx, resetRuntimeOwnership) {
+    runtime.branch.beginRestore(ctx.sessionManager.getSessionId());
+    runtime.prompt.restore(ctx);
+    const previous = {
+        active: runtime.managed.active,
+        sessionName: runtime.managed.name,
+        freshOrdinal: runtime.managed.freshOrdinal,
+        attachedKeys: runtime.sessions.attached,
+        pageState: runtime.sessions.pages,
+    };
+    runtime.managed.initializeBase(ctx.sessionManager.getSessionId(), ctx.cwd, runtime.ephemeralSessionSeed);
+    try {
+        const branch = await readBrowserEntries(ctx.sessionManager);
+        runtime.branch.setReplayError(undefined);
+        return { previous, branch, resetRuntimeOwnership };
+    }
+    catch (error) {
+        runtime.branch.setReplayError(error instanceof Error ? error.message : format("%s", error));
+        runtime.sessions.pages.reset();
+        throw error;
+    }
+}
+function headedLaunchTracking(launch) {
+    return {
+        headedManagedAutosaveDisabled: launch?.headedManagedAutosaveDisabled ?? false,
+        headedManagedAutosaveInterval: launch?.headedManagedAutosaveInterval,
+        socketDir: launch?.socketDir,
+    };
+}
+class BrowserBranchRestoration {
+    runtime;
+    ctx;
+    input;
+    branchResourceEvents;
+    restoredState;
+    constructor(runtime, ctx, input) {
+        this.runtime = runtime;
+        this.ctx = ctx;
+        this.input = input;
+        this.branchResourceEvents = collectBranchManagedResourceEvents(input.branch);
+        this.restoredState = restoreManagedSessionStateFromBranch([...input.branch], runtime.managed.baseName);
+    }
+    currentLaunch() {
+        return this.branchResourceEvents.managedSessionLaunchState.get(getSessionContextKey(this.runtime.managed.name, this.runtime.managed.namespace) ??
+            this.runtime.managed.name);
+    }
+    restoreManagedState() {
+        this.runtime.managed.restore.replace([...this.restoredState.managedSessionRestoreDisabledIdentities], {
+            preserveDaemonRestoreKeys: !this.input.resetRuntimeOwnership,
+        });
+        this.runtime.managed.active = this.restoredState.active;
+    }
+    alreadyReservedPostClose(ordinal, shouldReserve) {
+        return (shouldReserve &&
+            !this.input.resetRuntimeOwnership &&
+            !this.input.previous.active &&
+            this.input.previous.freshOrdinal > this.restoredState.freshSessionOrdinal &&
+            this.input.previous.freshOrdinal === ordinal &&
+            this.input.previous.sessionName ===
+                createFreshSessionName(this.runtime.managed.baseName, this.runtime.ephemeralSessionSeed, ordinal));
+    }
+    reserveSession() {
+        const restoredFreshSessionOrdinal = this.input.resetRuntimeOwnership
+            ? this.restoredState.freshSessionOrdinal
+            : Math.max(this.input.previous.freshOrdinal, this.restoredState.freshSessionOrdinal);
+        const shouldReservePostCloseSession = !this.restoredState.active &&
+            this.restoredState.closedSessionName === this.restoredState.sessionName;
+        const alreadyReservedPostCloseSession = this.alreadyReservedPostClose(restoredFreshSessionOrdinal, shouldReservePostCloseSession);
+        const nextFreshSessionOrdinal = shouldReservePostCloseSession && !alreadyReservedPostCloseSession
+            ? restoredFreshSessionOrdinal + 1
+            : restoredFreshSessionOrdinal;
+        if (!shouldReservePostCloseSession) {
+            this.runtime.managed.name = this.restoredState.sessionName;
+        }
+        else if (alreadyReservedPostCloseSession) {
+            this.runtime.managed.name = this.input.previous.sessionName;
+        }
+        else {
+            this.runtime.managed.name = createFreshSessionName(this.runtime.managed.baseName, this.runtime.ephemeralSessionSeed, nextFreshSessionOrdinal);
+        }
+        this.runtime.managed.freshOrdinal = nextFreshSessionOrdinal;
+        this.runtime.managed.namespace = shouldReservePostCloseSession
+            ? undefined
+            : this.restoredState.namespace;
+    }
+    restoreLaunchState() {
+        const currentLaunch = this.currentLaunch();
+        this.runtime.managed.compatibilityWorkaround = this.runtime.managed.active
+            ? currentLaunch?.compatibilityWorkaround
+            : undefined;
+        this.runtime.managed.headedAutosaveDisabled =
+            this.runtime.managed.active && currentLaunch?.headedManagedAutosaveDisabled === true;
+        this.runtime.managed.headedAutosaveInterval = this.runtime.managed.active
+            ? currentLaunch?.headedManagedAutosaveInterval
+            : undefined;
+        this.runtime.managed.cwd = currentLaunch?.cwd ?? this.ctx.cwd;
+    }
+    restoreRecordingState() {
+        this.runtime.sessions.pages = SessionPageState.fromBranch([...this.input.branch]);
+        this.runtime.sessions.traces = new Map();
+        this.runtime.artifacts.manifest = restoreArtifactManifestFromBranch(this.input.branch);
+        this.runtime.recordings.restore(this.input.branch);
+    }
+    restoreAttachments() {
+        this.runtime.sessions.attached = restoreAttachedSessionKeysFromBranch(this.input.branch);
+        this.runtime.sessions.routes = new Map();
+        this.runtime.electron.records = restoreElectronLaunchRecordsFromBranch([...this.input.branch]);
+        for (const record of getActiveElectronRecords(this.runtime.electron.records)) {
+            if (record.sessionName !== undefined && record.sessionName !== "") {
+                this.runtime.sessions.attached.add(getSessionContextKey(record.sessionName, record.namespace) ?? record.sessionName);
+            }
+        }
+    }
+    restoreOwnershipRanks() {
+        if (this.input.resetRuntimeOwnership) {
+            this.runtime.managed.owned.clear();
+            this.runtime.electron.resetOwnership();
+        }
+        else {
+            for (const [sessionName, closeRank] of this.branchResourceEvents.managedSessionCloseRanks) {
+                untrackOwnedManagedSessionFromBranchClose(this.runtime.managed.owned, sessionName, this.branchResourceEvents.managedSessionActiveRanks.get(sessionName), closeRank);
+            }
+            this.runtime.electron.removeInactive(this.runtime.electron.records, this.branchResourceEvents.electronLaunchActiveRanks, this.branchResourceEvents.electronLaunchCleanupRanks);
+        }
+    }
+    restoreManagedOwners() {
+        for (const [sessionKey, identity] of this.branchResourceEvents.managedSessionActiveIdentities) {
+            this.restoreBranchManagedOwner(sessionKey, identity);
+        }
+        if (this.restoredState.active) {
+            trackOwnedManagedSession(this.runtime.managed.owned, this.restoredState.sessionName, this.runtime.managed.cwd, {
+                branchOwned: true,
+                compatibilityWorkaround: this.runtime.managed.compatibilityWorkaround,
+                headedManagedAutosaveDisabled: this.runtime.managed.headedAutosaveDisabled,
+                headedManagedAutosaveInterval: this.runtime.managed.headedAutosaveInterval,
+                namespace: this.restoredState.namespace,
+                socketDir: this.currentLaunch()?.socketDir,
+            });
+        }
+    }
+    sessionActiveOnBranch(key) {
+        const active = this.branchResourceEvents.managedSessionActiveRanks.get(key);
+        const closed = this.branchResourceEvents.managedSessionCloseRanks.get(key);
+        return active !== undefined && (closed === undefined || closed < active);
+    }
+    restoreBranchManagedOwner(key, identity) {
+        if (!this.sessionActiveOnBranch(key) ||
+            !isRestorableManagedSessionName(identity.sessionName, this.runtime.managed.baseName)) {
+            return;
+        }
+        const launch = this.branchResourceEvents.managedSessionLaunchState.get(key);
+        trackOwnedManagedSession(this.runtime.managed.owned, identity.sessionName, launch?.cwd ?? this.ctx.cwd, {
+            branchOwned: true,
+            compatibilityWorkaround: launch?.compatibilityWorkaround,
+            headedManagedAutosaveDisabled: launch?.headedManagedAutosaveDisabled ?? false,
+            headedManagedAutosaveInterval: launch?.headedManagedAutosaveInterval,
+            namespace: identity.namespace,
+            socketDir: launch?.socketDir,
+        });
+    }
+    restoreInterruptedIntents() {
+        for (const begin of collectPendingOwnedBrowserIntents(this.input.branch, this.runtime.branch.ownerSessionId)) {
+            if (typeof begin.state.sessionName !== "string") {
+                continue;
+            }
+            // The persisted wrapper-selected intent proves cleanup scope, not launch success.
+            trackOwnedManagedSession(this.runtime.managed.owned, begin.state.sessionName, typeof begin.state.managedSessionCwd === "string"
+                ? begin.state.managedSessionCwd
+                : this.ctx.cwd, {
+                branchOwned: true,
+                namespace: typeof begin.state.namespace === "string" ? begin.state.namespace : undefined,
+                socketDir: typeof begin.state.managedSessionSocketDir === "string"
+                    ? begin.state.managedSessionSocketDir
+                    : undefined,
+            });
+        }
+    }
+    restoreElectronOwners() {
+        for (const record of getActiveElectronRecords(this.runtime.electron.records)) {
+            this.restoreElectronOwner(record);
+        }
+        this.runtime.electron.mergeActive(new Map([...this.runtime.electron.records].filter(([, record]) => record.ownerSessionId === this.runtime.branch.ownerSessionId)), { markBranchOwned: true });
+    }
+    restoreElectronOwner(record) {
+        const session = record.sessionName;
+        if (session === undefined ||
+            session === "" ||
+            !isRestorableManagedSessionName(session, this.runtime.managed.baseName)) {
+            return;
+        }
+        const key = getSessionContextKey(session) ?? session;
+        if (!this.sessionActiveOnBranch(key)) {
+            return;
+        }
+        const launch = this.branchResourceEvents.managedSessionLaunchState.get(key);
+        trackOwnedManagedSession(this.runtime.managed.owned, session, launch?.cwd ?? this.ctx.cwd, {
+            branchOwned: true,
+            ...headedLaunchTracking(launch),
+        });
+    }
+    restoreDaemonReceipts() {
+        for (const entry of this.input.branch) {
+            const event = getBrowserRecord(entry)?.event;
+            if (event && event.phase !== "begin") {
+                this.restoreDaemonReceipt(event.state);
+            }
+        }
+    }
+    restoreDaemonReceipt(state) {
+        if (state.ownerSessionId !== this.runtime.branch.ownerSessionId ||
+            typeof state.sessionName !== "string") {
+            return;
+        }
+        const namespace = typeof state.namespace === "string" ? state.namespace : undefined;
+        const key = getAgentBrowserSessionIdentityKey(state.sessionName, namespace);
+        if (this.runtime.managed.owned.has(key) &&
+            !this.runtime.managed.restore.hasDaemonRestoreKey(state.sessionName, namespace)) {
+            this.runtime.managed.restore.restoreDaemonReceipt(state.sessionName, namespace, state.managedSessionDaemon);
+        }
+    }
+    preserveLiveOwners() {
+        if (!this.input.resetRuntimeOwnership) {
+            // Off-branch live owners still need their established setting for cleanup.
+            for (const key of this.runtime.managed.owned.keys()) {
+                if (!this.branchResourceEvents.managedSessionActiveIdentities.has(key)) {
+                    this.runtime.sessions.pages.setConfirmActions(key, this.input.previous.pageState.get(key).confirmActions);
+                }
+            }
+            for (const sessionKey of this.input.previous.attachedKeys) {
+                if (this.runtime.managed.owned.has(sessionKey)) {
+                    this.runtime.sessions.attached.add(sessionKey);
+                }
+            }
+            for (const record of this.runtime.electron.ownedRecords.values()) {
+                const sessionKey = getSessionContextKey(record.sessionName);
+                if (sessionKey !== undefined &&
+                    sessionKey !== "" &&
+                    this.input.previous.attachedKeys.has(sessionKey)) {
+                    this.runtime.sessions.attached.add(sessionKey);
+                }
+            }
+        }
+    }
+    run() {
+        this.restoreManagedState();
+        this.reserveSession();
+        this.restoreLaunchState();
+        this.restoreRecordingState();
+        this.restoreAttachments();
+        this.restoreOwnershipRanks();
+        this.restoreManagedOwners();
+        this.restoreInterruptedIntents();
+        this.restoreElectronOwners();
+        this.restoreDaemonReceipts();
+        this.preserveLiveOwners();
+        return [...this.input.branch];
+    }
+}
+export async function restoreBranchBackedState(runtime, ctx, options) {
+    const input = await readBranchForRestore(runtime, ctx, options.resetRuntimeOwnership);
+    return new BrowserBranchRestoration(runtime, ctx, input).run();
+}

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

@@ -0,0 +1,280 @@
+import { requirePublishedBrowserJournal } from "../browser-journal.js";
+import { buildExecutionPlan } from "../runtime.js";
+import { extractExplicitSessionName, getAgentBrowserSessionIdentityKey } from "../argv-grammar.js";
+import { isRecord } from "../parsing.js";
+import { getAgentBrowserProcessEnvironment, withAgentBrowserProcessEnvironment, } from "../process-environment.js";
+import { withNativeSessionDefaults } from "./native-session-defaults.js";
+import { getBrowserCwdError, resolveExecutionCwd } from "../execution-cwd.js";
+import { AGENT_BROWSER_SCRIPT_DEFAULT_TIMEOUT_MS, bindBrowserCodeCall, runAgentBrowserScript, } from "../input-modes/script.js";
+import { buildValidationFailureResult, resolveAgentBrowserInput, } from "./input-plan.js";
+import { applyAgentBrowserOutputPath } from "./output-file.js";
+import { createBrowserCodeOutput } from "./script-mode.js";
+import { resolveBrowserExecutionIdentity, withBrowserExecutionLock, } from "../managed-session-policy-lock.js";
+import { loadAgentBrowserConfigSync } from "../config.js";
+import { getArtifactPreflightValidationError } from "./extension-artifact-preflight.js";
+import { browserExecutionFailure } from "./extension-result-state.js";
+import { shouldSerializeBrowserCommand } from "./extension-managed-ownership.js";
+import { shouldIncludeProjectConfig } from "./extension-prompt.js";
+import { executeBrowserInvocation } from "./extension-command-admission.js";
+import { createBrowserInvocation } from "./extension-invocation.js";
+function codePreflight(pi, replayError, invocation) {
+    if (replayError !== undefined && replayError !== "") {
+        return {
+            failure: browserExecutionFailure(new Error(replayError), invocation.signal, "validation-error"),
+        };
+    }
+    try {
+        requirePublishedBrowserJournal(invocation.ctx.sessionManager);
+        return { cwd: resolveExecutionCwd(pi, invocation.ctx) };
+    }
+    catch (error) {
+        return { failure: browserExecutionFailure(error, invocation.signal, "validation-error") };
+    }
+}
+class BrowserCodeExecution {
+    runtime;
+    invocation;
+    operationCwd;
+    deadline;
+    output = createBrowserCodeOutput();
+    nativeEnvironment = getAgentBrowserProcessEnvironment();
+    controller = new AbortController();
+    abort = () => {
+        this.controller.abort(this.invocation.signal?.reason);
+    };
+    commandIndex = 0;
+    journalFailed = false;
+    constructor(runtime, invocation, operationCwd) {
+        this.runtime = runtime;
+        this.invocation = invocation;
+        this.operationCwd = operationCwd;
+        this.deadline =
+            Date.now() + (invocation.params.timeoutMs ?? AGENT_BROWSER_SCRIPT_DEFAULT_TIMEOUT_MS);
+    }
+    start() {
+        const { runtime, invocation } = this;
+        invocation.signal?.addEventListener("abort", this.abort, { once: true });
+        if (invocation.signal?.aborted === true) {
+            this.abort();
+        }
+        runtime.code.controllers.add(this.controller);
+    }
+    prepare() {
+        const { params } = this.invocation;
+        const args = [
+            ...(params.namespace !== undefined ? ["--namespace", params.namespace] : []),
+            ...(params.session !== undefined ? ["--session", params.session] : []),
+            "get",
+            "url",
+        ];
+        const input = resolveAgentBrowserInput({
+            params: { args },
+            getBatchPreflightValidationError: () => {
+                // The identity-selection get-url probe has no batch rows to preflight.
+            },
+        });
+        return input;
+    }
+    browserCwd() {
+        const { runtime, invocation } = this;
+        if (this.nativeEnvironment.AGENT_BROWSER_CONFIG !== undefined) {
+            return this.operationCwd;
+        }
+        const session = invocation.params.session;
+        if (session !== undefined && session !== "") {
+            const key = getAgentBrowserSessionIdentityKey(session, invocation.params.namespace ?? this.nativeEnvironment.AGENT_BROWSER_NAMESPACE);
+            return runtime.managed.owned.get(key)?.cwd ?? invocation.ctx.cwd;
+        }
+        return runtime.managed.active ? runtime.managed.cwd : invocation.ctx.cwd;
+    }
+    nativeRoot() {
+        const { invocation } = this;
+        const config = loadAgentBrowserConfigSync({
+            cwd: invocation.ctx.cwd,
+            includeProjectConfig: shouldIncludeProjectConfig(invocation.ctx),
+        });
+        const profile = config.trustedBrowserDefaultProfile;
+        const root = process.env.PI_SUBAGENT_ROOT_SESSION_ID;
+        const id = process.env.PI_SUBAGENT_CHILD === "1" && root !== undefined && root !== ""
+            ? root
+            : invocation.ctx.sessionManager.getSessionId();
+        return {
+            id,
+            profile: profile?.policy === "always" && !/[\\/~]/.test(profile.name) ? profile.name : undefined,
+            executablePath: config.trustedBrowserExecutablePath,
+        };
+    }
+    async runAdmitted(root, input) {
+        const cwd = this.browserCwd();
+        const error = getBrowserCwdError(cwd);
+        if (error !== undefined && error !== "") {
+            return browserExecutionFailure(new Error(error), this.controller.signal, "validation-error");
+        }
+        const selectedRoot = this.runtime.managed.active || this.runtime.managed.freshOrdinal > 0 ? undefined : root;
+        return withNativeSessionDefaults(input, { cwd, signal: this.controller.signal, root: selectedRoot }, (nativeInput) => this.runNative(nativeInput));
+    }
+    async runNative(input) {
+        const { runtime } = this;
+        const plan = buildExecutionPlan(input.toolArgs, {
+            freshSessionName: runtime.managed.name,
+            managedSessionActive: runtime.managed.active,
+            managedSessionName: runtime.managed.name,
+            managedSessionNamespace: runtime.managed.namespace,
+            sessionMode: "auto",
+        });
+        const sessionName = plan.sessionName ?? "default";
+        const namespace = plan.namespace === "" ? undefined : plan.namespace;
+        const key = getAgentBrowserSessionIdentityKey(sessionName, namespace);
+        const identity = {
+            usedImplicitSession: plan.usedImplicitSession,
+            sessionName,
+            namespace,
+            key,
+            owned: plan.managedSessionName !== undefined || runtime.managed.owned.has(key),
+        };
+        const run = () => this.runLocked(identity);
+        return shouldSerializeBrowserCommand(runtime.managed.owned, runtime.electron.ownedRecords, {
+            namespace,
+            explicitSessionName: sessionName,
+            managedSessionName: runtime.managed.name,
+        })
+            ? runtime.managedSessionExecutionQueue.run(run, this.controller.signal)
+            : runtime.callerOwnedSessionExecutionQueues.run(key, namespace, run, this.controller.signal);
+    }
+    async runLocked(identity) {
+        const socketDir = this.runtime.managed.owned.get(identity.key)?.socketDir;
+        const env = socketDir !== undefined && socketDir !== "" ? { PI_AGENT_BROWSER_SOCKET_DIR: socketDir } : {};
+        return withAgentBrowserProcessEnvironment(env, async () => {
+            const lease = await resolveBrowserExecutionIdentity({
+                sessionName: identity.sessionName,
+                namespace: identity.namespace,
+                ownedManagedSession: identity.owned,
+            });
+            return withBrowserExecutionLock({ identity: lease, deadline: this.deadline, signal: this.controller.signal }, (signal) => this.runCell(signal, identity));
+        });
+    }
+    async dispatch(inner, innerSignal, identity) {
+        if (this.journalFailed) {
+            throw new Error("Browser-state persistence failed. Inspect the current page before continuing in another tool call.");
+        }
+        const bound = bindBrowserCodeCall(inner, {
+            sessionName: identity.sessionName,
+            namespace: identity.namespace,
+        });
+        const args = [...bound.args];
+        if (identity.usedImplicitSession &&
+            !this.runtime.managed.active &&
+            this.runtime.managed.name === identity.sessionName &&
+            extractExplicitSessionName(inner.args) === undefined) {
+            args.splice(args.indexOf("--session"), 2);
+        }
+        const { toolCallId, ctx, branch } = this.invocation;
+        const result = await withAgentBrowserProcessEnvironment({ AGENT_BROWSER_SESSION: this.nativeEnvironment.AGENT_BROWSER_SESSION }, () => executeBrowserInvocation(this.runtime, createBrowserInvocation({
+            toolCallId,
+            params: {
+                args,
+                stdin: inner.stdin,
+                timeoutMs: Math.min(inner.timeoutMs ?? this.deadline - Date.now(), Math.max(1, this.deadline - Date.now())),
+            },
+            signal: innerSignal,
+            ctx,
+            nativeToolCallId: toolCallId,
+            capturedCwd: this.operationCwd,
+            modelVisible: false,
+            commandIndex: this.commandIndex++,
+            selectedBranch: branch,
+        })));
+        if (isRecord(result.details) && result.details.browserStatePersistence !== undefined) {
+            this.journalFailed = true;
+            throw new Error("The browser effect may already have happened and its finish could not be persisted. Inspect before continuing; dependent commands were stopped.");
+        }
+        return this.output.observe(result);
+    }
+    async runCell(signal, identity) {
+        const run = await runAgentBrowserScript({
+            code: this.invocation.params.code,
+            signal,
+            timeoutMs: Math.max(1, this.deadline - Date.now()),
+            emitImage: (image) => this.output.emitImage(image),
+            dispatch: (inner, innerSignal) => this.dispatch(inner, innerSignal, identity),
+        });
+        const result = await this.finish(run, identity);
+        const path = this.invocation.params.outputPath;
+        if (path === undefined || path === "") {
+            return result;
+        }
+        return this.runtime.artifacts.queue.run(() => this.writeOutput(result, path));
+    }
+    async finish(run, identity) {
+        const result = await this.output.finish(run, identity.sessionName, identity.namespace);
+        if (this.journalFailed && isRecord(result.details)) {
+            result.isError = true;
+            result.details.resultCategory = "failure";
+            result.details.failureCategory = "upstream-error";
+            result.details.error =
+                "Browser-state persistence failed. Dependent calls were stopped; inspect before continuing because already-dispatched effects may have happened.";
+        }
+        if (isRecord(result.details)) {
+            result.details.browserEventVersion = 1;
+        }
+        return result;
+    }
+    async writeOutput(result, outputPath) {
+        const error = getArtifactPreflightValidationError({
+            args: [],
+            cwd: this.operationCwd,
+            outputPath,
+            activeRecordingReservations: [...this.runtime.recordings.active.values()],
+        });
+        if (error !== undefined && error !== "") {
+            const failure = browserExecutionFailure(new Error(error), undefined, "validation-error");
+            return {
+                ...result,
+                isError: true,
+                content: [...failure.content, ...result.content],
+                details: {
+                    ...(isRecord(result.details) ? result.details : {}),
+                    ...(isRecord(failure.details) ? failure.details : {}),
+                },
+            };
+        }
+        return applyAgentBrowserOutputPath({
+            cwd: this.operationCwd,
+            outputPath,
+            preserveTextContent: true,
+            result,
+        });
+    }
+    async run() {
+        this.start();
+        const timer = setTimeout(() => this.controller.abort(new DOMException("Browser code deadline exceeded.", "TimeoutError")), Math.max(0, this.deadline - Date.now()));
+        try {
+            const input = this.prepare();
+            if (input.status === "invalid") {
+                return buildValidationFailureResult(input);
+            }
+            const root = this.nativeRoot();
+            const session = this.invocation.params.session;
+            const implicit = (session === undefined || session === "") &&
+                this.nativeEnvironment.AGENT_BROWSER_CONFIG === undefined;
+            return await (implicit
+                ? this.runtime.managedSessionExecutionQueue.run(() => this.runAdmitted(root, input), this.controller.signal)
+                : this.runAdmitted(root, input));
+        }
+        catch (error) {
+            return browserExecutionFailure(error, this.controller.signal);
+        }
+        finally {
+            clearTimeout(timer);
+            this.runtime.code.controllers.delete(this.controller);
+            this.invocation.signal?.removeEventListener("abort", this.abort);
+        }
+    }
+}
+export function executeCode(runtime, invocation) {
+    const prepared = codePreflight(runtime.pi, runtime.branch.replayError, invocation);
+    if ("failure" in prepared) {
+        return Promise.resolve(prepared.failure);
+    }
+    return new BrowserCodeExecution(runtime, invocation, prepared.cwd).run();
+}