pi-agent-browser-native 0.9.3 → 0.9.5

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

@@ -0,0 +1,142 @@
+import { inspectElectronLaunchStatus } from "../../electron/cleanup.js";
+import { commandExplicitlyTargetsAboutBlank, isAboutBlankSessionTabTarget, normalizeSessionTabTarget, } from "../../session-page-state.js";
+import { extractUpstreamCommandTokens } from "../../argv-descriptor.js";
+import { applyOpenResultTabCorrection, buildAboutBlankRecoveryHint, buildElectronPostCommandHealthDiagnostic, buildElectronSessionMismatch, collectSessionTabSelection, findElectronLaunchRecordForSession, shouldCorrectSessionTabAfterCommand, shouldInspectElectronPostCommandHealth, } from "./session-state.js";
+import { sleepMs } from "./diagnostics.js";
+function unexpectedBlankTarget(draft) {
+    const explicitBlank = draft.dispatchedCommands.some((step) => commandExplicitlyTargetsAboutBlank(extractUpstreamCommandTokens(step)));
+    return (draft.succeeded &&
+        !draft.tabTransition &&
+        !draft.destinationTransition &&
+        !explicitBlank &&
+        draft.nestedBatchClose === undefined &&
+        draft.input.prepared.priorSessionTabTarget !== undefined &&
+        !isAboutBlankSessionTabTarget(draft.input.prepared.priorSessionTabTarget) &&
+        isAboutBlankSessionTabTarget(draft.observedSessionTabTarget ?? draft.currentSessionTabTarget));
+}
+async function inspectBlankElectronMismatch(draft, observed) {
+    const { prepared, state } = draft.input;
+    const record = findElectronLaunchRecordForSession(prepared.executionPlan.sessionName, state.electronLaunchRecords, prepared.executionPlan.namespace);
+    const sessionName = prepared.executionPlan.sessionName;
+    if (!record || sessionName === undefined || sessionName.length === 0) {
+        return;
+    }
+    draft.electronStatusAfterCommand = await inspectElectronLaunchStatus(record);
+    draft.electronSessionMismatch = buildElectronSessionMismatch({
+        managedSession: { sessionName, title: observed?.title, url: observed?.url ?? "about:blank" },
+        record,
+        statusTargets: draft.electronStatusAfterCommand.targets,
+    });
+}
+export async function recoverUnexpectedBlankTarget(draft) {
+    const { prepared, cwd, signal } = draft.input;
+    draft.sessionTabCorrection = prepared.sessionTabCorrection;
+    const prior = prepared.priorSessionTabTarget;
+    if (!unexpectedBlankTarget(draft) || !prior) {
+        return;
+    }
+    const observed = draft.observedSessionTabTarget ?? draft.currentSessionTabTarget;
+    const correction = await collectSessionTabSelection({
+        cwd,
+        namespace: prepared.executionPlan.namespace,
+        sessionName: prepared.executionPlan.sessionName,
+        signal,
+        target: prior,
+    });
+    const applied = correction
+        ? await applyOpenResultTabCorrection({
+            correction,
+            cwd,
+            namespace: prepared.executionPlan.namespace,
+            sessionName: prepared.executionPlan.sessionName,
+            signal,
+        })
+        : undefined;
+    if (applied) {
+        draft.sessionTabCorrection = applied;
+        draft.currentSessionTabTarget = prior;
+    }
+    else {
+        draft.currentSessionTabTarget = observed ?? normalizeSessionTabTarget({ url: "about:blank" });
+    }
+    draft.aboutBlankSessionMismatch = {
+        activeUrl: "about:blank",
+        recoveryApplied: applied !== undefined,
+        recoveryHint: buildAboutBlankRecoveryHint(),
+        targetTitle: prior.title,
+        targetUrl: prior.url,
+    };
+    await inspectBlankElectronMismatch(draft, observed);
+}
+function needsPostCommandPinning(draft) {
+    const { prepared } = draft.input;
+    return (draft.succeeded &&
+        prepared.priorSessionTabTarget !== undefined &&
+        !draft.sessionTabCorrection &&
+        !draft.aboutBlankSessionMismatch &&
+        !commandExplicitlyTargetsAboutBlank(prepared.commandTokens) &&
+        shouldCorrectSessionTabAfterCommand({
+            command: prepared.executionPlan.commandInfo.command,
+            pinningRequired: prepared.sessionTabPinningReason !== undefined,
+            sessionName: prepared.executionPlan.sessionName,
+        }));
+}
+export async function pinPostCommandTarget(draft) {
+    const target = draft.observedSessionTabTarget;
+    if (!needsPostCommandPinning(draft) || !target) {
+        return;
+    }
+    const { prepared, cwd, signal } = draft.input;
+    const correction = await collectSessionTabSelection({
+        cwd,
+        namespace: prepared.executionPlan.namespace,
+        sessionName: prepared.executionPlan.sessionName,
+        signal,
+        target,
+    });
+    if (!correction) {
+        return;
+    }
+    const applied = await applyOpenResultTabCorrection({
+        correction,
+        cwd,
+        namespace: prepared.executionPlan.namespace,
+        sessionName: prepared.executionPlan.sessionName,
+        signal,
+    });
+    // The draft is per-call and is never passed to either helper; no external writer can install a correction here.
+    if (applied) {
+        draft.sessionTabCorrection = applied;
+    }
+}
+export async function inspectElectronHealth(draft) {
+    const { prepared, state } = draft.input;
+    draft.electronRecordForCommand = findElectronLaunchRecordForSession(prepared.executionPlan.sessionName, state.electronLaunchRecords, prepared.executionPlan.namespace);
+    const record = draft.electronRecordForCommand;
+    if (!draft.succeeded ||
+        !record ||
+        !shouldInspectElectronPostCommandHealth(prepared.executionPlan.commandInfo.command)) {
+        return;
+    }
+    draft.electronStatusAfterCommand ??= await inspectElectronLaunchStatus(record);
+    draft.electronPostCommandHealth = buildElectronPostCommandHealthDiagnostic({
+        command: prepared.executionPlan.commandInfo.command,
+        record,
+        status: draft.electronStatusAfterCommand,
+        target: draft.observedSessionTabTarget ?? draft.currentSessionTabTarget,
+    });
+    if (draft.electronPostCommandHealth &&
+        draft.electronPostCommandHealth.reason !== "process-dead") {
+        await sleepMs(draft.input.electronPostCommandStatusSettleMs);
+        draft.electronStatusAfterCommand = await inspectElectronLaunchStatus(record);
+        draft.electronPostCommandHealth = buildElectronPostCommandHealthDiagnostic({
+            command: prepared.executionPlan.commandInfo.command,
+            record,
+            status: draft.electronStatusAfterCommand,
+            target: draft.observedSessionTabTarget ?? draft.currentSessionTabTarget,
+        });
+    }
+    if (draft.electronPostCommandHealth) {
+        draft.succeeded = false;
+    }
+}