@wix/pathgrade 1.0.25 → 1.0.27

package/dist/internal/direct-mcp-v2/cleanup.d.ts

@@ -0,0 +1,62 @@
+export type TrackedResource = {
+    opaqueId: string;
+    kind: 'process' | 'descriptor' | 'socket' | 'listener' | 'transport' | 'invocation' | 'auth-copy';
+    close(): Promise<void>;
+    isOpen(): boolean;
+};
+export type ScanEntry = {
+    path: string;
+    status: 'clean' | 'bearer-found' | 'unreadable' | 'skipped';
+    reason?: string;
+};
+export type CleanupReport = {
+    scans: ScanEntry[];
+    released: string[];
+    failures: {
+        opaqueId: string;
+        reason: string;
+    }[];
+    scratchDeleted: boolean;
+    bearerFound: boolean;
+};
+export type TrialArtifactPhase = 'provisional' | 'final';
+export declare function persistTrialArtifact(path: string, content: string, phase: TrialArtifactPhase): Promise<void>;
+export declare class TrialResourceRegistry {
+    private readonly resources;
+    register(resource: TrackedResource): void;
+    entries(): readonly TrackedResource[];
+}
+export declare function scanBearerSurfaces(roots: readonly string[], bearer: string): Promise<ScanEntry[]>;
+export declare function cleanupTrial(options: {
+    registry: TrialResourceRegistry;
+    scanRoots: readonly string[];
+    scratchPath: string;
+    approvedScratchParent: string;
+    bearer: string;
+    persistRedacted(report: CleanupReport, phase: TrialArtifactPhase): Promise<void>;
+    zeroBearer?(): void;
+    removeScratch?(path: string): Promise<void>;
+}): Promise<CleanupReport>;
+export declare class IdempotentTrialCleaner {
+    private readonly options;
+    private result?;
+    constructor(options: Parameters<typeof cleanupTrial>[0]);
+    dispose(): Promise<CleanupReport>;
+}
+export declare class TrialExecutionError extends Error {
+    constructor(message: string, options: {
+        primary?: unknown;
+        secondary: readonly unknown[];
+    });
+    readonly secondary: readonly unknown[];
+}
+export declare function runWithUnconditionalSettlement<T>(options: {
+    sendTurn(): Promise<T>;
+    finalize(input: {
+        providerResult?: T;
+        providerError?: unknown;
+        cancellationRequested: boolean;
+    }): Promise<void>;
+    cleanup(): Promise<void>;
+    cancellationRequested?: boolean;
+}): Promise<T>;

package/dist/internal/direct-mcp-v2/cleanup.js

@@ -0,0 +1,182 @@
+import { lstat, opendir, readFile, realpath, rename, rm, writeFile } from 'node:fs/promises';
+import { isAbsolute, relative, resolve } from 'node:path';
+import { removeSandboxRoot } from '../../providers/sandbox-lifecycle.js';
+export async function persistTrialArtifact(path, content, phase) {
+    const pending = `${path}.pending`;
+    const destination = phase === 'provisional' ? pending : path;
+    const temporary = `${destination}.${process.pid}.tmp`;
+    try {
+        await writeFile(temporary, content, { mode: 0o600 });
+        await rename(temporary, destination);
+        if (phase === 'final')
+            await rm(pending, { force: true });
+    }
+    catch (error) {
+        await rm(temporary, { force: true }).catch(() => undefined);
+        if (phase === 'final')
+            await rm(pending, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+export class TrialResourceRegistry {
+    resources = new Map();
+    register(resource) {
+        if (this.resources.has(resource.opaqueId))
+            throw new Error(`duplicate resource ID ${resource.opaqueId}`);
+        this.resources.set(resource.opaqueId, resource);
+    }
+    entries() { return [...this.resources.values()]; }
+}
+function within(root, path) {
+    const difference = relative(root, path);
+    return difference === '' || (!difference.startsWith('..') && !isAbsolute(difference));
+}
+export async function scanBearerSurfaces(roots, bearer) {
+    if (bearer.length === 0)
+        throw new Error('bearer must be non-empty');
+    const entries = [];
+    for (const declaredRoot of roots) {
+        try {
+            const root = await realpath(declaredRoot);
+            const pending = [root];
+            const visited = new Set();
+            while (pending.length > 0) {
+                const path = pending.pop();
+                try {
+                    const stat = await lstat(path);
+                    if (stat.isSymbolicLink()) {
+                        const target = await realpath(path);
+                        if (!within(root, target))
+                            entries.push({ path, status: 'clean', reason: 'symlink target outside approved root was not followed' });
+                        else if (!visited.has(target))
+                            pending.push(target);
+                    }
+                    else if (stat.isDirectory()) {
+                        const canonicalPath = await realpath(path);
+                        if (visited.has(canonicalPath))
+                            continue;
+                        visited.add(canonicalPath);
+                        const directory = await opendir(path);
+                        for await (const entry of directory)
+                            pending.push(resolve(path, entry.name));
+                    }
+                    else if (stat.isFile()) {
+                        const content = await readFile(path);
+                        entries.push({ path, status: content.includes(Buffer.from(bearer)) ? 'bearer-found' : 'clean' });
+                    }
+                    else
+                        entries.push({ path, status: 'skipped', reason: 'not a regular file, directory, or symlink' });
+                }
+                catch (error) {
+                    entries.push({ path, status: 'unreadable', reason: error instanceof Error ? error.message : String(error) });
+                }
+            }
+        }
+        catch (error) {
+            entries.push({ path: declaredRoot, status: 'unreadable', reason: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    return entries.sort((left, right) => left.path.localeCompare(right.path, 'en'));
+}
+export async function cleanupTrial(options) {
+    const released = [];
+    const failures = [];
+    for (const resource of [...options.registry.entries()].reverse()) {
+        try {
+            await resource.close();
+            if (resource.isOpen())
+                throw new Error('resource remained open after close');
+            released.push(resource.opaqueId);
+        }
+        catch (error) {
+            failures.push({ opaqueId: resource.opaqueId, reason: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    const scans = await scanBearerSurfaces(options.scanRoots, options.bearer);
+    const bearerFound = scans.some((entry) => entry.status === 'bearer-found');
+    if (scans.some((entry) => entry.status === 'unreadable' || entry.status === 'skipped'))
+        failures.push({ opaqueId: 'surface-scan', reason: 'scan was incomplete' });
+    if (bearerFound)
+        failures.push({ opaqueId: 'surface-scan', reason: 'bearer found in writable surface' });
+    const report = { scans, released: released.sort(), failures, scratchDeleted: false, bearerFound };
+    if (!bearerFound) {
+        try {
+            await options.persistRedacted(report, 'provisional');
+        }
+        catch (error) {
+            failures.push({ opaqueId: 'artifact-persistence', reason: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    else
+        failures.push({ opaqueId: 'artifact-persistence', reason: 'persistence refused because bearer remained' });
+    options.zeroBearer?.();
+    try {
+        const parent = await realpath(options.approvedScratchParent);
+        const scratch = await realpath(options.scratchPath);
+        if (scratch === parent || !within(parent, scratch))
+            throw new Error('scratch path is outside its approved parent');
+        await (options.removeScratch ?? removeSandboxRoot)(scratch);
+        report.scratchDeleted = true;
+    }
+    catch (error) {
+        failures.push({ opaqueId: 'scratch', reason: error instanceof Error ? error.message : String(error) });
+    }
+    if (!bearerFound) {
+        try {
+            await options.persistRedacted(report, 'final');
+        }
+        catch (error) {
+            failures.push({ opaqueId: 'artifact-finalization', reason: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    return report;
+}
+export class IdempotentTrialCleaner {
+    options;
+    result;
+    constructor(options) {
+        this.options = options;
+    }
+    dispose() {
+        this.result ??= cleanupTrial(this.options);
+        return this.result;
+    }
+}
+export class TrialExecutionError extends Error {
+    constructor(message, options) {
+        super(message, { cause: options.primary });
+        this.name = 'TrialExecutionError';
+        this.secondary = options.secondary;
+    }
+    secondary;
+}
+export async function runWithUnconditionalSettlement(options) {
+    let providerResult;
+    let providerError;
+    const secondary = [];
+    try {
+        providerResult = await options.sendTurn();
+    }
+    catch (error) {
+        providerError = error;
+    }
+    finally {
+        try {
+            await options.finalize({ providerResult, providerError, cancellationRequested: options.cancellationRequested ?? false });
+        }
+        catch (error) {
+            secondary.push(error);
+        }
+        try {
+            await options.cleanup();
+        }
+        catch (error) {
+            secondary.push(error);
+        }
+    }
+    if (providerError !== undefined || secondary.length > 0) {
+        throw new TrialExecutionError(providerError instanceof Error ? providerError.message : 'trial settlement failed', { primary: providerError, secondary });
+    }
+    // SAFETY: reaching this line proves sendTurn resolved and neither it nor settlement recorded an error.
+    return providerResult;
+}

package/dist/internal/direct-mcp-v2/codex-direct-mcp.d.ts

@@ -0,0 +1,41 @@
+import { type CleanupReport } from './cleanup.js';
+import { type AppServerSessionHandle } from '../../agents/codex-app-server/transport.js';
+import type { EvidenceEnvelope, ScenarioArtifact, ScenarioMachineV2 } from './types.js';
+export declare const CODEX_DIRECT_MCP_FLAG = "PATHGRADE_INTERNAL_CODEX_DIRECT_MCP_V2";
+export type CodexDirectMcpChecks = {
+    runtimeAdmitted: boolean;
+    secretFreeProject: boolean;
+    directCall: boolean;
+    structuredToolError: boolean;
+    fencedCancellation: boolean;
+    providerTerminal: boolean;
+    hostQuiescent: boolean;
+    postCancelReuse: boolean;
+    privateReplay: boolean;
+    cleanup: boolean;
+};
+export type CodexDirectMcpTrialResult = {
+    selected: true;
+    profileFingerprint: string;
+    artifact: ScenarioArtifact;
+    evidence: readonly EvidenceEnvelope[];
+    checks: CodexDirectMcpChecks;
+    cleanup: CleanupReport;
+    cancellationStatus: string;
+};
+export declare function isCodexDirectMcpSelected(environment?: NodeJS.ProcessEnv): boolean;
+export declare function codexDirectMcpDisableReason(): string | undefined;
+/** Test-only reset for proving the fail-closed process latch. */
+export declare function __resetCodexDirectMcpDisablementForTesting(): void;
+export declare function runCodexDirectMcpTrial(options: {
+    scenario: ScenarioMachineV2;
+    environment?: NodeJS.ProcessEnv;
+    model?: string;
+    artifactDirectory?: string;
+    createControlPlane?: (context: {
+        cwd: string;
+        env: NodeJS.ProcessEnv;
+        binary: string;
+    }) => AppServerSessionHandle;
+}): Promise<CodexDirectMcpTrialResult>;
+export declare function mapCodexProviderEnvironment(environment: NodeJS.ProcessEnv, codexHome: string): NodeJS.ProcessEnv;