pi-agent-browser-native 0.9.4 → 0.9.6

package/dist/extensions/agent-browser/lib/orchestration/browser-run/prepare-page-selection.js

@@ -1,254 +0,0 @@
-import { isRecord } from "../../parsing.js";
-import { extractUpstreamCommandTokens } from "../../runtime.js";
-import { redactInvocationArgs } from "../../runtime-redaction.js";
-import { getExplicitSessionPageVerificationRequirement, getPageTargetValidationError, } from "../../page-target-validation.js";
-import { buildAgentBrowserResultCategoryDetails } from "../../results/categories.js";
-import { buildStaleRefPreflight, ensureSessionTabTarget, extractStringResultField, runSessionCommandData, shouldPinSessionTabForCommand, } from "./session-state.js";
-import { validateStdinCommandContract } from "./prepare-input.js";
-import { preparationFailure, preparationSessionDetails } from "./prepare-failure.js";
-import { planHasValidationError, withPlanValidationError } from "./prepare-session-plan.js";
-function shouldSelectRememberedTab(plan, hasReadConfirmation, request) {
-    const tokens = extractUpstreamCommandTokens(request.preparedArgs.args);
-    const knownStaleRef = buildStaleRefPreflight({
-        commandTokens: tokens,
-        currentTarget: request.page.priorSessionTabTarget,
-        refSnapshot: request.page.priorRefSnapshotState,
-        refSnapshotInvalidation: request.page.priorRefSnapshotInvalidation,
-        stdin: request.stdin,
-    });
-    const invalidStdin = validateStdinCommandContract({
-        command: plan.commandInfo.command,
-        commandTokens: tokens,
-        stdin: request.stdin,
-    });
-    const pin = shouldPinSessionTabForCommand({
-        command: plan.commandInfo.command,
-        commandTokens: tokens,
-        pinningRequired: !hasReadConfirmation &&
-            request.page.sessionTabPinningReason !== undefined &&
-            request.input.compiledQaPreset?.checks.url === undefined,
-        reopenPending: request.page.coldManagedSession,
-        sessionName: plan.sessionName,
-        stdin: request.stdin,
-    });
-    return (!planHasValidationError(plan) &&
-        !plan.plainTextInspection &&
-        !knownStaleRef &&
-        invalidStdin === undefined &&
-        request.page.priorSessionTabTarget !== undefined &&
-        pin);
-}
-async function reopenRememberedTab(pageState, process, plan, request) {
-    const page = request.page;
-    const target = page.priorSessionTabTarget;
-    if (!page.coldManagedSession || !target) {
-        return { page, reopened: true };
-    }
-    const data = await runSessionCommandData({
-        args: ["open", target.url],
-        cwd: process.cwd,
-        namespace: plan.namespace,
-        sessionName: plan.sessionName,
-        signal: process.signal,
-        timeoutMs: process.timeoutMs,
-        onProcessResult: ({ agentBrowserStarted }) => {
-            // A started open may navigate even when its CLI is aborted before replying.
-            if (agentBrowserStarted &&
-                page.sessionStateKey !== undefined &&
-                page.sessionStateKey !== "") {
-                pageState.setTabReopenPending({
-                    pending: false,
-                    sessionName: page.sessionStateKey,
-                    update: request.update,
-                });
-            }
-        },
-    });
-    if (data === undefined) {
-        return { page, reopened: false };
-    }
-    return {
-        page: {
-            ...page,
-            priorSessionTabTarget: {
-                ...target,
-                targetId: isRecord(data) && typeof data.targetId === "string" ? data.targetId : undefined,
-            },
-        },
-        reopened: true,
-    };
-}
-function abortedReopenResult(restoreDisabled, plan, request) {
-    const errorText = "agent_browser was aborted while reopening the remembered page. The requested command did not run.";
-    return preparationFailure({
-        message: errorText,
-        details: {
-            aborted: true,
-            args: request.input.redactedArgs,
-            command: plan.commandInfo.command,
-            effectiveArgs: redactInvocationArgs(plan.effectiveArgs),
-            sessionMode: request.sessionMode,
-            ...preparationSessionDetails(restoreDisabled, plan),
-            ...buildAgentBrowserResultCategoryDetails({
-                args: request.input.redactedArgs,
-                command: plan.commandInfo.command,
-                errorText,
-                failureCategory: "aborted",
-                succeeded: false,
-            }),
-        },
-    });
-}
-async function selectReopenedTab(process, plan, reopened) {
-    if (process.signal?.aborted === true) {
-        return undefined;
-    }
-    if (!reopened.reopened) {
-        return {
-            error: "agent-browser could not reopen the remembered URL after the managed browser shut down. Navigate explicitly, then run snapshot -i before retrying.",
-        };
-    }
-    const target = reopened.page.priorSessionTabTarget;
-    if (!target) {
-        return undefined;
-    }
-    return ensureSessionTabTarget({
-        cwd: process.cwd,
-        namespace: plan.namespace,
-        sessionName: plan.sessionName,
-        signal: process.signal,
-        target,
-    });
-}
-function reconcileTabSelection(base, reopened, selection) {
-    const error = selection?.error;
-    return {
-        ...base,
-        page: reopened.page,
-        sessionTabCorrection: selection?.correction,
-        sessionTabSelectionError: error,
-        executionPlan: error !== undefined && error !== ""
-            ? withPlanValidationError(base.executionPlan, error)
-            : base.executionPlan,
-    };
-}
-export async function preparePageSelection(pageState, process, hasReadConfirmation, request) {
-    const base = {
-        page: request.page,
-        executionPlan: request.plan,
-        livePageVerified: false,
-    };
-    if (!shouldSelectRememberedTab(request.plan, hasReadConfirmation, request)) {
-        return base;
-    }
-    process.signal?.throwIfAborted();
-    const reopened = await reopenRememberedTab(pageState, process, request.plan, request);
-    const selection = await selectReopenedTab(process, request.plan, reopened);
-    if (request.page.coldManagedSession && process.signal?.aborted === true) {
-        return {
-            earlyResult: abortedReopenResult(request.restoreDisabled, request.plan, request),
-        };
-    }
-    process.signal?.throwIfAborted();
-    return reconcileTabSelection(base, reopened, selection);
-}
-export function callerOwnedExplicitSession(ownsSession, plan) {
-    return plan.sessionName !== undefined && !plan.usedImplicitSession && !ownsSession;
-}
-export function requiresLivePageVerification(preserveAttachedBrowserSession, routing, selection) {
-    return (!routing.hasReadConfirmation &&
-        (selection.page.reuseConfirmedCapture ||
-            callerOwnedExplicitSession(routing.ownsSession, selection.executionPlan) ||
-            preserveAttachedBrowserSession === true));
-}
-async function readLiveUrl(process, plan) {
-    try {
-        const data = await runSessionCommandData({
-            args: ["get", "url"],
-            cwd: process.cwd,
-            namespace: plan.namespace,
-            sessionName: plan.sessionName,
-            signal: process.signal,
-            throwOnFailure: true,
-        });
-        return extractStringResultField(data, "result") ?? extractStringResultField(data, "url");
-    }
-    catch (error) {
-        if (process.signal?.aborted === true) {
-            process.signal.throwIfAborted();
-            throw error;
-        }
-        // A failed read cannot establish the target; the caller retains the requirement error.
-    }
-    return undefined;
-}
-function verifiedLivePage(selection, url) {
-    const target = selection.page.priorSessionTabTarget;
-    return {
-        ...selection,
-        livePageVerified: true,
-        page: {
-            ...selection.page,
-            priorSessionTabTarget: target?.url === url ? { ...target, url } : { url },
-            priorSessionTabTargetUnknown: undefined,
-        },
-    };
-}
-export async function verifyPreparationLivePage(process, selection, request) {
-    const plan = selection.executionPlan;
-    if (request.requirement === undefined ||
-        request.requirement === "" ||
-        plan.sessionName === undefined ||
-        plan.sessionName === "") {
-        return selection;
-    }
-    if (process.establishAttachedBrowserSession === true) {
-        return { ...selection, executionPlan: withPlanValidationError(plan, request.requirement) };
-    }
-    const url = await readLiveUrl(process, plan);
-    if (url === undefined) {
-        return { ...selection, executionPlan: withPlanValidationError(plan, request.requirement) };
-    }
-    const error = getPageTargetValidationError({
-        args: request.args,
-        currentPageUrl: url,
-        pageUrlUnknown: false,
-        stdin: request.stdin,
-    });
-    if (error !== undefined && error !== "") {
-        return { ...selection, executionPlan: withPlanValidationError(plan, error) };
-    }
-    return verifiedLivePage(selection, url);
-}
-export async function verifyCommandLivePage(process, routing, selection, request) {
-    const { page, executionPlan: plan } = selection;
-    const stale = buildStaleRefPreflight({
-        commandTokens: request.commandTokens,
-        currentTarget: page.priorSessionTabTarget,
-        refSnapshot: request.resolvedSnapshot ?? page.priorRefSnapshotState,
-        refSnapshotInvalidation: request.resolvedSnapshot
-            ? undefined
-            : page.priorRefSnapshotInvalidation,
-        stdin: request.stdin,
-    });
-    const invalidStdin = validateStdinCommandContract({
-        command: plan.commandInfo.command,
-        commandTokens: request.commandTokens,
-        stdin: request.stdin,
-    });
-    const eligible = !planHasValidationError(plan) &&
-        stale === undefined &&
-        invalidStdin === undefined &&
-        requiresLivePageVerification(process.preserveAttachedBrowserSession, routing, selection);
-    const requirement = eligible && !selection.livePageVerified
-        ? getExplicitSessionPageVerificationRequirement({
-            args: plan.effectiveArgs,
-            stdin: request.stdin,
-        })
-        : undefined;
-    return verifyPreparationLivePage(process, selection, {
-        args: plan.effectiveArgs,
-        requirement,
-        stdin: request.stdin,
-    });
-}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/prepare-page-state.js

@@ -1,121 +0,0 @@
-import { isCloseCommand } from "../../command-taxonomy.js";
-import { buildPageTransitionRefSnapshotInvalidation, } from "../../session-page-state.js";
-import { inspectManagedSessionDaemon } from "./managed-session-daemon-policy.js";
-import { getSessionContextKey } from "./session-state.js";
-export async function inspectPreparationGeneration(process, identity) {
-    return inspectManagedSessionDaemon({
-        ...process,
-        namespace: identity.namespace,
-        sessionName: identity.sessionName,
-        includeGeneration: true,
-        headedManagedAutosaveInterval: identity.owned?.headedManagedAutosaveInterval ??
-            (identity.owned?.headedManagedAutosaveDisabled === true ? "0" : undefined),
-    });
-}
-function consumeConfirmedCapture(state, update, key) {
-    const confirmed = key !== undefined && key !== "" ? state.sessionPageState.getReadConfirmation(key) : undefined;
-    if (confirmed?.refSnapshotFresh !== true) {
-        return false;
-    }
-    // ponytail: reuse the approved capture for one call; DOM-only renames after that sample are not resampled on this use.
-    const consumed = { ...confirmed };
-    delete consumed.refSnapshotFresh;
-    state.sessionPageState.applyReadConfirmation(consumed, update);
-    state.observedBrowserEffects = { ...state.observedBrowserEffects, readConfirmation: consumed };
-    return true;
-}
-function generationInspectionEligible(plan, browserIndependent, page) {
-    if (browserIndependent || isCloseCommand(plan.commandInfo.command)) {
-        return false;
-    }
-    return ((page.priorRefSnapshotState?.refIds.length ?? 0) > 0 &&
-        page.sessionStateKey !== undefined &&
-        page.sessionStateKey !== "" &&
-        plan.sessionName !== undefined &&
-        plan.sessionName !== "");
-}
-async function reconcileGeneration(pageState, process, request) {
-    const { page, plan, session } = request;
-    const snapshot = page.priorRefSnapshotState;
-    const key = page.sessionStateKey;
-    const name = plan.sessionName;
-    if (!generationInspectionEligible(plan, session.browserIndependent, page) ||
-        snapshot === undefined ||
-        key === undefined ||
-        name === undefined) {
-        return { ...page, nativeGenerationChanged: false };
-    }
-    const daemon = await inspectPreparationGeneration(process, {
-        namespace: plan.namespace,
-        sessionName: name,
-        owned: session.ownedManagedSession,
-    });
-    pageState.bindSnapshotGeneration(key, daemon.status === "active" ? daemon.generation : undefined);
-    const generationKnown = daemon.status === "active" && daemon.generation !== undefined;
-    if (generationKnown && snapshot.generation === daemon.generation) {
-        return { ...page, nativeGenerationChanged: false };
-    }
-    const nativeGenerationChanged = generationKnown && snapshot.generation !== undefined;
-    const invalidation = buildPageTransitionRefSnapshotInvalidation("The native browser generation changed or could not be verified. Take a new complete snapshot before using refs, even when the URL is unchanged.");
-    pageState.applyRefSnapshotInvalidation({
-        invalidation,
-        sessionName: key,
-        update: request.update,
-    });
-    return {
-        ...page,
-        nativeGenerationChanged,
-        priorRefSnapshotState: undefined,
-        priorRefSnapshotInvalidation: invalidation,
-    };
-}
-function coldSessionEligible(request) {
-    const nativeCold = request.inactive || request.page.nativeGenerationChanged || request.reopenPending;
-    return (!request.browserIndependent &&
-        nativeCold &&
-        request.restoreEligible &&
-        request.preserveAttachedBrowserSession !== true);
-}
-export async function preparePageState(state, process, request) {
-    const { plan, session, update } = request;
-    const key = getSessionContextKey(plan.sessionName, plan.namespace);
-    const pageState = state.sessionPageState;
-    const prior = pageState.get(key);
-    const page = await reconcileGeneration(pageState, process, {
-        plan,
-        session,
-        update,
-        page: {
-            sessionStateKey: key,
-            priorSessionTabTarget: prior.tabTarget,
-            priorSessionTabTargetUnknown: prior.tabTargetUnknown,
-            sessionTabPinningReason: prior.pinningReason,
-            priorRefSnapshotState: prior.refSnapshot,
-            priorRefSnapshotInvalidation: prior.refSnapshotInvalidation,
-            reuseConfirmedCapture: consumeConfirmedCapture(state, update, key),
-            coldManagedSession: false,
-        },
-    });
-    const coldManagedSession = coldSessionEligible({
-        browserIndependent: session.browserIndependent,
-        ...request,
-        page,
-        reopenPending: prior.tabReopenPending === true,
-        restoreEligible: session.recordedOwnedSession !== undefined &&
-            page.sessionTabPinningReason === "restore" &&
-            session.ownedManagedSession?.restoreDecision === "enabled" &&
-            !state.managedSessionRestoreState.isDisabled(plan.sessionName, plan.namespace),
-    });
-    if (!coldManagedSession || key === undefined || key === "") {
-        return { ...page, coldManagedSession };
-    }
-    pageState.setTabReopenPending({ pending: true, sessionName: key, update });
-    const invalidation = buildPageTransitionRefSnapshotInvalidation("The managed browser shut down. Reopening its URL reloads the page; run snapshot -i before using page-scoped refs.");
-    pageState.applyRefSnapshotInvalidation({ invalidation, sessionName: key, update });
-    return {
-        ...page,
-        coldManagedSession,
-        priorRefSnapshotState: undefined,
-        priorRefSnapshotInvalidation: invalidation,
-    };
-}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/prepare-refs.js

@@ -1,130 +0,0 @@
-import { getCompiledSemanticActionSessionPrefix } from "../../input-modes/semantic-action.js";
-import { resolveVisibleRefActionFromSnapshot } from "../../results/selector-recovery.js";
-import { extractRefSnapshotFromData, normalizeComparableUrl } from "../../session-page-state.js";
-import { getGuardedRefUsage, runSessionCommandData } from "./session-state.js";
-function describeRef(snapshot, refId) {
-    const ref = snapshot?.refs?.[refId];
-    return ref ? `${ref.role} ${JSON.stringify(ref.name)}` : "not present";
-}
-function refChanged(previous, current, refId) {
-    const previousRef = previous.refs?.[refId];
-    const currentRef = current.refs?.[refId];
-    if (!current.refIds.includes(refId)) {
-        return true;
-    }
-    if (!previousRef || !currentRef) {
-        return previousRef !== currentRef;
-    }
-    return previousRef.role !== currentRef.role || previousRef.name !== currentRef.name;
-}
-function samePageFreshnessFailure(options) {
-    const previousUrl = normalizeComparableUrl(options.previousSnapshot.target?.url);
-    const currentUrl = normalizeComparableUrl(options.currentSnapshot.target?.url);
-    if (previousUrl === undefined ||
-        previousUrl === "" ||
-        currentUrl === undefined ||
-        currentUrl === "" ||
-        previousUrl !== currentUrl ||
-        currentUrl === "about:blank") {
-        return undefined;
-    }
-    const mismatchedRefs = options.refIds.filter((refId) => refChanged(options.previousSnapshot, options.currentSnapshot, refId));
-    if (mismatchedRefs.length === 0) {
-        return undefined;
-    }
-    const refText = mismatchedRefs.map((refId) => `@${refId}`).join(", ");
-    const evidence = mismatchedRefs
-        .map((refId) => `@${refId}: previous ${describeRef(options.previousSnapshot, refId)}, current ${describeRef(options.currentSnapshot, refId)}`)
-        .join("; ");
-    return {
-        message: `Ref ${refText} no longer matches the latest same-page snapshot. The page likely rerendered after the previous snapshot; run snapshot -i and retry with current refs. Evidence: ${evidence}.`,
-        refIds: mismatchedRefs,
-    };
-}
-function targetPrecludesFreshness(previousSnapshot, currentTarget) {
-    const previousUrl = normalizeComparableUrl(previousSnapshot.target?.url);
-    const currentUrl = normalizeComparableUrl(currentTarget?.url);
-    if (currentUrl === "about:blank") {
-        return true;
-    }
-    return (previousUrl !== undefined &&
-        previousUrl !== "" &&
-        currentUrl !== undefined &&
-        currentUrl !== "" &&
-        previousUrl !== currentUrl);
-}
-export async function collectSamePageRefFreshnessPreflight(options) {
-    const refIds = [...new Set(getGuardedRefUsage(options.commandTokens, options.stdin))];
-    if (!options.previousSnapshot ||
-        options.sessionName === undefined ||
-        options.sessionName === "" ||
-        refIds.length === 0) {
-        return undefined;
-    }
-    if (targetPrecludesFreshness(options.previousSnapshot, options.currentTarget)) {
-        return undefined;
-    }
-    const snapshotData = await runSessionCommandData({
-        args: ["snapshot", "-i"],
-        cwd: options.cwd,
-        namespace: options.namespace,
-        sessionName: options.sessionName,
-        signal: options.signal,
-    });
-    const currentSnapshot = extractRefSnapshotFromData(snapshotData);
-    if (!currentSnapshot) {
-        return undefined;
-    }
-    const snapshotWithTarget = {
-        ...currentSnapshot,
-        target: currentSnapshot.target ?? options.currentTarget,
-    };
-    const mismatch = samePageFreshnessFailure({
-        currentSnapshot: snapshotWithTarget,
-        previousSnapshot: options.previousSnapshot,
-        refIds,
-    });
-    return mismatch
-        ? { message: mismatch.message, refIds: mismatch.refIds, snapshot: snapshotWithTarget }
-        : undefined;
-}
-export function canResolveSemanticVisibleRef(compiled) {
-    if (compiled?.locator === undefined) {
-        return false;
-    }
-    if (compiled.action === "select") {
-        return true;
-    }
-    return compiled.locator === "role" && ["check", "click", "fill"].includes(compiled.action);
-}
-export function requiresResolvedSemanticVisibleRef(compiled) {
-    return compiled?.action === "select" && compiled.locator !== undefined;
-}
-export async function resolveSemanticActionVisibleRefArgs(options) {
-    if (!canResolveSemanticVisibleRef(options.compiled) ||
-        options.sessionName === undefined ||
-        options.sessionName === "") {
-        return undefined;
-    }
-    const snapshotData = options.refSnapshot
-        ? undefined
-        : await runSessionCommandData({
-            args: ["snapshot", "-i"],
-            cwd: options.cwd,
-            namespace: options.namespace,
-            sessionName: options.sessionName,
-            signal: options.signal,
-        });
-    const resolution = resolveVisibleRefActionFromSnapshot({
-        allowFill: true,
-        compiledAction: options.compiled,
-        refSnapshot: options.refSnapshot,
-        snapshotData,
-    });
-    return resolution
-        ? {
-            args: [...getCompiledSemanticActionSessionPrefix(options.compiled), ...resolution.args],
-            snapshot: resolution.snapshot,
-        }
-        : undefined;
-}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/prepare-resources.js

@@ -1,114 +0,0 @@
-import { cleanupElectronLaunchResources } from "../../electron/cleanup.js";
-import { launchElectronApp } from "../../electron/launch.js";
-import { redactSensitiveText } from "../../runtime-redaction.js";
-import { buildAgentBrowserResultCategoryDetails } from "../../results/categories.js";
-import { buildElectronHostFailureResult, getElectronLaunchFailureCategory, } from "./final-result.js";
-import { buildManagedSessionOutcome } from "./session-state.js";
-import { prepareAgentBrowserArgs } from "./prepare-artifacts.js";
-import { preparationFailure } from "./prepare-failure.js";
-export async function prepareElectronLaunch(facts, input, freshSessionName) {
-    const compiled = input.compiledElectron;
-    if (compiled?.action !== "launch") {
-        return {};
-    }
-    const launched = await launchElectronApp({ ...compiled, signal: facts.signal });
-    if (!launched.ok) {
-        const managedSessionOutcome = buildManagedSessionOutcome({
-            activeAfter: facts.managedSessionActive,
-            activeBefore: facts.managedSessionActive,
-            attemptedSessionName: freshSessionName,
-            command: "connect",
-            currentSessionName: facts.managedSessionName,
-            previousSessionName: facts.managedSessionName,
-            sessionMode: "fresh",
-            succeeded: false,
-        });
-        return {
-            earlyResult: {
-                kind: "early-result",
-                result: buildElectronHostFailureResult({
-                    compiledElectron: input.redactedCompiledElectron ?? compiled,
-                    errorText: launched.failure.error,
-                    failureCategory: getElectronLaunchFailureCategory(launched.failure),
-                    launchFailure: launched.failure,
-                    managedSessionOutcome,
-                    status: launched.failure.reason,
-                }),
-            },
-        };
-    }
-    return {
-        electronLaunch: {
-            ...launched.value,
-            record: { ...launched.value.record, ownerSessionId: facts.getOwnerSessionId() },
-        },
-    };
-}
-async function cleanupPreparationElectron(state, launch, timeoutMs) {
-    try {
-        const cleanup = await cleanupElectronLaunchResources({
-            child: launch.child,
-            record: launch.record,
-            timeoutMs,
-        });
-        if (cleanup.partial) {
-            state.electronLaunchRecords.set(cleanup.launchId, cleanup.record);
-            state.electronChildProcesses.set(cleanup.launchId, launch.child);
-        }
-    }
-    catch {
-        state.electronLaunchRecords.set(launch.record.launchId, launch.record);
-        state.electronChildProcesses.set(launch.record.launchId, launch.child);
-    }
-}
-export async function cleanupPreparationResources(state, resources) {
-    // Release native execution ownership before tearing down the task-owned Electron process.
-    await resources.lock?.release();
-    if (resources.electronLaunch) {
-        await cleanupPreparationElectron(state, resources.electronLaunch, resources.timeoutMs);
-    }
-}
-function artifactDirectoryFailure(error, path, redactedArgs) {
-    const guidance = "Choose a writable artifact path whose parent components are directories. Use absolute paths in raw batch artifact rows.";
-    const validationError = redactSensitiveText(`Could not prepare artifact directory ${path}: ${error.message}. ${guidance}`);
-    return preparationFailure({
-        message: validationError,
-        details: {
-            agentBrowserStarted: false,
-            args: redactedArgs,
-            nextActions: [
-                {
-                    artifactPath: redactSensitiveText(path),
-                    id: "verify-artifact-path",
-                    reason: guidance,
-                    safety: "The requested browser command did not run; inspect the directory with host file tools before retrying.",
-                    tool: "agent_browser",
-                },
-            ],
-            ...buildAgentBrowserResultCategoryDetails({
-                args: redactedArgs,
-                succeeded: false,
-                validationError,
-            }),
-            validationError,
-        },
-    });
-}
-export async function prepareArtifactArguments(process, request) {
-    try {
-        return {
-            preparedArgs: await prepareAgentBrowserArgs(request.args, request.stdin, process.cwd),
-        };
-    }
-    catch (error) {
-        process.signal?.throwIfAborted();
-        if (!(error instanceof Error) ||
-            !("syscall" in error) ||
-            error.syscall !== "mkdir" ||
-            !("path" in error) ||
-            typeof error.path !== "string") {
-            throw error;
-        }
-        return { earlyResult: artifactDirectoryFailure(error, error.path, request.redactedArgs) };
-    }
-}