@wix/pathgrade 1.0.25 → 1.0.27

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

@@ -0,0 +1,147 @@
+import { buildSummary } from '../../tool-events.js';
+import { sanitizePersistenceValue, sanitizeToolEventResult } from '../../tool-event-results.js';
+export const ACP_AUTHOR_TRACE_MAX_CHARS = 64 * 1024;
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function updateFromNotification(message) {
+    if (message.method !== 'session/update')
+        throw new Error('ACP author projector received a non-update notification');
+    const params = object(message.params);
+    const update = object(params?.update);
+    if (!update || typeof update.sessionUpdate !== 'string')
+        throw new Error('ACP session/update contained no typed update');
+    return update;
+}
+function toolUpdate(update, priorTitle) {
+    if (update.sessionUpdate !== 'tool_call' && update.sessionUpdate !== 'tool_call_update')
+        throw new Error('ACP update was not a tool update');
+    const title = typeof update.title === 'string' && update.title.length > 0 ? update.title : priorTitle;
+    if (!title)
+        throw new Error('ACP tool update contained no title');
+    const rawInput = update.rawInput === undefined ? undefined : object(update.rawInput);
+    if (update.rawInput !== undefined && !rawInput)
+        throw new Error('ACP tool update rawInput was not an object');
+    const rawOutput = update.rawOutput === undefined ? undefined : object(update.rawOutput);
+    if (update.rawOutput !== undefined && !rawOutput)
+        throw new Error('ACP tool update rawOutput was not an object');
+    const output = update.output ?? rawOutput?.output;
+    const error = update.error ?? rawOutput?.error;
+    return {
+        sessionUpdate: update.sessionUpdate,
+        title,
+        ...(typeof update.toolCallId === 'string' ? { toolCallId: update.toolCallId } : {}),
+        ...(typeof update.status === 'string' ? { status: update.status } : {}),
+        ...(rawInput ? { rawInput } : {}),
+        ...(output !== undefined ? { output } : {}),
+        ...(error !== undefined ? { error } : {}),
+    };
+}
+function textValue(value) {
+    if (value === undefined)
+        return undefined;
+    return typeof value === 'string' ? value : JSON.stringify(value);
+}
+export function projectAcpAuthorTurn(input) {
+    const protectedValues = input.protectedValues ?? [];
+    const redactionValues = [...new Set([...protectedValues, ...(input.sensitiveValues ?? [])])];
+    const serialized = JSON.stringify({ terminal: input.terminal, notifications: input.notifications });
+    if (protectedValues.some((value) => value.length > 0 && serialized.includes(value))) {
+        throw new Error('ACP provider reflected a protected control-plane value');
+    }
+    const assistantChunks = [];
+    const toolEvents = [];
+    const trace = [];
+    const toolCalls = new Map();
+    let providerError = false;
+    for (const notification of input.notifications) {
+        const update = updateFromNotification(notification);
+        if (update.sessionUpdate === 'agent_message_chunk') {
+            const content = object(update.content);
+            const text = typeof update.text === 'string'
+                ? update.text
+                : typeof content?.text === 'string' ? content.text : undefined;
+            if (text === undefined)
+                throw new Error('ACP agent message chunk contained no text');
+            assistantChunks.push(text);
+            trace.push({ sessionUpdate: 'agent_message_chunk', text });
+            continue;
+        }
+        if (update.sessionUpdate === 'error') {
+            if (typeof update.message !== 'string' || update.message.length === 0)
+                throw new Error('ACP error update contained no message');
+            providerError = true;
+            trace.push({ sessionUpdate: 'error', message: update.message });
+            continue;
+        }
+        if (update.sessionUpdate !== 'tool_call' && update.sessionUpdate !== 'tool_call_update') {
+            trace.push({ sessionUpdate: update.sessionUpdate });
+            continue;
+        }
+        const toolCallId = typeof update.toolCallId === 'string' ? update.toolCallId : undefined;
+        const prior = toolCallId ? toolCalls.get(toolCallId) : undefined;
+        const current = toolUpdate(update, prior?.title);
+        if (prior && prior.title !== current.title)
+            throw new Error('ACP tool update changed title for one call');
+        const correlated = {
+            ...prior,
+            ...current,
+            ...(current.rawInput ?? prior?.rawInput ? { rawInput: current.rawInput ?? prior?.rawInput } : {}),
+        };
+        trace.push({
+            sessionUpdate: current.sessionUpdate,
+            title: current.title,
+            ...(current.status ? { status: current.status } : {}),
+            ...(current.rawInput ? { rawInput: current.rawInput } : {}),
+        });
+        if (current.status !== 'completed' && current.status !== 'failed') {
+            if (current.toolCallId)
+                toolCalls.set(current.toolCallId, correlated);
+            continue;
+        }
+        const terminalFingerprint = JSON.stringify({
+            status: correlated.status,
+            rawInput: correlated.rawInput,
+            output: correlated.output,
+            error: correlated.error,
+        });
+        if (prior?.terminalFingerprint !== undefined) {
+            if (prior.terminalFingerprint !== terminalFingerprint)
+                throw new Error('ACP tool call emitted conflicting terminal updates');
+            continue;
+        }
+        if (current.toolCallId)
+            toolCalls.set(current.toolCallId, { ...correlated, terminalFingerprint });
+        const normalized = input.normalizeToolName(correlated.title);
+        const resultText = textValue(correlated.status === 'completed' ? correlated.output : correlated.error);
+        toolEvents.push({
+            action: normalized.action,
+            provider: input.provider,
+            providerToolName: normalized.providerToolName,
+            ...(input.turnNumber !== undefined ? { turnNumber: input.turnNumber } : {}),
+            ...(correlated.rawInput ? { arguments: correlated.rawInput } : {}),
+            status: correlated.status === 'completed' ? 'completed' : 'error',
+            ...(resultText !== undefined ? { result: sanitizeToolEventResult({ content: resultText }, redactionValues) } : {}),
+            summary: buildSummary(normalized.action, normalized.providerToolName, correlated.rawInput),
+            confidence: normalized.action === 'unknown' ? 'low' : 'high',
+            rawSnippet: JSON.stringify(sanitizePersistenceValue({ title: normalized.providerToolName, status: correlated.status, rawInput: correlated.rawInput }, redactionValues)).slice(0, 2_000),
+        });
+    }
+    const assistantMessage = sanitizePersistenceValue(assistantChunks.join(''), redactionValues);
+    const rawTrace = JSON.stringify(sanitizePersistenceValue({
+        terminal: { stopReason: input.terminal.stopReason },
+        updates: trace,
+    }, redactionValues));
+    const traceOutput = rawTrace.length > ACP_AUTHOR_TRACE_MAX_CHARS
+        ? `${rawTrace.slice(0, ACP_AUTHOR_TRACE_MAX_CHARS - 1)}…`
+        : rawTrace;
+    return sanitizePersistenceValue({
+        rawOutput: traceOutput,
+        traceOutput,
+        assistantMessage,
+        visibleAssistantMessage: assistantMessage,
+        visibleAssistantMessageSource: 'assistant_message',
+        exitCode: input.terminal.stopReason === 'end_turn' && !providerError ? 0 : 1,
+        toolEvents,
+    }, redactionValues);
+}

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

@@ -0,0 +1,39 @@
+import type { AgentTurnResult } from '../../types.js';
+import { type RuntimeLock } from './runtime-lock.js';
+import { type AcpClient, type SpawnAcpClientOptions } from './acp-client.js';
+import { type AcpToolNameNormalizer } from './acp-author-projector.js';
+import type { JsonObject, ProviderId, ScenarioProviderAttachContext, ScenarioProviderAttachment } from './types.js';
+export type AcpAuthorSession = {
+    runTurn(message: string, turnNumber?: number): Promise<AgentTurnResult>;
+    interrupt(reason?: string): Promise<void>;
+    waitForTerminal(): Promise<void>;
+    close(): Promise<void>;
+};
+export type CreateAcpAuthorSessionOptions = {
+    provider: Extract<ProviderId, 'cursor' | 'opencode'>;
+    client: AcpClient;
+    mcpServers: readonly JsonObject[];
+    normalizeToolName: AcpToolNameNormalizer;
+    protectedValues?: readonly string[];
+    sensitiveValues?: readonly string[];
+    assertProtectedSurfacesClean?(): Promise<void>;
+    closeJoinTimeoutMs?: number;
+};
+export type AttachAcpAuthorSessionOptions = {
+    provider: Extract<ProviderId, 'cursor' | 'opencode'>;
+    context: ScenarioProviderAttachContext;
+    runtimeLock: RuntimeLock;
+    resolvedExecutable: string;
+    cwd: string;
+    environment: NodeJS.ProcessEnv;
+    scanRoots: readonly string[];
+    normalizeToolName: AcpToolNameNormalizer;
+    createClient?: (options: SpawnAcpClientOptions) => AcpClient;
+};
+export declare function createAcpAuthorSession(options: CreateAcpAuthorSessionOptions): Promise<AcpAuthorSession>;
+export declare function createAcpScenarioAttachment(session: AcpAuthorSession): ScenarioProviderAttachment<AcpAuthorSession>;
+/**
+ * P4/P5 provider seam: attach one exact, relocatable ACP runtime to the
+ * coordinator and return the reusable author session as its opaque value.
+ */
+export declare function attachAcpAuthorSession(options: AttachAcpAuthorSessionOptions): Promise<ScenarioProviderAttachment<AcpAuthorSession>>;

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;