@wix/pathgrade 1.0.25 → 1.0.26

package/dist/internal/direct-mcp-v2/acp-author-session.js

@@ -0,0 +1,201 @@
+import { collectSensitiveEnvValues } from '../../tool-event-results.js';
+import { scanBearerSurfaces } from './cleanup.js';
+import { materializeProjection } from './materialize.js';
+import { projectEndpoints } from './projection.js';
+import { admitRuntimeLock } from './runtime-lock.js';
+import { spawnAcpClient } from './acp-client.js';
+import { projectAcpAuthorTurn, } from './acp-author-projector.js';
+export async function createAcpAuthorSession(options) {
+    const sessionId = await options.client.newSession(options.mcpServers);
+    let activeTerminal;
+    let interruptSent = false;
+    let promptStarted = false;
+    let closed = false;
+    let closePromise;
+    const waitForTerminal = async () => { await activeTerminal; };
+    const interrupt = async () => {
+        if (!activeTerminal || interruptSent)
+            return;
+        interruptSent = true;
+        options.client.setCancelling(true);
+        if (promptStarted)
+            options.client.cancel(sessionId);
+    };
+    const session = {
+        async runTurn(message, turnNumber) {
+            if (closed)
+                throw new Error('ACP author session is closed');
+            if (activeTerminal)
+                throw new Error('ACP author session already has an active turn');
+            const checkpoint = options.client.notificationCheckpoint();
+            interruptSent = false;
+            let finishTerminal;
+            const terminal = new Promise((resolve) => { finishTerminal = resolve; });
+            activeTerminal = terminal;
+            let checkpointDrained = false;
+            try {
+                await options.assertProtectedSurfacesClean?.();
+                if (interruptSent)
+                    throw new Error('ACP author session turn cancelled before prompt');
+                promptStarted = true;
+                const promptResult = await options.client.prompt(sessionId, message);
+                const notifications = options.client.drainNotifications(checkpoint);
+                checkpointDrained = true;
+                return projectAcpAuthorTurn({
+                    provider: options.provider,
+                    terminal: promptResult,
+                    notifications,
+                    normalizeToolName: options.normalizeToolName,
+                    protectedValues: options.protectedValues,
+                    sensitiveValues: options.sensitiveValues,
+                    turnNumber,
+                });
+            }
+            finally {
+                if (!checkpointDrained)
+                    options.client.drainNotifications(checkpoint);
+                promptStarted = false;
+                options.client.setCancelling(false);
+                finishTerminal();
+                if (activeTerminal === terminal)
+                    activeTerminal = undefined;
+            }
+        },
+        interrupt,
+        waitForTerminal,
+        close() {
+            closePromise ??= (async () => {
+                if (closed)
+                    return;
+                closed = true;
+                const terminal = activeTerminal;
+                if (terminal) {
+                    await interrupt();
+                    if (!await settlesWithin(terminal, options.closeJoinTimeoutMs ?? 2_000)) {
+                        await options.client.close();
+                    }
+                    await terminal;
+                }
+                await options.client.close();
+            })();
+            return closePromise;
+        },
+    };
+    return session;
+}
+export function createAcpScenarioAttachment(session) {
+    return {
+        value: session,
+        interrupt: async (_turn, reason) => session.interrupt(reason),
+        waitForTerminal: async () => session.waitForTerminal(),
+        close: async () => session.close(),
+    };
+}
+/**
+ * P4/P5 provider seam: attach one exact, relocatable ACP runtime to the
+ * coordinator and return the reusable author session as its opaque value.
+ */
+export async function attachAcpAuthorSession(options) {
+    const protectedValues = [...new Set(options.context.endpoints.flatMap((endpoint) => [
+            endpoint.url,
+            ...endpoint.headers.flatMap((header) => {
+                const value = options.context.resolveSecret(header.valueRef);
+                return [value, value.startsWith('Bearer ') ? value.slice('Bearer '.length) : value];
+            }),
+        ]).filter((value) => value.length > 0))];
+    const createClient = options.createClient ?? spawnAcpClient;
+    const sensitiveValues = collectSensitiveEnvValues(Object.fromEntries(Object.entries(options.environment).filter((entry) => typeof entry[1] === 'string')));
+    let client;
+    const admission = await admitRuntimeLock(options.runtimeLock, {
+        provider: options.provider,
+        platform: process.platform,
+        architecture: process.arch,
+        resolvedExecutable: options.resolvedExecutable,
+        environment: options.environment,
+        forbiddenSecrets: protectedValues,
+        async initializeControlPlane(commandPath, args) {
+            const initialized = createClient({
+                provider: options.provider,
+                command: commandPath,
+                args,
+                cwd: options.cwd,
+                environment: options.environment,
+                protectedValues,
+            });
+            client = initialized;
+            try {
+                const normalizedHandshake = await initialized.initialize();
+                return {
+                    normalizedHandshake,
+                    capabilities: options.runtimeLock.capabilities,
+                    close: () => initialized.close(),
+                };
+            }
+            catch (error) {
+                await initialized.close().catch(() => undefined);
+                throw error;
+            }
+        },
+    });
+    const admittedClient = client;
+    if (!admittedClient)
+        throw new Error('RUNTIME_NOT_ADMITTED: ACP client unavailable');
+    try {
+        const projected = projectEndpoints(options.context.endpoints, admission.profile);
+        if (!Array.isArray(projected))
+            throw new Error(`RUNTIME_NOT_ADMITTED: ${projected.reason}`);
+        const mcpServers = projected.flatMap((plan) => {
+            const materialized = materializeProjection(plan, { resolve: options.context.resolveSecret });
+            if (materialized.kind !== 'acp-session' || materialized.provider !== options.provider) {
+                throw new Error('RUNTIME_NOT_ADMITTED: ACP projection materialized for another provider');
+            }
+            return materialized.mcpServers.map((server) => ({
+                type: server.type,
+                name: server.name,
+                url: server.url,
+                headers: server.headers.map((header) => ({ ...header })),
+            }));
+        });
+        const assertProtectedSurfacesClean = async () => {
+            for (const value of protectedValues) {
+                const scans = await scanBearerSurfaces(options.scanRoots, value);
+                if (scans.some((entry) => entry.status !== 'clean')) {
+                    throw new Error('ACP protected projection reached a writable or unreadable surface');
+                }
+            }
+            if (admittedClient.inboundSecretSeen())
+                throw new Error('ACP provider reflected a protected control-plane value');
+        };
+        const session = await createAcpAuthorSession({
+            provider: options.provider,
+            client: admittedClient,
+            mcpServers,
+            normalizeToolName: options.normalizeToolName,
+            protectedValues,
+            sensitiveValues,
+            assertProtectedSurfacesClean,
+        });
+        if (admittedClient.controlPlaneSecretFrames() !== 1 || admittedClient.inboundSecretSeen()) {
+            throw new Error('RUNTIME_NOT_ADMITTED: ACP secret isolation failed during session admission');
+        }
+        await assertProtectedSurfacesClean();
+        return createAcpScenarioAttachment(session);
+    }
+    catch (error) {
+        try {
+            await admission.controlPlane.close();
+        }
+        catch (cleanupError) {
+            throw new AggregateError([error, cleanupError], 'ACP author-session setup and cleanup failed');
+        }
+        throw error;
+    }
+}
+async function settlesWithin(promise, timeoutMs) {
+    let timer;
+    return Promise.race([
+        promise.then(() => true),
+        new Promise((resolve) => { timer = setTimeout(() => resolve(false), timeoutMs); }),
+    ]).finally(() => { if (timer)
+        clearTimeout(timer); });
+}

package/dist/internal/direct-mcp-v2/acp-client.d.ts

@@ -0,0 +1,70 @@
+import { type ChildProcessWithoutNullStreams } from 'node:child_process';
+import type { JsonObject, JsonValue } from './types.js';
+export type JsonRpcMessage = JsonObject;
+export type AcpNotificationCheckpoint = number;
+export type AcpPermissionRequest = {
+    sessionId?: string;
+    toolCallId?: string;
+    options: readonly {
+        optionId: string;
+        kind: string;
+    }[];
+};
+export type AcpClientRequestHandler = (method: string, params: JsonValue) => Promise<JsonValue>;
+export declare class AcpClientCore {
+    private readonly sendFrame;
+    private readonly onRequest;
+    private nextId;
+    private readonly pending;
+    private readonly notifications;
+    private nextNotificationSequence;
+    private closed;
+    private closeReason;
+    constructor(sendFrame: (message: JsonRpcMessage) => void, onRequest: AcpClientRequestHandler);
+    request(method: string, params: JsonObject, timeoutMs?: number): Promise<JsonValue>;
+    notify(method: string, params: JsonObject): void;
+    receiveLine(line: string): Promise<void>;
+    observedNotifications(): readonly JsonRpcMessage[];
+    notificationCheckpoint(): AcpNotificationCheckpoint;
+    drainNotifications(checkpoint: AcpNotificationCheckpoint): readonly JsonRpcMessage[];
+    close(reason?: string): void;
+}
+export type AcpNormalizedHandshake = JsonObject & {
+    normalizerVersion: 'pathgrade-acp-v1-capabilities-v1';
+    provider: 'cursor' | 'opencode';
+    protocolVersion: 1;
+    httpMcp: true;
+    sessionClose: boolean;
+};
+export type AcpPromptResult = {
+    stopReason: string;
+};
+export type AcpClient = {
+    initialize(): Promise<AcpNormalizedHandshake>;
+    newSession(mcpServers: readonly JsonObject[]): Promise<string>;
+    prompt(sessionId: string, text: string): Promise<AcpPromptResult>;
+    cancel(sessionId: string): void;
+    close(): Promise<void>;
+    setCancelling(value: boolean): void;
+    isOpen(): boolean;
+    controlPlaneSecretFrames(): number;
+    inboundSecretSeen(): boolean;
+    notificationCheckpoint(): AcpNotificationCheckpoint;
+    drainNotifications(checkpoint: AcpNotificationCheckpoint): readonly JsonRpcMessage[];
+    notifications(): readonly JsonRpcMessage[];
+};
+export type SpawnAcpClientOptions = {
+    provider: 'cursor' | 'opencode';
+    command: string;
+    args: readonly string[];
+    cwd: string;
+    environment: NodeJS.ProcessEnv;
+    protectedValues: readonly string[];
+    spawnProcess?: SpawnAcpProcess;
+};
+export type SpawnAcpProcess = (command: string, args: readonly string[], options: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    stdio: ['pipe', 'pipe', 'pipe'];
+}) => ChildProcessWithoutNullStreams;
+export declare function spawnAcpClient(options: SpawnAcpClientOptions): AcpClient;

package/dist/internal/direct-mcp-v2/acp-client.js

@@ -0,0 +1,310 @@
+/* oxlint-disable anti-slop/no-unknown-parameters, anti-slop/no-runtime-typeof -- ACP frames are an external JSON-RPC trust boundary. */
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+function isJsonObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function jsonValue(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (Array.isArray(value))
+        return value.map(jsonValue);
+    if (value !== null && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, jsonValue(entry)]));
+    throw new Error('ACP response was not JSON');
+}
+function jsonObject(value) {
+    const parsed = jsonValue(value);
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+        throw new Error('ACP frame was not a JSON object');
+    return parsed;
+}
+function errorFromResponse(method, value) {
+    if (!isJsonObject(value))
+        return new Error(`${method} failed with an invalid JSON-RPC error`);
+    const rawMessage = value.message;
+    const code = value.code;
+    const message = typeof rawMessage === 'string' ? rawMessage : 'unknown ACP error';
+    return Object.assign(new Error(`${method} failed: ${message}`), {
+        code: typeof code === 'number' || typeof code === 'string' ? code : undefined,
+        data: value.data,
+    });
+}
+export class AcpClientCore {
+    sendFrame;
+    onRequest;
+    nextId = 1;
+    pending = new Map();
+    notifications = [];
+    nextNotificationSequence = 0;
+    closed = false;
+    closeReason = 'ACP client is closed';
+    constructor(sendFrame, onRequest) {
+        this.sendFrame = sendFrame;
+        this.onRequest = onRequest;
+    }
+    request(method, params, timeoutMs = 120_000) {
+        if (this.closed)
+            return Promise.reject(new Error(this.closeReason));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`ACP ${method} timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pending.set(id, { method, resolve, reject, timer });
+            this.sendFrame({ jsonrpc: '2.0', id, method, params });
+        });
+    }
+    notify(method, params) {
+        if (this.closed)
+            throw new Error(this.closeReason);
+        this.sendFrame({ jsonrpc: '2.0', method, params });
+    }
+    async receiveLine(line) {
+        let message;
+        try {
+            message = jsonObject(JSON.parse(line));
+        }
+        catch {
+            throw new Error('ACP emitted a non-JSON frame');
+        }
+        if (message.jsonrpc !== '2.0')
+            throw new Error('ACP emitted an invalid JSON-RPC frame');
+        const rawId = message.id;
+        const id = typeof rawId === 'string' || typeof rawId === 'number' ? rawId : undefined;
+        const rawMethod = message.method;
+        if (id !== undefined && rawMethod === undefined) {
+            const pending = this.pending.get(id);
+            if (!pending)
+                return;
+            this.pending.delete(id);
+            clearTimeout(pending.timer);
+            const responseError = message.error;
+            if (responseError !== undefined)
+                pending.reject(errorFromResponse(pending.method, responseError));
+            else
+                pending.resolve(message.result ?? null);
+            return;
+        }
+        if (typeof rawMethod !== 'string')
+            throw new Error('ACP JSON-RPC frame has no method');
+        if (id === undefined) {
+            this.notifications.push({ sequence: this.nextNotificationSequence++, message: jsonObject(message) });
+            return;
+        }
+        try {
+            const result = await this.onRequest(rawMethod, message.params ?? null);
+            this.sendFrame({ jsonrpc: '2.0', id, result });
+        }
+        catch (error) {
+            this.sendFrame({ jsonrpc: '2.0', id, error: { code: -32601, message: error instanceof Error ? error.message : String(error) } });
+        }
+    }
+    observedNotifications() {
+        return this.notifications.map(({ message }) => ({ ...message }));
+    }
+    notificationCheckpoint() {
+        return this.nextNotificationSequence;
+    }
+    drainNotifications(checkpoint) {
+        if (!Number.isSafeInteger(checkpoint) || checkpoint < 0 || checkpoint > this.nextNotificationSequence) {
+            throw new Error('invalid ACP notification checkpoint');
+        }
+        const drained = [];
+        for (let index = this.notifications.length - 1; index >= 0; index--) {
+            const entry = this.notifications[index];
+            if (entry.sequence < checkpoint)
+                continue;
+            drained.unshift({ ...entry.message });
+            this.notifications.splice(index, 1);
+        }
+        return drained;
+    }
+    close(reason = 'ACP client closed') {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.closeReason = reason;
+        for (const request of this.pending.values()) {
+            clearTimeout(request.timer);
+            request.reject(new Error(reason));
+        }
+        this.pending.clear();
+    }
+}
+function normalizeHandshake(provider, value) {
+    if (!isJsonObject(value) || value.protocolVersion !== 1 || !isJsonObject(value.agentCapabilities))
+        throw new Error('ACP initialize did not return protocol v1 capabilities');
+    const mcp = value.agentCapabilities.mcpCapabilities;
+    if (!isJsonObject(mcp) || mcp.http !== true)
+        throw new Error('ACP initialize did not advertise HTTP MCP');
+    const session = value.agentCapabilities.sessionCapabilities;
+    return {
+        normalizerVersion: 'pathgrade-acp-v1-capabilities-v1',
+        provider,
+        protocolVersion: 1,
+        httpMcp: true,
+        sessionClose: session !== undefined && isJsonObject(session) && session.close !== undefined && isJsonObject(session.close),
+    };
+}
+function readSessionId(value) {
+    const sessionId = isJsonObject(value) ? value.sessionId : undefined;
+    if (typeof sessionId !== 'string' || sessionId.length === 0)
+        throw new Error('ACP session/new returned no sessionId');
+    return sessionId;
+}
+function readPromptResult(value) {
+    const stopReason = isJsonObject(value) ? value.stopReason : undefined;
+    if (typeof stopReason !== 'string')
+        throw new Error('ACP session/prompt returned no stopReason');
+    return { stopReason };
+}
+function permissionRequest(params) {
+    if (!isJsonObject(params))
+        throw new Error('invalid ACP permission request');
+    const toolCall = params.toolCall !== undefined && isJsonObject(params.toolCall) ? params.toolCall : undefined;
+    const rawOptions = params.options;
+    if (!Array.isArray(rawOptions))
+        throw new Error('invalid ACP permission options');
+    const options = rawOptions.map((entry) => {
+        const optionId = isJsonObject(entry) ? entry.optionId : undefined;
+        const kind = isJsonObject(entry) ? entry.kind : undefined;
+        if (typeof optionId !== 'string' || typeof kind !== 'string')
+            throw new Error('invalid ACP permission option');
+        return { optionId, kind };
+    });
+    return {
+        sessionId: typeof params.sessionId === 'string' ? params.sessionId : undefined,
+        toolCallId: toolCall && typeof toolCall.toolCallId === 'string' ? toolCall.toolCallId : undefined,
+        options,
+    };
+}
+function includesProtectedValue(value, protectedValues) {
+    return protectedValues.some((secret) => secret.length > 0 && value.includes(secret));
+}
+export function spawnAcpClient(options) {
+    const argv = [options.command, ...options.args].join('\u0000');
+    const environmentText = Object.entries(options.environment).map(([name, value]) => `${name}=${value ?? ''}`).join('\u0000');
+    if (includesProtectedValue(argv, options.protectedValues) || includesProtectedValue(environmentText, options.protectedValues)) {
+        throw new Error('ACP protected value reached child argv or environment');
+    }
+    const spawnProcess = options.spawnProcess ?? ((command, args, childOptions) => spawn(command, [...args], childOptions));
+    const child = spawnProcess(options.command, options.args, { cwd: options.cwd, env: options.environment, stdio: ['pipe', 'pipe', 'pipe'] });
+    let open = true;
+    let cancelling = false;
+    let sessionClose = false;
+    let sessionId;
+    let outboundSecretFrames = 0;
+    let reflectedSecret = false;
+    const exit = new Promise((resolve) => {
+        child.once('exit', (code, signal) => {
+            open = false;
+            core.close(`ACP provider exited (${code ?? signal ?? 'unknown'})`);
+            resolve();
+        });
+        child.once('error', (error) => {
+            open = false;
+            core.close(`ACP provider failed: ${error.message}`);
+            resolve();
+        });
+    });
+    const core = new AcpClientCore((message) => {
+        const frame = JSON.stringify(message);
+        if (includesProtectedValue(frame, options.protectedValues))
+            outboundSecretFrames += 1;
+        child.stdin.write(`${frame}\n`);
+    }, async (method, params) => {
+        if (method !== 'session/request_permission')
+            throw new Error(`unsupported ACP client request ${method}`);
+        const request = permissionRequest(params);
+        if (cancelling)
+            return { outcome: { outcome: 'cancelled' } };
+        const allowed = request.options.find((entry) => entry.kind === 'allow_once');
+        if (!allowed)
+            throw new Error('ACP permission request has no allow_once option');
+        return { outcome: { outcome: 'selected', optionId: allowed.optionId } };
+    });
+    const lines = createInterface({ input: child.stdout });
+    lines.on('line', (line) => {
+        if (includesProtectedValue(line, options.protectedValues)) {
+            reflectedSecret = true;
+            core.close('ACP provider reflected a protected control-plane value');
+            return;
+        }
+        void core.receiveLine(line).catch((error) => core.close(error instanceof Error ? error.message : String(error)));
+    });
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => {
+        if (includesProtectedValue(chunk, options.protectedValues)) {
+            reflectedSecret = true;
+            core.close('ACP provider reflected a protected control-plane value');
+        }
+    });
+    return {
+        async initialize() {
+            const raw = await core.request('initialize', {
+                protocolVersion: 1,
+                clientCapabilities: {},
+                clientInfo: { name: 'pathgrade-direct-mcp', title: 'Pathgrade direct MCP', version: '2.0.0' },
+            }, 30_000);
+            const normalized = normalizeHandshake(options.provider, raw);
+            sessionClose = normalized.sessionClose;
+            return normalized;
+        },
+        async newSession(mcpServers) {
+            sessionId = readSessionId(await core.request('session/new', { cwd: options.cwd, mcpServers: [...mcpServers] }, 30_000));
+            return sessionId;
+        },
+        async prompt(currentSessionId, text) {
+            return readPromptResult(await core.request('session/prompt', { sessionId: currentSessionId, prompt: [{ type: 'text', text }] }, 180_000));
+        },
+        cancel(currentSessionId) { core.notify('session/cancel', { sessionId: currentSessionId }); },
+        async close() {
+            if (!open) {
+                await exit;
+                if (reflectedSecret)
+                    throw new Error('ACP provider reflected a protected control-plane value');
+                return;
+            }
+            if (sessionId && sessionClose)
+                await core.request('session/close', { sessionId }, 10_000).catch(() => undefined);
+            core.close();
+            lines.close();
+            child.stdin.end();
+            if (await waitForExit(exit, 1_000)) {
+                if (reflectedSecret)
+                    throw new Error('ACP provider reflected a protected control-plane value');
+                return;
+            }
+            child.kill('SIGTERM');
+            if (await waitForExit(exit, 2_000)) {
+                if (reflectedSecret)
+                    throw new Error('ACP provider reflected a protected control-plane value');
+                return;
+            }
+            child.kill('SIGKILL');
+            if (!await waitForExit(exit, 2_000))
+                throw new Error('ACP provider did not exit after SIGKILL');
+            if (reflectedSecret)
+                throw new Error('ACP provider reflected a protected control-plane value');
+        },
+        setCancelling(value) { cancelling = value; },
+        isOpen: () => open,
+        controlPlaneSecretFrames: () => outboundSecretFrames,
+        inboundSecretSeen: () => reflectedSecret,
+        notificationCheckpoint: () => core.notificationCheckpoint(),
+        drainNotifications: (checkpoint) => core.drainNotifications(checkpoint),
+        notifications: () => core.observedNotifications(),
+    };
+}
+async function waitForExit(exit, timeoutMs) {
+    let timer;
+    return Promise.race([
+        exit.then(() => true),
+        new Promise((resolve) => { timer = setTimeout(() => resolve(false), timeoutMs); }),
+    ]).finally(() => { if (timer)
+        clearTimeout(timer); });
+}

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

@@ -0,0 +1,38 @@
+import { spawnAcpClient } from './acp-client.js';
+import { type CleanupReport } from './cleanup.js';
+import type { EvidenceEnvelope, RuntimeCapabilityProfile, ScenarioArtifact, ScenarioMachineV2 } from './types.js';
+export type AcpDirectMcpChecks = {
+    runtimeAdmitted: boolean;
+    secretFreeProject: boolean;
+    directCall: boolean;
+    structuredToolError: boolean;
+    fencedCancellation: boolean;
+    providerTerminal: boolean;
+    hostQuiescent: boolean;
+    postCancelReuse: boolean;
+    privateReplay: boolean;
+    cleanup: boolean;
+};
+export type AcpDirectMcpTrialResult = {
+    selected: true;
+    profileFingerprint: string;
+    artifact: ScenarioArtifact;
+    evidence: readonly EvidenceEnvelope[];
+    checks: AcpDirectMcpChecks;
+    cleanup: CleanupReport;
+    cancellationStatus: string;
+};
+export type AcpDirectMcpOptions = {
+    provider: 'cursor' | 'opencode';
+    scenario: ScenarioMachineV2;
+    environment: NodeJS.ProcessEnv;
+    profile: RuntimeCapabilityProfile;
+    artifactDirectory?: string;
+    createClient?: typeof spawnAcpClient;
+    localHomeLinks?: readonly {
+        relativePath: string;
+        hostPath: string;
+    }[];
+};
+export declare function curateAcpProcessEnvironment(environment: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function runAcpDirectMcpTrial(options: AcpDirectMcpOptions): Promise<AcpDirectMcpTrialResult>;