pi-agent-browser-native 0.9.4 → 0.9.6

package/dist/extensions/agent-browser/lib/orchestration/browser-run/process-output-lifecycle-phase.js

@@ -1,115 +0,0 @@
-import { observeFinalHelperConfirmation } from "./process-output-confirmation.js";
-import { reconcileOutputPinning } from "./process-output-refs.js";
-import { resolveManagedCloseTarget, inspectFailedFreshLaunch, applyManagedTransition, retireReplacedSession, } from "./process-output-managed.js";
-import { reconcileElectronHandoff } from "./process-output-electron.js";
-import { resolveOutputError } from "./process-output-presentation.js";
-import { commitObservedLifecycle } from "./process-output-receipts.js";
-function createLifecycleOutputPhase(input, native, page, ownership) {
-    return {
-        input,
-        aboutBlankSessionMismatch: page.aboutBlankSessionMismatch,
-        artifactManifest: native.artifactManifest,
-        closeAllApplied: native.closeAllApplied,
-        closeCommandSucceeded: false,
-        commandClosesSession: false,
-        confirmationFromHelper: page.confirmationFromHelper,
-        currentRefSnapshot: page.currentRefSnapshot,
-        currentRefSnapshotInvalidation: page.currentRefSnapshotInvalidation,
-        currentSessionTabTarget: page.currentSessionTabTarget,
-        directClose: page.directClose,
-        electronFailedConnectCleanup: undefined,
-        electronHandoff: undefined,
-        electronLaunchRecord: undefined,
-        errorText: undefined,
-        freshSessionOrdinal: ownership.freshSessionOrdinal,
-        managedCloseSessionName: undefined,
-        managedSessionActive: ownership.managedSessionActive,
-        managedSessionCompatibilityWorkaround: ownership.managedSessionCompatibilityWorkaround,
-        managedSessionCwd: ownership.managedSessionCwd,
-        managedSessionHeadedAutosaveDisabled: ownership.managedSessionHeadedAutosaveDisabled,
-        managedSessionHeadedAutosaveInterval: ownership.managedSessionHeadedAutosaveInterval,
-        managedSessionName: ownership.managedSessionName,
-        managedSessionNamespace: ownership.managedSessionNamespace,
-        managedSessionOutcome: undefined,
-        managedTransitionSucceeded: false,
-        nestedBatchClosed: page.nestedBatchClosed,
-        nestedBatchRemainsActive: native.nestedBatchRemainsActive,
-        networkRoutesBySession: page.networkRoutesBySession,
-        observedSessionTabTarget: page.observedSessionTabTarget,
-        openResultTabCorrection: page.openResultTabCorrection,
-        parseError: native.parseError,
-        parseSucceeded: native.parseSucceeded,
-        plainTextInspection: native.plainTextInspection,
-        plainTextUpgrade: native.plainTextUpgrade,
-        presentationEnvelope: page.presentationEnvelope,
-        priorManagedSessionActive: false,
-        priorManagedSessionCwd: "",
-        priorManagedSessionHeadedAutosaveInterval: undefined,
-        priorManagedSessionName: "",
-        priorManagedSessionNamespace: undefined,
-        processSucceeded: page.processSucceeded,
-        rawCloseStatePath: native.rawCloseStatePath,
-        readConfirmationEvent: page.readConfirmationEvent,
-        recordingStopRecovery: page.recordingStopRecovery,
-        replacedManagedSessionName: undefined,
-        resultHeadedManagedAutosaveDisabled: false,
-        resultHeadedManagedAutosaveInterval: undefined,
-        sessionStateKey: page.sessionStateKey,
-        sessionTabCorrection: page.sessionTabCorrection,
-        succeeded: page.succeeded,
-        textOutput: page.textOutput,
-        timeoutPartialProgress: page.timeoutPartialProgress,
-    };
-}
-export async function commitLifecycleEffects(input, native, page, ownership) {
-    const draft = createLifecycleOutputPhase(input, native, page, ownership);
-    resolveManagedCloseTarget(draft);
-    await inspectFailedFreshLaunch(draft);
-    applyManagedTransition(draft);
-    reconcileOutputPinning(draft);
-    await retireReplacedSession(draft);
-    await reconcileElectronHandoff(draft);
-    resolveOutputError(draft);
-    observeFinalHelperConfirmation(draft);
-    commitObservedLifecycle(draft);
-    return {
-        aboutBlankSessionMismatch: draft.aboutBlankSessionMismatch,
-        artifactManifest: draft.artifactManifest,
-        closeAllApplied: draft.closeAllApplied,
-        commandClosesSession: draft.commandClosesSession,
-        confirmationFromHelper: draft.confirmationFromHelper,
-        currentRefSnapshot: draft.currentRefSnapshot,
-        currentRefSnapshotInvalidation: draft.currentRefSnapshotInvalidation,
-        currentSessionTabTarget: draft.currentSessionTabTarget,
-        electronFailedConnectCleanup: draft.electronFailedConnectCleanup,
-        electronHandoff: draft.electronHandoff,
-        electronLaunchRecord: draft.electronLaunchRecord,
-        errorText: draft.errorText,
-        freshSessionOrdinal: draft.freshSessionOrdinal,
-        managedSessionActive: draft.managedSessionActive,
-        managedSessionCompatibilityWorkaround: draft.managedSessionCompatibilityWorkaround,
-        managedSessionCwd: draft.managedSessionCwd,
-        managedSessionHeadedAutosaveDisabled: draft.managedSessionHeadedAutosaveDisabled,
-        managedSessionHeadedAutosaveInterval: draft.managedSessionHeadedAutosaveInterval,
-        managedSessionName: draft.managedSessionName,
-        managedSessionNamespace: draft.managedSessionNamespace,
-        managedSessionOutcome: draft.managedSessionOutcome,
-        networkRoutesBySession: draft.networkRoutesBySession,
-        openResultTabCorrection: draft.openResultTabCorrection,
-        parseError: draft.parseError,
-        parseSucceeded: draft.parseSucceeded,
-        plainTextInspection: draft.plainTextInspection,
-        plainTextUpgrade: draft.plainTextUpgrade,
-        presentationEnvelope: draft.presentationEnvelope,
-        processSucceeded: draft.processSucceeded,
-        readConfirmationEvent: draft.readConfirmationEvent,
-        recordingStopRecovery: draft.recordingStopRecovery,
-        resultHeadedManagedAutosaveDisabled: draft.resultHeadedManagedAutosaveDisabled,
-        resultHeadedManagedAutosaveInterval: draft.resultHeadedManagedAutosaveInterval,
-        sessionStateKey: draft.sessionStateKey,
-        sessionTabCorrection: draft.sessionTabCorrection,
-        succeeded: draft.succeeded,
-        textOutput: draft.textOutput,
-        timeoutPartialProgress: draft.timeoutPartialProgress,
-    };
-}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/process-output-lifecycle.js

@@ -1,256 +0,0 @@
-import { isStringArray } from "../../results/presentation/content.js";
-import { isBrowserIndependentRead } from "../../command-policy.js";
-import { deleteIdentityKeysInNamespace, isAgentBrowserSessionIdentityKeyInNamespace, } from "../../argv-grammar.js";
-import { batchHasSuccessfulCloseAll, getSuccessfulBatchCloseLifecycle, } from "../../batch-lifecycle.js";
-import { isCloseAllCommand, isPageMutationCommand, isWindowOrDiffPageTransitionCommand, } from "../../command-taxonomy.js";
-import { detectConfirmationRequired } from "../../results/confirmation.js";
-import { isRecord } from "../../parsing.js";
-import { getAgentBrowserProcessEnvironment } from "../../process-environment.js";
-import { isBrowserIndependentConfirmation } from "../../read-confirmation.js";
-import { extractUpstreamCommandTokens } from "../../argv-descriptor.js";
-import { commandChoosesSessionTabTarget, getSessionContextKey, updateTraceOwnerState, nativePolicyDefinitelyUnestablished, } from "./session-state.js";
-import { redactExactSensitiveValue } from "./final-result.js";
-export function observeCloseLifecycle(draft) {
-    draft.destinationTransition = draft.dispatchedCommands.some((step) => {
-        const [command, subcommand] = extractUpstreamCommandTokens(step);
-        return isWindowOrDiffPageTransitionCommand(command, subcommand);
-    });
-    draft.nestedBatchClose =
-        draft.input.prepared.executionPlan.commandInfo.command === "batch"
-            ? getSuccessfulBatchCloseLifecycle(draft.presentationEnvelope?.data, draft.batchCommandSteps)
-            : undefined;
-    draft.nestedBatchClosed = draft.nestedBatchClose?.endsClosed === true;
-    draft.nestedBatchRemainsActive = draft.nestedBatchClose?.endsClosed === false;
-    draft.nestedBatchClosesAll =
-        draft.input.prepared.executionPlan.commandInfo.command === "batch" &&
-            batchHasSuccessfulCloseAll(draft.presentationEnvelope?.data, draft.batchCommandSteps);
-    draft.directCloseAllRequested = isCloseAllCommand(extractUpstreamCommandTokens(draft.input.prepared.commandTokens));
-    observeCloseStatePath(draft);
-}
-export function redactNativeEnvelope(draft) {
-    if (draft.presentationEnvelope && draft.input.prepared.exactSensitiveValues.length > 0) {
-        const redacted = redactExactSensitiveValue(draft.presentationEnvelope, draft.input.prepared.exactSensitiveValues);
-        if (!isRecord(redacted) || typeof redacted.success !== "boolean") {
-            throw new Error("Native envelope redaction did not preserve its success field.");
-        }
-        draft.presentationEnvelope = { ...redacted, success: redacted.success };
-    }
-    draft.parseFailureOutput =
-        draft.parseError !== undefined &&
-            draft.parseError.length > 0 &&
-            draft.input.processResult.stdoutSpillPath !== undefined &&
-            draft.input.processResult.stdoutSpillPath.length > 0
-            ? {
-                fullOutputUnavailable: "Malformed upstream output was discarded because it may contain sensitive browser data.",
-            }
-            : {};
-}
-export function classifyNativeExecution(draft) {
-    observeNativePolicyExecution(draft);
-    classifyNativeEnvelope(draft);
-}
-export function observeInterruptedMutation(draft) {
-    draft.unobservedMutation =
-        draft.input.processResult.agentBrowserStarted &&
-            !draft.plainTextInspection &&
-            (draft.input.processResult.aborted ||
-                draft.input.processResult.timedOut ||
-                !draft.parseSucceeded ||
-                draft.presentationEnvelope === undefined) &&
-            (draft.input.prepared.executionPlan.commandInfo.command === "batch"
-                ? draft.batchCommandSteps
-                : [draft.input.prepared.commandTokens]).some((step) => {
-                const action = step[0] === "find" ? (step[step[1] === "nth" ? 4 : 3] ?? "click") : step[0];
-                return isPageMutationCommand(action, step[1]);
-            });
-    draft.sessionStateKey = getSessionContextKey(draft.input.prepared.executionPlan.sessionName, draft.input.prepared.executionPlan.namespace);
-    draft.closeAllApplied =
-        draft.nestedBatchClosesAll || (draft.directCloseAllRequested && draft.succeeded);
-}
-export function applyCloseAndTraceLifecycle(draft) {
-    clearReopenedTabLatch(draft);
-    applyOutputCloseScope(draft);
-    restoreConfirmActionsAfterRelaunch(draft);
-    foldTraceOwnership(draft);
-}
-function nativePrimitiveErrorMessage(error) {
-    if (typeof error === "number") {
-        return error !== 0 && !Number.isNaN(error) ? String(error) : undefined;
-    }
-    return error === true ? "true" : undefined;
-}
-function getEnvelopeErrorString(envelope) {
-    if (!envelope) {
-        return;
-    }
-    const error = envelope.error;
-    if (typeof error === "string") {
-        return error.length > 0 ? error : undefined;
-    }
-    if (isRecord(error) && typeof error.message === "string") {
-        return error.message;
-    }
-    // Arbitrary browser error objects may contain credentials and have no useful public message.
-    return nativePrimitiveErrorMessage(error);
-}
-function isStreamEnableAlreadyEnabledNoop(options) {
-    if (!options.processSucceeded ||
-        options.command !== "stream" ||
-        options.subcommand !== "enable" ||
-        options.envelope?.success !== false) {
-        return false;
-    }
-    const message = (getEnvelopeErrorString(options.envelope) ?? "")
-        .trim()
-        .replace(/[.!]+$/, "")
-        .toLowerCase();
-    return (message === "streaming is already enabled for this session" ||
-        message === "streaming is already enabled" ||
-        message === "stream already enabled");
-}
-function observeCloseStatePath(draft) {
-    const directCloseData = draft.confirmedData ?? draft.presentationEnvelope?.data;
-    draft.rawCloseStatePath =
-        draft.directClose && isRecord(directCloseData) && typeof directCloseData.statePath === "string"
-            ? directCloseData.statePath
-            : draft.nestedBatchClose?.statePath;
-}
-function classifyNativeEnvelope(draft) {
-    observeNativeConfirmationPolicy(draft);
-    draft.processSucceeded =
-        !draft.input.processResult.timedOut &&
-            !draft.input.processResult.aborted &&
-            !draft.input.processResult.spawnError &&
-            draft.input.processResult.exitCode === 0;
-    draft.plainTextInspection =
-        draft.input.prepared.executionPlan.plainTextInspection && draft.processSucceeded;
-    draft.parseSucceeded = draft.plainTextInspection || draft.parseError === undefined;
-    normalizeStreamEnableNoop(draft);
-    resolveEnvelopeSuccess(draft);
-    draft.inspectionText = draft.plainTextInspection
-        ? draft.input.processResult.stdout.trim()
-        : undefined;
-}
-function observeNativePolicyExecution(draft) {
-    draft.browserIndependentRead =
-        isBrowserIndependentConfirmation(draft.input.prepared.readConfirmation) ||
-            isBrowserIndependentRead(draft.input.prepared.commandTokens, draft.input.prepared.runtimeToolStdin);
-    draft.nativeCommandMayHaveExecuted = !nativePolicyDefinitelyUnestablished(draft.input.processResult, draft.parsed.envelope, draft.input.prepared.commandTokens);
-}
-function observeNativeConfirmationPolicy(draft) {
-    if (draft.input.state.confirmationPolicyMayBeEstablished !== true) {
-        draft.input.state.confirmationPolicyMayBeEstablished = draft.nativeCommandMayHaveExecuted;
-    }
-}
-function normalizeStreamEnableNoop(draft) {
-    if (isStreamEnableAlreadyEnabledNoop({
-        command: draft.input.prepared.executionPlan.commandInfo.command,
-        envelope: draft.presentationEnvelope,
-        processSucceeded: draft.processSucceeded,
-        subcommand: draft.input.prepared.executionPlan.commandInfo.subcommand,
-    })) {
-        draft.presentationEnvelope = {
-            success: true,
-            data: {
-                alreadyEnabled: true,
-                enabled: true,
-                message: getEnvelopeErrorString(draft.presentationEnvelope) ?? "Stream already enabled",
-            },
-        };
-    }
-}
-function clearReopenedTabLatch(draft) {
-    if (draft.sessionStateKey !== undefined &&
-        draft.sessionStateKey.length > 0 &&
-        draft.input.processResult.agentBrowserStarted &&
-        draft.input.state.sessionPageState.get(draft.sessionStateKey).tabReopenPending === true) {
-        if (draft.dispatchedCommands.some(commandChoosesSessionTabTarget)) {
-            draft.input.state.sessionPageState.setTabReopenPending({
-                pending: false,
-                sessionName: draft.sessionStateKey,
-                update: draft.input.sessionPageStateUpdate,
-            });
-        }
-    }
-}
-function applyOutputCloseScope(draft) {
-    if (draft.closeAllApplied) {
-        pruneNamespaceNetworkRoutes(draft);
-        deleteIdentityKeysInNamespace(draft.input.state.attachedSessionKeys, draft.input.prepared.executionPlan.namespace);
-        deleteIdentityKeysInNamespace(draft.input.state.traceOwners, draft.input.prepared.executionPlan.namespace);
-        draft.input.state.sessionPageState.clearNamespace(draft.input.prepared.executionPlan.namespace);
-        const retainedSessionKey = draft.nestedBatchRemainsActive ? draft.sessionStateKey : undefined;
-        for (const [key, owner] of draft.input.state.ownedManagedSessions) {
-            if (!isAgentBrowserSessionIdentityKeyInNamespace(key, draft.input.prepared.executionPlan.namespace) ||
-                key === retainedSessionKey) {
-                continue;
-            }
-            draft.input.state.closedManagedSessionNames.add(key);
-            draft.input.state.managedSessionRestoreState.clear(owner.sessionName, owner.namespace);
-        }
-    }
-    else if (draft.nestedBatchClose &&
-        draft.sessionStateKey !== undefined &&
-        draft.sessionStateKey.length > 0) {
-        const routes = new Map(draft.networkRoutesBySession);
-        routes.delete(draft.sessionStateKey);
-        draft.networkRoutesBySession = routes;
-        draft.input.state.sessionPageState.clearSession(draft.sessionStateKey);
-    }
-}
-function restoreConfirmActionsAfterRelaunch(draft) {
-    if (draft.sessionStateKey !== undefined &&
-        draft.sessionStateKey.length > 0 &&
-        draft.nestedBatchRemainsActive) {
-        const confirmActions = getAgentBrowserProcessEnvironment().AGENT_BROWSER_CONFIRM_ACTIONS;
-        if (confirmActions !== undefined) {
-            draft.input.state.sessionPageState.setConfirmActions(draft.sessionStateKey, confirmActions);
-        }
-    }
-}
-function foldTraceOwnership(draft) {
-    if (draft.input.prepared.executionPlan.commandInfo.command === "batch" &&
-        Array.isArray(draft.presentationEnvelope?.data)) {
-        for (const [index, row] of draft.presentationEnvelope.data.entries()) {
-            foldBatchTraceRow(draft, row, index);
-        }
-    }
-    else {
-        updateTraceOwnerState({
-            command: draft.directClose ? "close" : draft.input.prepared.executionPlan.commandInfo.command,
-            sessionName: draft.sessionStateKey,
-            subcommand: draft.input.prepared.executionPlan.commandInfo.subcommand,
-            succeeded: draft.succeeded,
-            traceOwners: draft.input.state.traceOwners,
-        });
-    }
-}
-function resolveEnvelopeSuccess(draft) {
-    const envelopeSuccess = draft.plainTextInspection
-        ? true
-        : draft.presentationEnvelope?.success !== false &&
-            !detectConfirmationRequired(draft.presentationEnvelope?.data);
-    draft.succeeded =
-        (draft.processSucceeded && draft.parseSucceeded && envelopeSuccess) ||
-            draft.recordingStopRecovery?.recovery.healed === true;
-}
-function foldBatchTraceRow(draft, row, index) {
-    if (!isRecord(row)) {
-        return;
-    }
-    const rowCommand = isStringArray(row.command) ? row.command : draft.batchCommandSteps.at(index);
-    if (!rowCommand) {
-        return;
-    }
-    const [command, subcommand] = extractUpstreamCommandTokens(rowCommand);
-    updateTraceOwnerState({
-        command,
-        sessionName: draft.sessionStateKey,
-        subcommand,
-        succeeded: row.success === true && !detectConfirmationRequired(row.result),
-        traceOwners: draft.input.state.traceOwners,
-    });
-}
-function pruneNamespaceNetworkRoutes(draft) {
-    draft.networkRoutesBySession = new Map([...draft.networkRoutesBySession].filter(([key]) => !isAgentBrowserSessionIdentityKeyInNamespace(key, draft.input.prepared.executionPlan.namespace)));
-}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/process-output-managed-contracts.js

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

package/dist/extensions/agent-browser/lib/orchestration/browser-run/process-output-managed.js

@@ -1,256 +0,0 @@
-import { createFreshSessionName, resolveManagedSessionState, } from "../../runtime-session-identity.js";
-import { closeManagedSession, inspectManagedSessionDaemon, } from "./managed-session-daemon-policy.js";
-import { getAgentBrowserSessionIdentityKey, isAgentBrowserSessionIdentityKeyInNamespace, } from "../../argv-grammar.js";
-import { isOpenNavigationCommand } from "../../command-taxonomy.js";
-import { isRecord } from "../../parsing.js";
-import { pruneOwnedManagedSessionRestoreSnapshots } from "../../managed-session-restore.js";
-import { isManagedSessionRestoreKey } from "../../managed-session-storage.js";
-import { buildManagedSessionOutcome, getSessionContextKey } from "./session-state.js";
-function closeAllClosesManagedSession(draft) {
-    const priorKey = getSessionContextKey(draft.priorManagedSessionName, draft.priorManagedSessionNamespace) ??
-        draft.priorManagedSessionName;
-    const targetsPrior = draft.closeAllApplied &&
-        draft.priorManagedSessionActive &&
-        isAgentBrowserSessionIdentityKeyInNamespace(priorKey, draft.input.prepared.executionPlan.namespace);
-    const retainsPrior = targetsPrior && draft.nestedBatchRemainsActive && draft.sessionStateKey === priorKey;
-    return targetsPrior && !retainsPrior;
-}
-function managedCloseTarget(draft, closesPrior) {
-    if (closesPrior) {
-        return draft.priorManagedSessionName;
-    }
-    const { executionPlan } = draft.input.prepared;
-    if (draft.closeCommandSucceeded &&
-        executionPlan.sessionName === draft.priorManagedSessionName &&
-        executionPlan.namespace === draft.priorManagedSessionNamespace) {
-        return executionPlan.sessionName;
-    }
-    return executionPlan.managedSessionName;
-}
-export function resolveManagedCloseTarget(draft) {
-    draft.priorManagedSessionActive = draft.managedSessionActive;
-    draft.priorManagedSessionCwd = draft.managedSessionCwd;
-    draft.priorManagedSessionHeadedAutosaveInterval = draft.managedSessionHeadedAutosaveInterval;
-    draft.priorManagedSessionName = draft.managedSessionName;
-    draft.priorManagedSessionNamespace = draft.managedSessionNamespace;
-    const closesPrior = closeAllClosesManagedSession(draft);
-    draft.commandClosesSession = draft.directClose || draft.nestedBatchClosed || closesPrior;
-    draft.closeCommandSucceeded =
-        (draft.directClose && draft.succeeded) || draft.nestedBatchClosed || closesPrior;
-    draft.managedCloseSessionName = managedCloseTarget(draft, closesPrior);
-}
-function failedBatchEstablishedBrowser(draft) {
-    const { prepared } = draft.input;
-    return (!draft.succeeded &&
-        draft.processSucceeded &&
-        draft.parseSucceeded &&
-        prepared.sessionMode === "fresh" &&
-        prepared.executionPlan.commandInfo.command === "batch" &&
-        batchStartedManagedBrowser(draft.presentationEnvelope?.data));
-}
-function timedOutBatchEstablishedPage(draft) {
-    const { prepared, processResult } = draft.input;
-    return (!draft.succeeded &&
-        processResult.timedOut &&
-        prepared.sessionMode === "fresh" &&
-        prepared.executionPlan.commandInfo.command === "batch" &&
-        draft.timeoutPartialProgress?.liveUrlRecovered === true);
-}
-function failedFreshSessionMayHaveStarted(draft) {
-    const { prepared, processResult } = draft.input;
-    const spawnMayHaveRun = processResult.agentBrowserStarted ||
-        (!processResult.aborted && processResult.spawnError === undefined);
-    return (!draft.succeeded &&
-        spawnMayHaveRun &&
-        prepared.sessionMode === "fresh" &&
-        prepared.executionPlan.managedSessionName === prepared.executionPlan.sessionName);
-}
-async function inspectFailedFreshDaemon(draft) {
-    const { prepared, cwd, implicitSessionCloseTimeoutMs } = draft.input;
-    const sessionName = prepared.executionPlan.sessionName;
-    if (!failedFreshSessionMayHaveStarted(draft) ||
-        sessionName === undefined ||
-        sessionName.length === 0) {
-        return;
-    }
-    const daemon = await inspectManagedSessionDaemon({
-        cwd,
-        headedManagedAutosaveInterval: prepared.ownedManagedSessionContext?.headedManagedAutosaveInterval,
-        namespace: prepared.executionPlan.namespace,
-        sessionName,
-        timeoutMs: Math.min(implicitSessionCloseTimeoutMs, 2_000),
-    });
-    if (daemon.status === "active") {
-        draft.input.state.managedSessionRestoreState.recordDaemonRestoreKey(prepared.executionPlan.sessionName, prepared.executionPlan.namespace, daemon.restoreKey);
-    }
-    return daemon;
-}
-export async function inspectFailedFreshLaunch(draft) {
-    const batchStarted = failedBatchEstablishedBrowser(draft);
-    const timeoutPage = timedOutBatchEstablishedPage(draft);
-    const daemon = await inspectFailedFreshDaemon(draft);
-    // Only an explicitly inactive daemon proves a started fresh command did not establish ownership.
-    const failedFreshStarted = daemon !== undefined && daemon.status !== "inactive";
-    draft.managedTransitionSucceeded =
-        draft.succeeded ||
-            draft.nestedBatchClosed ||
-            draft.nestedBatchRemainsActive ||
-            batchStarted ||
-            timeoutPage ||
-            failedFreshStarted;
-}
-function executionTargetsManagedSession(draft) {
-    const { executionPlan } = draft.input.prepared;
-    return (executionPlan.sessionName !== undefined &&
-        executionPlan.sessionName.length > 0 &&
-        getAgentBrowserSessionIdentityKey(executionPlan.sessionName, executionPlan.namespace) ===
-            getAgentBrowserSessionIdentityKey(draft.managedSessionName, draft.managedSessionNamespace));
-}
-function applyManagedLaunchPolicy(draft) {
-    if (!draft.managedSessionActive) {
-        draft.managedSessionCompatibilityWorkaround = undefined;
-        draft.managedSessionHeadedAutosaveDisabled = false;
-        draft.managedSessionHeadedAutosaveInterval = undefined;
-        return;
-    }
-    const { prepared } = draft.input;
-    const owned = prepared.ownedManagedSessionContext;
-    if (!draft.managedTransitionSucceeded ||
-        !executionTargetsManagedSession(draft) ||
-        !owned ||
-        owned.reuseOnly === true) {
-        return;
-    }
-    draft.managedSessionCompatibilityWorkaround = prepared.compatibilityWorkaround;
-    draft.managedSessionHeadedAutosaveDisabled = owned.headedManagedAutosaveDisabled === true;
-    draft.managedSessionHeadedAutosaveInterval = owned.headedManagedAutosaveInterval;
-}
-function retireManagedRestorePool(draft) {
-    if (!draft.closeCommandSucceeded ||
-        draft.managedCloseSessionName !== draft.priorManagedSessionName ||
-        draft.managedSessionActive) {
-        return;
-    }
-    const { managedSessionRestoreState } = draft.input.state;
-    const daemonKey = managedSessionRestoreState.getDaemonRestoreKey(draft.managedCloseSessionName, draft.priorManagedSessionNamespace);
-    const ownedKey = !managedSessionRestoreState.isDisabled(draft.managedCloseSessionName, draft.priorManagedSessionNamespace) && isManagedSessionRestoreKey(daemonKey)
-        ? daemonKey
-        : null;
-    managedSessionRestoreState.clear(draft.managedCloseSessionName, draft.priorManagedSessionNamespace);
-    pruneOwnedManagedSessionRestoreSnapshots({
-        cwd: draft.input.cwd,
-        namespace: draft.priorManagedSessionNamespace,
-        restoreKey: ownedKey,
-        statePath: draft.rawCloseStatePath,
-    });
-    draft.freshSessionOrdinal += 1;
-    draft.managedSessionName = createFreshSessionName(draft.input.state.managedSessionBaseName, draft.input.state.ephemeralSessionSeed, draft.freshSessionOrdinal);
-    draft.managedSessionNamespace = undefined;
-}
-function updateManagedLaunchDirectory(draft) {
-    const sessionName = draft.input.prepared.executionPlan.managedSessionName;
-    if (sessionName === undefined ||
-        sessionName.length === 0 ||
-        !draft.managedTransitionSucceeded ||
-        !draft.managedSessionActive) {
-        return;
-    }
-    if (!draft.priorManagedSessionActive ||
-        (draft.replacedManagedSessionName !== undefined && draft.replacedManagedSessionName.length > 0)) {
-        draft.managedSessionCwd = draft.input.cwd;
-    }
-    draft.managedSessionNamespace = draft.input.prepared.executionPlan.namespace;
-}
-export function applyManagedTransition(draft) {
-    const { prepared, state } = draft.input;
-    const command = draft.commandClosesSession ? "close" : prepared.executionPlan.commandInfo.command;
-    const next = resolveManagedSessionState({
-        command,
-        managedSessionName: draft.managedCloseSessionName,
-        managedSessionNamespace: prepared.executionPlan.namespace,
-        priorActive: draft.priorManagedSessionActive,
-        priorNamespace: draft.priorManagedSessionNamespace,
-        priorSessionName: draft.priorManagedSessionName,
-        succeeded: draft.managedTransitionSucceeded,
-    });
-    if (!draft.managedTransitionSucceeded &&
-        prepared.sessionMode === "fresh" &&
-        prepared.executionPlan.managedSessionName !== undefined &&
-        prepared.executionPlan.managedSessionName.length > 0) {
-        state.managedSessionRestoreState.clear(prepared.executionPlan.managedSessionName, prepared.executionPlan.namespace);
-    }
-    draft.replacedManagedSessionName = next.replacedSessionName;
-    draft.managedSessionActive = next.active;
-    draft.managedSessionName = next.sessionName;
-    draft.managedSessionNamespace = next.namespace;
-    applyManagedLaunchPolicy(draft);
-    retireManagedRestorePool(draft);
-    draft.managedSessionOutcome = buildManagedSessionOutcome({
-        activeAfter: draft.managedSessionActive,
-        activeBefore: draft.priorManagedSessionActive,
-        attemptedSessionName: draft.managedCloseSessionName,
-        command,
-        currentSessionName: draft.managedSessionName,
-        currentSessionNamespace: draft.managedSessionNamespace,
-        previousSessionName: draft.priorManagedSessionName,
-        replacedSessionName: draft.replacedManagedSessionName,
-        replacedSessionNamespace: draft.priorManagedSessionNamespace,
-        sessionMode: prepared.sessionMode,
-        succeeded: draft.managedTransitionSucceeded,
-    });
-    updateManagedLaunchDirectory(draft);
-}
-export async function retireReplacedSession(draft) {
-    const sessionName = draft.replacedManagedSessionName;
-    if (sessionName === undefined || sessionName.length === 0) {
-        return;
-    }
-    const sessionKey = getSessionContextKey(sessionName, draft.priorManagedSessionNamespace) ?? sessionName;
-    const { state } = draft.input;
-    const closeError = await closeManagedSession({
-        confirmActions: state.sessionPageState.get(sessionKey).confirmActions ??
-            process.env.AGENT_BROWSER_CONFIRM_ACTIONS,
-        cwd: draft.priorManagedSessionCwd,
-        headedManagedAutosaveInterval: draft.priorManagedSessionHeadedAutosaveInterval,
-        namespace: draft.priorManagedSessionNamespace,
-        preserveAttachedBrowserSession: state.attachedSessionKeys.has(sessionKey),
-        restoreState: state.managedSessionRestoreState,
-        sessionName,
-        socketDir: state.ownedManagedSessions.get(sessionKey)?.socketDir,
-        timeoutMs: draft.input.implicitSessionCloseTimeoutMs,
-    });
-    const closed = (closeError ?? "").length === 0;
-    if (draft.managedSessionOutcome) {
-        draft.managedSessionOutcome = {
-            ...draft.managedSessionOutcome,
-            replacedSessionClosed: closed,
-            summary: closed
-                ? draft.managedSessionOutcome.summary
-                : `${draft.managedSessionOutcome.summary} Previous session ${sessionName} remains wrapper-owned because automatic close failed; retry an explicit close.`,
-        };
-    }
-    if (!closed) {
-        return;
-    }
-    const routes = new Map(draft.networkRoutesBySession);
-    routes.delete(sessionKey);
-    draft.networkRoutesBySession = routes;
-    state.sessionPageState.clearSession(sessionKey);
-    state.attachedSessionKeys.delete(sessionKey);
-    state.closedManagedSessionNames.add(sessionKey);
-}
-function batchStartedManagedBrowser(data) {
-    if (!Array.isArray(data)) {
-        return false;
-    }
-    return data.some((entry) => {
-        if (!isRecord(entry) || entry.success !== true || !Array.isArray(entry.command)) {
-            return false;
-        }
-        const command = typeof entry.command[0] === "string" ? entry.command[0] : undefined;
-        return (command === "connect" ||
-            command === "goto" ||
-            command === "navigate" ||
-            isOpenNavigationCommand(command));
-    });
-}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/process-output-native-phase-contracts.js

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