pi-agent-browser-native 0.9.4 → 0.9.6

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

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

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

@@ -1,25 +0,0 @@
-import { rm } from "node:fs/promises";
-import { captureBrowserOutputOwnership } from "./process-output-ownership.js";
-import { observeNativeEffects } from "./process-output-native-phase.js";
-import { observePageEffects } from "./process-output-page-phase.js";
-import { commitLifecycleEffects } from "./process-output-lifecycle-phase.js";
-import { publishOutputEffects } from "./process-output-publication-phase.js";
-import { buildOutputResult } from "./process-output-publication.js";
-export async function processBrowserOutput(input) {
-    const ownership = captureBrowserOutputOwnership(input);
-    try {
-        const native = await observeNativeEffects(input, ownership);
-        const page = await observePageEffects(input, native);
-        const lifecycle = await commitLifecycleEffects(input, native, page, ownership);
-        const { publication, recovery } = await publishOutputEffects(input, native, page, lifecycle);
-        return buildOutputResult({ input, native, page, lifecycle, publication }, recovery);
-    }
-    finally {
-        const path = input.processResult.stdoutSpillPath;
-        if (path !== undefined && path.length > 0) {
-            await rm(path, { force: true }).catch(() => {
-                // This raw spool is disposable and may already be removed; cleanup must not replace the native outcome or a publication failure.
-            });
-        }
-    }
-}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/prompt-guards.js

@@ -1,50 +0,0 @@
-import { isAbsolute, resolve } from "node:path";
-import { isCloseCommand } from "../../command-taxonomy.js";
-import { executableExistsOnPath } from "../../executable-path.js";
-function resolveArtifactPath(cwd, path) {
-    return isAbsolute(path) ? path : resolve(cwd, path);
-}
-function manifestContainsArtifact(manifest, cwd, artifact) {
-    if (!manifest) {
-        return false;
-    }
-    const requestedAbsolutePath = resolveArtifactPath(cwd, artifact.path);
-    const expectedKind = artifact.kind === "screenshot" ? "image" : "video";
-    return manifest.entries.some((entry) => {
-        const entryAbsolutePath = entry.absolutePath ?? resolveArtifactPath(cwd, entry.path);
-        return (entry.storageScope === "explicit-path" &&
-            entry.kind === expectedKind &&
-            entryAbsolutePath === requestedAbsolutePath &&
-            entry.retentionState === "live" &&
-            entry.exists === true);
-    });
-}
-async function isArtifactRequired(artifact) {
-    if (artifact.required) {
-        return true;
-    }
-    return artifact.kind === "recording" && (await executableExistsOnPath("ffmpeg"));
-}
-export async function findRequestedArtifactCloseViolation(options) {
-    if (!isCloseCommand(options.command)) {
-        return undefined;
-    }
-    const requirements = await Promise.all(options.promptPolicy.requestedArtifacts.map(async (artifact) => ({
-        artifact,
-        required: await isArtifactRequired(artifact),
-    })));
-    const missingArtifacts = requirements
-        .filter(({ artifact, required }) => required && !manifestContainsArtifact(options.artifactManifest, options.cwd, artifact))
-        .map(({ artifact }) => artifact);
-    if (missingArtifacts.length === 0) {
-        return undefined;
-    }
-    const missingList = missingArtifacts
-        .map((artifact) => `${artifact.kind}: ${artifact.path}`)
-        .join(", ");
-    return {
-        message: `Blocked browser close because requested artifact path${missingArtifacts.length === 1 ? " is" : "s are"} missing or unverified: ${missingList}. Save the requested artifact path first, or report why an optional artifact is unavailable before closing.`,
-        missingArtifacts,
-        reason: "requested-artifacts-missing-before-close",
-    };
-}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/recording-receipt-reconciliation.js

@@ -1,198 +0,0 @@
-import { resolve } from "node:path";
-import { getAgentBrowserSessionIdentityKey } from "../../argv-grammar.js";
-import { getRecordCommandOperands } from "../../command-taxonomy.js";
-import { isRecord } from "../../parsing.js";
-import { extractEnvelopeErrorText } from "../../results/envelope.js";
-import { getRecordingReceipt } from "../../results/recording.js";
-import { getUpstreamEffectiveBatchSteps } from "../batch-stdin.js";
-import { diagnosticErrorText } from "./diagnostic-values.js";
-import { runSessionCommandData } from "./session-state.js";
-export function isRecordingStop(tokens) {
-    return tokens[0] === "record" && tokens[1] === "stop";
-}
-function rowError(row) {
-    return isRecord(row) ? row.error : undefined;
-}
-function rowResult(row) {
-    return isRecord(row) && isRecord(row.result) ? row.result : undefined;
-}
-function stopNeedsRecovery(options, row) {
-    return (options.processResult.timedOut ||
-        /no recording in progress/i.test(extractEnvelopeErrorText(rowError(row) ?? options.envelope?.error) ?? ""));
-}
-function reservationForStart(options, step, row) {
-    if (step[0] !== "record" || !["start", "restart"].includes(step[1] ?? "")) {
-        return undefined;
-    }
-    if (isRecord(row) && row.success === false) {
-        return undefined;
-    }
-    return buildStartReservation(options, step, rowResult(row));
-}
-function buildStartReservation(options, step, started) {
-    const path = typeof started?.path === "string" ? started.path : getRecordCommandOperands(step).path;
-    if (path === undefined ||
-        path === "" ||
-        options.sessionName === undefined ||
-        options.sessionName === "") {
-        return undefined;
-    }
-    return {
-        absolutePath: resolve(options.cwd, path),
-        cwd: options.cwd,
-        path,
-        namespace: options.namespace,
-        sessionName: options.sessionName,
-        recordingId: typeof started?.recordingId === "string" ? started.recordingId : undefined,
-        startedAtMs: options.artifactRunStartedAtMs,
-    };
-}
-function recoverySource(options) {
-    const batch = options.commandTokens[0] === "batch";
-    return {
-        batch,
-        steps: batch
-            ? getUpstreamEffectiveBatchSteps(options.commandTokens, options.stdin)
-            : [options.commandTokens],
-        rows: batch && Array.isArray(options.envelope?.data) ? options.envelope.data : undefined,
-    };
-}
-function originalAttempt(options, stopRow) {
-    const error = options.processResult.timedOut
-        ? `Record stop timed out after ${options.processResult.timeoutMs ?? "undefined"} ms.`
-        : (extractEnvelopeErrorText(rowError(stopRow) ?? options.envelope?.error) ??
-            "Record stop did not return a receipt.");
-    return {
-        success: false,
-        exitCode: options.processResult.exitCode,
-        timedOut: options.processResult.timedOut,
-        error,
-        parseError: options.parseError,
-    };
-}
-function recordingAttemptWasInterrupted(options) {
-    return (options.processResult.aborted ||
-        (options.signal?.aborted ?? false) ||
-        !options.processResult.agentBrowserStarted);
-}
-export function planRecordingRecovery(options) {
-    if (recordingAttemptWasInterrupted(options)) {
-        return undefined;
-    }
-    const { batch, steps, rows } = recoverySource(options);
-    const stopIndex = steps.reduce((last, step, index) => isRecordingStop(step) && stopNeedsRecovery(options, rows?.at(index)) ? index : last, -1);
-    if (stopIndex < 0) {
-        return undefined;
-    }
-    let expected = options.reservation;
-    for (const [index, step] of steps.slice(0, stopIndex).entries()) {
-        expected = reservationForStart(options, step, rows?.at(index)) ?? expected;
-    }
-    return {
-        batch,
-        rows,
-        stopIndex,
-        expected,
-        attempt: originalAttempt(options, rows?.at(stopIndex)),
-    };
-}
-function receiptMatches(receipt, expected, nowMs) {
-    if (resolve(expected.cwd, receipt.path) !== expected.absolutePath) {
-        return false;
-    }
-    if (expected.recordingId !== undefined && expected.recordingId !== "") {
-        return receipt.recordingId === expected.recordingId;
-    }
-    const startedAtMs = Date.parse(receipt.capture.startedAt ?? "");
-    return (expected.startedAtMs !== undefined &&
-        startedAtMs >= expected.startedAtMs &&
-        startedAtMs <= nowMs);
-}
-function sameNativeSession(info, options) {
-    if (!isRecord(info) || typeof info.session !== "string" || options.sessionName === undefined) {
-        return false;
-    }
-    return (getAgentBrowserSessionIdentityKey(info.session, typeof info.namespace === "string" ? info.namespace : undefined) === getAgentBrowserSessionIdentityKey(options.sessionName, options.namespace));
-}
-function reconcileNativeReceipts(info, options, expected) {
-    const recordings = nativeRecordingState(info);
-    const current = getRecordingReceipt(recordings?.current);
-    const unavailable = {
-        current,
-        status: "unavailable",
-        reason: "Native session info did not provide a matching recording receipt. File presence alone cannot prove successful recording finalization.",
-    };
-    if (!recordings) {
-        return unavailable;
-    }
-    if (!sameNativeSession(info, options)) {
-        return {
-            current,
-            status: "mismatch",
-            reason: "Native session info reported a different namespace/session; its recording receipt was not used.",
-        };
-    }
-    if (!expected) {
-        return unavailable;
-    }
-    for (const candidate of [recordings.current, recordings.last]) {
-        const receipt = getRecordingReceipt(candidate);
-        if (receipt && receiptMatches(receipt, expected, Date.now())) {
-            return { ...unavailable, receipt, data: candidate };
-        }
-    }
-    return {
-        current,
-        status: "mismatch",
-        reason: "Native recording IDs, paths or capture windows did not match this attempt; unrelated receipt measurements were not used.",
-    };
-}
-function nativeRecordingState(info) {
-    const runtime = isRecord(info) && isRecord(info.runtime) ? info.runtime : undefined;
-    return isRecord(runtime?.recording) ? runtime.recording : undefined;
-}
-export async function collectRecordingReceiptEvidence(options, expected) {
-    try {
-        const info = await runSessionCommandData({
-            args: ["session", "info"],
-            cwd: options.cwd,
-            namespace: options.namespace,
-            pinNamespace: true,
-            sessionName: options.sessionName,
-            signal: options.signal,
-            timeoutMs: 2_000,
-        });
-        return reconcileNativeReceipts(info, options, expected);
-    }
-    catch (error) {
-        return {
-            status: "unavailable",
-            reason: `Native session info was unavailable: ${diagnosticErrorText(error)}. File presence alone cannot prove successful recording finalization.`,
-        };
-    }
-}
-export function anotherTakeUsesPath(evidence, expected) {
-    const { current, receipt } = evidence;
-    return (current !== undefined &&
-        receipt !== undefined &&
-        expected !== undefined &&
-        current.recordingId !== receipt.recordingId &&
-        resolve(expected.cwd, current.path) === expected.absolutePath);
-}
-function encodedOutputIsComplete(receipt) {
-    return (receipt.success === true &&
-        receipt.output.encoderSucceeded === true &&
-        receipt.output.encodedFrames !== null &&
-        receipt.output.encodedFrames > 0 &&
-        receipt.file.exists === true &&
-        receipt.file.sizeBytes !== null &&
-        receipt.file.sizeBytes > 0);
-}
-export function recordingHasTerminalMeasurements(evidence, expected) {
-    const receipt = evidence.receipt;
-    return (receipt !== undefined &&
-        encodedOutputIsComplete(receipt) &&
-        Number.isFinite(Date.parse(receipt.capture.startedAt ?? "")) &&
-        Number.isFinite(Date.parse(receipt.capture.endedAt ?? "")) &&
-        !anotherTakeUsesPath(evidence, expected));
-}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/recording-recovery-contracts.js

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

package/dist/extensions/agent-browser/lib/orchestration/browser-run/recording-recovery-presentation.js

@@ -1,154 +0,0 @@
-import { buildToolPresentation } from "../../results/presentation.js";
-import { isRecord } from "../../parsing.js";
-import { anotherTakeUsesPath, } from "./recording-receipt-reconciliation.js";
-export function recordingRecoveryData(plan, evidence) {
-    return (evidence.data ??
-        (plan.expected
-            ? { path: plan.expected.absolutePath, recordingId: plan.expected.recordingId, success: null }
-            : undefined));
-}
-export async function presentRecordingReceipt(options, plan, evidence, terminalMeasurements) {
-    const expected = plan.expected;
-    const data = recordingRecoveryData(plan, evidence);
-    return buildToolPresentation({
-        modelVisible: options.modelVisible,
-        artifactManifest: options.artifactManifest,
-        artifactMinUpdatedAtMs: expected?.startedAtMs ?? options.artifactRunStartedAtMs,
-        artifactMaxUpdatedAtMs: Date.now(),
-        artifactRequest: expected
-            ? {
-                path: expected.path,
-                absolutePath: expected.absolutePath,
-                status: terminalMeasurements ? undefined : "unverified",
-            }
-            : undefined,
-        commandInfo: { command: "record", subcommand: "stop" },
-        cwd: expected?.cwd ?? options.cwd,
-        envelope: { success: evidence.receipt?.success === true, data },
-        namespace: options.namespace,
-        sessionName: options.sessionName,
-        recordingPending: evidence.receipt
-            ? evidence.receipt.success === null
-            : options.processResult.timedOut,
-    });
-}
-export function classifyRecordingRecovery(evidence, plan, verified) {
-    const receipt = evidence.receipt;
-    if (!receipt) {
-        return { status: evidence.status, reason: evidence.reason };
-    }
-    if (verified) {
-        return {
-            status: "recovered",
-            reason: "Native terminal success and encoder measurements match the expected recording and the verified file.",
-        };
-    }
-    if (receipt.success === null) {
-        return {
-            status: "pending",
-            reason: "The matching native take is still pending; no terminal success was reported.",
-        };
-    }
-    if (!receipt.success) {
-        return {
-            status: "failed",
-            reason: `The matching native receipt reports failure: ${receipt.error ?? "unknown encoder/capture failure"}.`,
-        };
-    }
-    return {
-        status: "unverified",
-        reason: anotherTakeUsesPath(evidence, plan.expected)
-            ? "Another active recording uses this path. The previous receipt cannot verify the new take's file."
-            : "A matching receipt was found, but successful encoding and a matching fresh file could not both be verified.",
-    };
-}
-export function repairRecordingEnvelope(options, plan, data, verified) {
-    if (plan.rows) {
-        const rows = plan.rows.map((row, index) => index === plan.stopIndex && isRecord(row)
-            ? { ...row, result: data, success: verified, error: verified ? undefined : row.error }
-            : row);
-        const healed = verified &&
-            !options.processResult.timedOut &&
-            rows.every((row) => isRecord(row) && row.success === true);
-        return {
-            healed,
-            envelope: {
-                success: healed,
-                data: rows,
-                error: healed ? undefined : options.envelope?.error,
-            },
-        };
-    }
-    if (!plan.batch) {
-        return {
-            healed: verified,
-            envelope: { success: verified, data, error: verified ? undefined : plan.attempt.error },
-        };
-    }
-    return { healed: false, envelope: options.envelope };
-}
-function recordingSessionArgs(options, command) {
-    return [
-        "--namespace",
-        options.namespace ?? "",
-        "--session",
-        options.sessionName ?? "",
-        ...command,
-    ];
-}
-function pendingTakeIsCurrent(evidence, recovery) {
-    return (evidence.current !== undefined &&
-        evidence.receipt !== undefined &&
-        evidence.current.recordingId === evidence.receipt.recordingId &&
-        recovery.status === "pending");
-}
-function buildRecordingFollowups(options, evidence, recovery) {
-    if (options.sessionName === undefined || options.sessionName === "") {
-        return [];
-    }
-    const actions = recovery.healed
-        ? []
-        : [
-            {
-                id: "inspect-recording-receipt",
-                tool: "agent_browser",
-                params: { args: recordingSessionArgs(options, ["session", "info"]) },
-                reason: "Inspect the native current/last recording receipts for this exact session.",
-                safety: "Read-only status; does not launch or retarget the browser. Do not infer encoding success from an existing file.",
-            },
-        ];
-    if (pendingTakeIsCurrent(evidence, recovery)) {
-        actions.push({
-            id: "stop-pending-recording",
-            tool: "agent_browser",
-            params: { args: recordingSessionArgs(options, ["record", "stop"]) },
-            reason: `Finalize the still-current native recording ${evidence.receipt?.recordingId ?? "null"}; it has not reported a terminal outcome.`,
-            safety: "Run only while this same recording remains current. No repeated stop was dispatched during recovery.",
-        });
-    }
-    return actions;
-}
-export function finishRecordingPresentation(options, presentation, evidence, recovery) {
-    const content = [...presentation.content];
-    if (options.modelVisible !== false) {
-        content.unshift({
-            type: "text",
-            text: `Recording receipt recovery (${recovery.status}): ${recovery.reason}\nOriginal attempt: ${recovery.attempt.error}`,
-        });
-    }
-    const failure = recovery.healed
-        ? {}
-        : {
-            resultCategory: "failure",
-            failureCategory: options.processResult.timedOut ? "timeout" : "upstream-error",
-            successCategory: undefined,
-            summary: `${recovery.attempt.error} ${recovery.reason}`,
-        };
-    return {
-        ...presentation,
-        ...failure,
-        content,
-        nextActions: buildRecordingFollowups(options, evidence, recovery),
-        recordingRecovery: recovery,
-    };
-}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/recording-recovery.js

@@ -1,80 +0,0 @@
-import { isPendingRecordingArtifact, mergeSessionArtifactManifest, } from "../../results/artifact-manifest.js";
-import { appendUniqueAgentBrowserNextActions } from "../../results/next-actions.js";
-import { buildArtifactVerificationSummary, buildManifestEntriesForFileArtifacts, } from "../../results/presentation/artifacts.js";
-import { collectRecordingReceiptEvidence, isRecordingStop, planRecordingRecovery, recordingHasTerminalMeasurements, } from "./recording-receipt-reconciliation.js";
-import { classifyRecordingRecovery, finishRecordingPresentation, presentRecordingReceipt, repairRecordingEnvelope, recordingRecoveryData, } from "./recording-recovery-presentation.js";
-export async function recoverRecordingStop(options) {
-    const plan = planRecordingRecovery(options);
-    if (!plan) {
-        return undefined;
-    }
-    const evidence = await collectRecordingReceiptEvidence(options, plan.expected);
-    const terminalMeasurements = recordingHasTerminalMeasurements(evidence, plan.expected);
-    const presentation = await presentRecordingReceipt(options, plan, evidence, terminalMeasurements);
-    const verified = terminalMeasurements &&
-        presentation.artifactVerification?.verified === true &&
-        presentation.artifacts?.at(0)?.sizeBytes === evidence.receipt?.file.sizeBytes;
-    const data = recordingRecoveryData(plan, evidence);
-    const repaired = repairRecordingEnvelope(options, plan, data, verified);
-    const recovery = {
-        attempt: plan.attempt,
-        expected: plan.expected,
-        healed: repaired.healed,
-        namespace: options.namespace,
-        sessionName: options.sessionName,
-        source: "session-info",
-        receipt: evidence.receipt,
-        ...classifyRecordingRecovery(evidence, plan, verified),
-    };
-    return {
-        batch: plan.batch,
-        envelope: repaired.envelope,
-        partialBatch: plan.batch && plan.rows === undefined,
-        stopIndex: plan.stopIndex,
-        presentation: finishRecordingPresentation(options, presentation, evidence, recovery),
-        recovery,
-    };
-}
-function mergeRecoveryNextActions(base, result) {
-    const laterRecording = base.batchSteps
-        ?.slice(result.stopIndex + 1)
-        .some((step) => step.artifacts?.some(isPendingRecordingArtifact) === true) === true;
-    const unrelatedFailure = base.batchFailure !== undefined && !isRecordingStop(base.batchFailure.failedStep.command ?? []);
-    const nextActions = (base.nextActions ?? []).filter((action) => action.id === "stop-pending-recording" ? laterRecording : unrelatedFailure);
-    appendUniqueAgentBrowserNextActions(nextActions, result.presentation.nextActions);
-    return nextActions;
-}
-export function mergeRecordingRecoveryPresentation(base, result) {
-    if (!result.batch) {
-        return { ...result.presentation, content: [...result.presentation.content] };
-    }
-    const artifacts = result.partialBatch
-        ? [...(base.artifacts ?? []), ...(result.presentation.artifacts ?? [])]
-        : base.artifacts;
-    return {
-        ...base,
-        artifacts,
-        artifactVerification: buildArtifactVerificationSummary(artifacts ?? []),
-        batchSteps: base.batchSteps?.map((step) => step.index === result.stopIndex
-            ? {
-                ...step,
-                artifacts: result.presentation.artifacts,
-                artifactVerification: result.presentation.artifactVerification,
-            }
-            : step),
-        artifactManifest: result.partialBatch
-            ? mergeSessionArtifactManifest({
-                base: base.artifactManifest,
-                entries: buildManifestEntriesForFileArtifacts(result.presentation.artifacts ?? []),
-            })
-            : base.artifactManifest,
-        content: [
-            ...base.content,
-            ...(result.partialBatch
-                ? result.presentation.content
-                : result.presentation.content.slice(0, 1)),
-        ],
-        nextActions: mergeRecoveryNextActions(base, result),
-        recordingRecovery: result.recovery,
-    };
-}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/screenshot-capture.js

@@ -1,14 +0,0 @@
-import { getScreenshotPathTokenIndex, getScreenshotPositionalIndices } from "./artifact-paths.js";
-export function getScreenshotCapture(command) {
-    if (command[0] !== "screenshot") {
-        return { kind: "unknown" };
-    }
-    if (command.includes("--full") || command.includes("-f")) {
-        return { kind: "full-page" };
-    }
-    const positional = getScreenshotPositionalIndices(command);
-    const selectorIndex = positional.find((index) => index !== getScreenshotPathTokenIndex(command));
-    return selectorIndex === undefined
-        ? { kind: "viewport" }
-        : { kind: "element", selector: command[selectorIndex] };
-}