@agent-link/agent 0.1.334 → 0.1.335

package/dist/copilot-command-bridge.js

@@ -1,654 +0,0 @@
-import { spawn } from 'child_process';
-import { randomUUID } from 'crypto';
-import { existsSync, readFileSync } from 'fs';
-import { dirname, join } from 'path';
-import { platform } from 'os';
-import { Readable, Writable } from 'stream';
-import * as acp from '@agentclientprotocol/sdk';
-import { createMessageConnection, StreamMessageReader, StreamMessageWriter, } from 'vscode-jsonrpc/node.js';
-import { getProvider, resolveProviderCommand } from './providers.js';
-import { getCleanEnv, resolveExecutablePath } from './sdk.js';
-const SDK_START_TIMEOUT_MS = 30_000;
-const SDK_REQUEST_TIMEOUT_MS = 30_000;
-const SDK_STOP_TIMEOUT_MS = 5_000;
-const ACP_SESSION_TIMEOUT_MS = 90_000;
-const ACP_PROMPT_TIMEOUT_MS = 15 * 60_000;
-const SUPPORTED_COMMANDS = ['compact', 'plan', 'goal'];
-const sessionLocks = new Map();
-function withTimeout(promise, timeoutMs, label) {
-    return new Promise((resolvePromise, rejectPromise) => {
-        const timer = setTimeout(() => rejectPromise(new Error(`${label} timed out`)), timeoutMs);
-        promise.then(value => {
-            clearTimeout(timer);
-            resolvePromise(value);
-        }, error => {
-            clearTimeout(timer);
-            rejectPromise(error);
-        });
-    });
-}
-function resolveDirectExecution(command) {
-    if (platform() !== 'win32' || !command.toLowerCase().endsWith('.cmd'))
-        return null;
-    const baseDir = dirname(command);
-    const loader = join(baseDir, 'node_modules', '@github', 'copilot', 'npm-loader.js');
-    if (existsSync(loader))
-        return { command: process.execPath, prefixArgs: [loader] };
-    try {
-        const match = readFileSync(command, 'utf8').match(/"%~dp0\\([^"\r\n]+\.js)"/);
-        if (match) {
-            const script = join(baseDir, match[1]);
-            if (existsSync(script))
-                return { command: process.execPath, prefixArgs: [script] };
-        }
-    }
-    catch {
-        // Fall through to cmd.exe below.
-    }
-    return null;
-}
-export function resolveCopilotCommandSpawn(providerId, workDir) {
-    const provider = getProvider(providerId);
-    const isDefaultCopilot = providerId === 'copilot'
-        && provider.command === 'copilot'
-        && !provider.args?.length
-        && !provider.shell;
-    const resolved = isDefaultCopilot
-        ? { command: resolveExecutablePath('copilot') || 'copilot', prefixArgs: [], spawnOpts: {} }
-        : resolveProviderCommand(provider);
-    const runtimeArgs = providerId === 'agency-copilot'
-        ? [...resolved.prefixArgs, '--acp']
-        : [...resolved.prefixArgs, '--headless', '--no-auto-update', '--stdio'];
-    const direct = resolveDirectExecution(resolved.command);
-    if (direct) {
-        return {
-            command: direct.command,
-            args: [...direct.prefixArgs, ...runtimeArgs],
-            options: {
-                cwd: provider.cwd || workDir,
-                env: { ...getCleanEnv(), ...(provider.env || {}) },
-                stdio: ['pipe', 'pipe', 'pipe'],
-                windowsHide: true,
-            },
-        };
-    }
-    if (platform() === 'win32' && resolved.command.toLowerCase().endsWith('.cmd')) {
-        return {
-            command: process.env.COMSPEC || 'cmd.exe',
-            args: ['/d', '/s', '/c', resolved.command, ...runtimeArgs],
-            options: {
-                cwd: provider.cwd || workDir,
-                env: { ...getCleanEnv(), ...(provider.env || {}) },
-                stdio: ['pipe', 'pipe', 'pipe'],
-                windowsHide: true,
-            },
-        };
-    }
-    return {
-        command: resolved.command,
-        args: runtimeArgs,
-        options: {
-            cwd: provider.cwd || workDir,
-            env: { ...getCleanEnv(), ...(provider.env || {}) },
-            stdio: ['pipe', 'pipe', 'pipe'],
-            windowsHide: true,
-            ...resolved.spawnOpts,
-        },
-    };
-}
-export class CopilotCommandRuntime {
-    options;
-    child = null;
-    connection = null;
-    acpConnection = null;
-    acpSessions = new Map();
-    acpCommandWaiters = new Map();
-    acpToolNames = new Map();
-    stderr = '';
-    releaseSessionLock = null;
-    constructor(options) {
-        this.options = options;
-    }
-    async start() {
-        if (this.connection || this.acpConnection)
-            return;
-        const spec = resolveCopilotCommandSpawn(this.options.providerId, this.options.workDir);
-        const child = spawn(spec.command, spec.args, spec.options);
-        this.child = child;
-        child.stderr?.on('data', chunk => {
-            if (this.stderr.length < 16_384)
-                this.stderr += String(chunk);
-        });
-        if (!child.stdout || !child.stdin) {
-            throw new Error('Copilot SDK runtime did not expose stdio pipes');
-        }
-        if (this.usesAgencyAcp()) {
-            const client = acp.client({ name: 'agentlink' })
-                .onNotification(acp.methods.client.session.update, ({ params }) => {
-                this.handleAcpSessionUpdate(params);
-            })
-                .onRequest(acp.methods.client.session.requestPermission, ({ params }) => {
-                const selected = params.options.find(option => option.kind === 'allow_always')
-                    || params.options.find(option => option.kind === 'allow_once');
-                return selected
-                    ? { outcome: { outcome: 'selected', optionId: selected.optionId } }
-                    : { outcome: { outcome: 'cancelled' } };
-            })
-                .onRequest(acp.methods.client.elicitation.create, ({ params }) => {
-                if (!this.options.onAcpElicitationRequest) {
-                    return { action: 'cancel' };
-                }
-                return this.options.onAcpElicitationRequest(params);
-            });
-            const stream = acp.ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
-            const connection = client.connect(stream);
-            this.acpConnection = connection;
-            try {
-                await withTimeout(connection.agent.request(acp.methods.agent.initialize, {
-                    protocolVersion: acp.PROTOCOL_VERSION,
-                    clientCapabilities: {
-                        session: { compaction: {} },
-                        ...(this.options.onAcpElicitationRequest
-                            ? { elicitation: { form: {} } }
-                            : {}),
-                    },
-                    clientInfo: { name: 'agentlink', version: '1' },
-                }), SDK_START_TIMEOUT_MS, 'Agency Copilot ACP startup');
-            }
-            catch (error) {
-                const detail = this.stderr.trim().split(/\r?\n/).slice(-4).join('\n');
-                await this.stop();
-                throw new Error(`${error.message}${detail ? `\n${detail}` : ''}`);
-            }
-            return;
-        }
-        const connection = createMessageConnection(new StreamMessageReader(child.stdout), new StreamMessageWriter(child.stdin));
-        this.connection = connection;
-        connection.onNotification('session.event', notification => {
-            if (!notification || typeof notification !== 'object')
-                return;
-            const value = notification;
-            if (typeof value.sessionId === 'string'
-                && value.event
-                && typeof value.event === 'object') {
-                this.options.onSessionEvent?.(value.sessionId, value.event);
-            }
-        });
-        connection.onRequest('userInput.request', async (params) => {
-            if (!this.options.onUserInputRequest || !isRecord(params)) {
-                throw new Error('Copilot user input handler is unavailable');
-            }
-            const sessionId = typeof params.sessionId === 'string' ? params.sessionId : '';
-            const question = typeof params.question === 'string' ? params.question : '';
-            if (!sessionId || !question)
-                throw new Error('Invalid Copilot user input request');
-            return this.options.onUserInputRequest(sessionId, {
-                question,
-                choices: Array.isArray(params.choices)
-                    ? params.choices.filter((value) => typeof value === 'string')
-                    : undefined,
-                allowFreeform: typeof params.allowFreeform === 'boolean'
-                    ? params.allowFreeform
-                    : undefined,
-            });
-        });
-        connection.onRequest('exitPlanMode.request', async (params) => {
-            if (!this.options.onExitPlanModeRequest || !isRecord(params)) {
-                throw new Error('Copilot Plan decision handler is unavailable');
-            }
-            const sessionId = typeof params.sessionId === 'string' ? params.sessionId : '';
-            const summary = typeof params.summary === 'string' ? params.summary : '';
-            const actions = Array.isArray(params.actions)
-                ? params.actions.filter((value) => typeof value === 'string')
-                : [];
-            const recommendedAction = typeof params.recommendedAction === 'string'
-                ? params.recommendedAction
-                : actions[0] || '';
-            if (!sessionId || !summary)
-                throw new Error('Invalid Copilot Plan decision request');
-            return this.options.onExitPlanModeRequest(sessionId, {
-                summary,
-                planContent: typeof params.planContent === 'string' ? params.planContent : undefined,
-                actions,
-                recommendedAction,
-            });
-        });
-        connection.listen();
-        try {
-            await withTimeout(connection.sendRequest('connect', {}), SDK_START_TIMEOUT_MS, 'Copilot SDK startup');
-        }
-        catch (error) {
-            const detail = this.stderr.trim().split(/\r?\n/).slice(-4).join('\n');
-            await this.stop();
-            throw new Error(`${error.message}${detail ? `\n${detail}` : ''}`);
-        }
-    }
-    async request(method, params = {}, timeoutMs = SDK_REQUEST_TIMEOUT_MS) {
-        if (!this.connection)
-            throw new Error('Copilot SDK runtime is not started');
-        return withTimeout(this.connection.sendRequest(method, params), timeoutMs, method);
-    }
-    async openSession(sessionId, options = {}) {
-        if (this.usesAgencyAcp()) {
-            return this.openAcpSession(sessionId);
-        }
-        const activeSessionId = sessionId || randomUUID();
-        await this.acquireSessionLock(activeSessionId);
-        const method = sessionId ? 'session.resume' : 'session.create';
-        let response;
-        try {
-            response = await this.request(method, {
-                sessionId: activeSessionId,
-                clientName: 'agentlink',
-                workingDirectory: this.options.workDir,
-                model: options.model,
-                contextTier: options.contextTier,
-                reasoningEffort: options.reasoningEffort,
-                streaming: true,
-                includeSubAgentStreamingEvents: true,
-                requestUserInput: !!this.options.onUserInputRequest,
-                requestExitPlanMode: !!this.options.onExitPlanModeRequest,
-                toolFilterPrecedence: 'excluded',
-                envValueMode: 'direct',
-                ...(sessionId ? { disableResume: true, continuePendingWork: false } : {}),
-            });
-        }
-        catch (error) {
-            this.releaseSessionLock?.();
-            throw error;
-        }
-        const returnedSessionId = response.sessionId || activeSessionId;
-        if (returnedSessionId !== activeSessionId) {
-            throw new Error(`Copilot SDK returned unexpected session ID ${returnedSessionId}`);
-        }
-        return returnedSessionId;
-    }
-    async acquireSessionLock(sessionId) {
-        if (this.releaseSessionLock) {
-            throw new Error('Copilot SDK runtime already owns a session lock');
-        }
-        const previous = sessionLocks.get(sessionId) || Promise.resolve();
-        let releaseCurrent;
-        const current = new Promise(resolvePromise => {
-            releaseCurrent = resolvePromise;
-        });
-        const tail = previous.then(() => current, () => current);
-        sessionLocks.set(sessionId, tail);
-        await previous.catch(() => { });
-        this.releaseSessionLock = () => {
-            releaseCurrent();
-            if (sessionLocks.get(sessionId) === tail)
-                sessionLocks.delete(sessionId);
-            this.releaseSessionLock = null;
-        };
-    }
-    async listSessionCommands(sessionId) {
-        if (this.usesAgencyAcp()) {
-            const current = this.acpSessions.get(sessionId)?.commands;
-            if (current)
-                return current;
-            return withTimeout(new Promise(resolvePromise => {
-                const waiters = this.acpCommandWaiters.get(sessionId) || new Set();
-                waiters.add(resolvePromise);
-                this.acpCommandWaiters.set(sessionId, waiters);
-            }), SDK_REQUEST_TIMEOUT_MS, 'Agency Copilot command catalog');
-        }
-        return normalizeCopilotCommands(await this.request('session.commands.list', {
-            sessionId,
-            includeBuiltins: true,
-            includeSkills: true,
-            includeClientCommands: true,
-        }));
-    }
-    async invokeCommand(sessionId, name, input) {
-        if (this.usesAgencyAcp()) {
-            await this.requestAcp(acp.methods.agent.session.prompt, {
-                sessionId,
-                prompt: [{
-                        type: 'text',
-                        text: input.trim() ? `/${name} ${input}` : `/${name}`,
-                    }],
-            }, ACP_PROMPT_TIMEOUT_MS);
-            return { kind: 'completed' };
-        }
-        return this.request('session.commands.invoke', { sessionId, name, input });
-    }
-    async setMode(sessionId, mode) {
-        if (this.usesAgencyAcp()) {
-            const state = this.acpSessions.get(sessionId);
-            const modeId = state?.modes?.availableModes.find(value => normalizeAcpMode(value.id) === mode)?.id
-                || mode;
-            await this.requestAcp(acp.methods.agent.session.setMode, { sessionId, modeId });
-            if (state?.modes)
-                state.modes.currentModeId = modeId;
-            return;
-        }
-        await this.request('session.mode.set', { sessionId, mode });
-    }
-    async getMode(sessionId) {
-        if (this.usesAgencyAcp()) {
-            return normalizeAcpMode(this.acpSessions.get(sessionId)?.modes?.currentModeId);
-        }
-        return this.request('session.mode.get', { sessionId });
-    }
-    async enableAllowAll(sessionId) {
-        if (this.usesAgencyAcp())
-            return;
-        await this.request('session.permissions.setMode', {
-            sessionId,
-            mode: 'allow-all',
-            source: 'rpc',
-        });
-    }
-    async send(sessionId, prompt, displayPrompt) {
-        if (this.usesAgencyAcp()) {
-            await this.requestAcp(acp.methods.agent.session.prompt, { sessionId, prompt: [{ type: 'text', text: displayPrompt || prompt }] }, ACP_PROMPT_TIMEOUT_MS);
-            return;
-        }
-        await this.request('session.send', {
-            sessionId,
-            prompt,
-            displayPrompt,
-            wait: true,
-        }, ACP_PROMPT_TIMEOUT_MS);
-    }
-    async abort(sessionId) {
-        if (this.usesAgencyAcp()) {
-            await this.notifyAcp(acp.methods.agent.session.cancel, { sessionId });
-            return;
-        }
-        await this.request('session.abort', { sessionId });
-    }
-    async abortManualCompaction(sessionId) {
-        if (this.usesAgencyAcp()) {
-            await this.notifyAcp(acp.methods.agent.session.cancel, { sessionId });
-            return;
-        }
-        await this.request('session.history.abortManualCompaction', { sessionId });
-    }
-    async destroySession(sessionId) {
-        if (this.usesAgencyAcp()) {
-            try {
-                await this.requestAcp(acp.methods.agent.session.close, { sessionId });
-            }
-            catch {
-                // ACP connection shutdown below releases any remaining session resources.
-            }
-            this.acpSessions.delete(sessionId);
-            return;
-        }
-        try {
-            await this.request('session.destroy', { sessionId });
-        }
-        catch {
-            // Runtime shutdown below also releases any remaining session handles.
-        }
-    }
-    async deleteSession(sessionId) {
-        if (this.usesAgencyAcp())
-            return;
-        await this.request('session.delete', { sessionId });
-    }
-    async stop() {
-        const connection = this.connection;
-        const acpConnection = this.acpConnection;
-        const child = this.child;
-        this.connection = null;
-        this.acpConnection = null;
-        this.child = null;
-        if (acpConnection)
-            acpConnection.close();
-        if (connection) {
-            try {
-                await withTimeout(connection.sendRequest('runtime.shutdown', {}), SDK_STOP_TIMEOUT_MS, 'Copilot SDK shutdown');
-            }
-            catch {
-                // Force termination below is the bounded fallback.
-            }
-            connection.dispose();
-        }
-        if (child && !child.killed)
-            child.kill();
-        this.acpSessions.clear();
-        this.acpCommandWaiters.clear();
-        this.acpToolNames.clear();
-        this.releaseSessionLock?.();
-    }
-    usesAgencyAcp() {
-        return this.options.providerId === 'agency-copilot';
-    }
-    async openAcpSession(sessionId) {
-        const lockId = sessionId || randomUUID();
-        await this.acquireSessionLock(lockId);
-        try {
-            if (sessionId) {
-                const state = this.acpSessions.get(sessionId) || {};
-                state.suppressEvents = true;
-                this.acpSessions.set(sessionId, state);
-            }
-            const response = sessionId
-                ? await this.requestAcp(acp.methods.agent.session.load, { sessionId, cwd: this.options.workDir, mcpServers: [] }, ACP_SESSION_TIMEOUT_MS)
-                : await this.requestAcp(acp.methods.agent.session.new, { cwd: this.options.workDir, mcpServers: [] }, ACP_SESSION_TIMEOUT_MS);
-            const activeSessionId = sessionId || response.sessionId;
-            if (!activeSessionId)
-                throw new Error('Agency Copilot ACP did not return a session ID');
-            const state = this.acpSessions.get(activeSessionId) || {};
-            if (response && 'modes' in response)
-                state.modes = response.modes;
-            state.suppressEvents = false;
-            this.acpSessions.set(activeSessionId, state);
-            return activeSessionId;
-        }
-        catch (error) {
-            if (sessionId)
-                this.acpSessions.delete(sessionId);
-            this.releaseSessionLock?.();
-            throw error;
-        }
-    }
-    async requestAcp(method, params, timeoutMs = SDK_REQUEST_TIMEOUT_MS) {
-        if (!this.acpConnection)
-            throw new Error('Agency Copilot ACP runtime is not started');
-        return withTimeout(this.acpConnection.agent.request(method, params), timeoutMs, method);
-    }
-    async notifyAcp(method, params) {
-        if (!this.acpConnection)
-            throw new Error('Agency Copilot ACP runtime is not started');
-        await this.acpConnection.agent.notify(method, params);
-    }
-    handleAcpSessionUpdate(notification) {
-        const { sessionId, update } = notification;
-        const state = this.acpSessions.get(sessionId) || {};
-        this.acpSessions.set(sessionId, state);
-        switch (update.sessionUpdate) {
-            case 'available_commands_update': {
-                const commands = normalizeAcpCommands(update.availableCommands);
-                state.commands = commands;
-                const waiters = this.acpCommandWaiters.get(sessionId);
-                if (waiters) {
-                    this.acpCommandWaiters.delete(sessionId);
-                    for (const resolvePromise of waiters)
-                        resolvePromise(commands);
-                }
-                break;
-            }
-            case 'current_mode_update':
-                if (state.modes)
-                    state.modes.currentModeId = update.currentModeId;
-                else
-                    state.modes = { currentModeId: update.currentModeId, availableModes: [] };
-                this.emitAcpEvent(sessionId, {
-                    type: 'session.mode_changed',
-                    data: { newMode: normalizeAcpMode(update.currentModeId) },
-                });
-                break;
-            case 'compaction_update': {
-                const type = update.status === 'in_progress'
-                    ? 'session.compaction_start'
-                    : update.status === 'completed'
-                        ? 'session.compaction_complete'
-                        : 'session.compaction_failed';
-                this.emitAcpEvent(sessionId, {
-                    type,
-                    data: { status: update.status, error: update.error },
-                });
-                break;
-            }
-            case 'agent_message_chunk':
-            case 'agent_thought_chunk':
-                if (update.content.type === 'text') {
-                    this.emitAcpEvent(sessionId, {
-                        type: update.sessionUpdate === 'agent_message_chunk'
-                            ? 'assistant.message_delta'
-                            : 'assistant.reasoning_delta',
-                        data: { deltaContent: update.content.text },
-                    });
-                }
-                break;
-            case 'tool_call': {
-                const name = update.name || update.title;
-                this.acpToolNames.set(update.toolCallId, name);
-                this.emitAcpEvent(sessionId, {
-                    type: 'assistant.message',
-                    data: {
-                        toolRequests: [{
-                                toolCallId: update.toolCallId,
-                                name,
-                                arguments: update.rawInput,
-                                intentionSummary: update.title,
-                            }],
-                    },
-                });
-                break;
-            }
-            case 'tool_call_update':
-                if (update.status === 'completed' || update.status === 'failed') {
-                    this.emitAcpEvent(sessionId, {
-                        type: 'tool.execution_complete',
-                        data: {
-                            toolCallId: update.toolCallId,
-                            toolName: update.name || this.acpToolNames.get(update.toolCallId),
-                            success: update.status === 'completed',
-                            result: { content: stringifyAcpToolOutput(update.rawOutput) },
-                            error: update.status === 'failed'
-                                ? { message: stringifyAcpToolOutput(update.rawOutput) || 'Tool execution failed' }
-                                : undefined,
-                        },
-                    });
-                }
-                break;
-        }
-    }
-    emitAcpEvent(sessionId, event) {
-        if (this.acpSessions.get(sessionId)?.suppressEvents)
-            return;
-        this.options.onSessionEvent?.(sessionId, event);
-    }
-}
-function normalizeAcpMode(modeId) {
-    const normalized = modeId?.toLowerCase().split(/[#/]/).filter(Boolean).at(-1);
-    if (normalized === 'plan')
-        return 'plan';
-    if (normalized === 'autopilot')
-        return 'autopilot';
-    return 'interactive';
-}
-function stringifyAcpToolOutput(value) {
-    if (typeof value === 'string')
-        return value;
-    if (value == null)
-        return '';
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return String(value);
-    }
-}
-export function normalizeAcpCommands(values) {
-    if (!Array.isArray(values))
-        return [];
-    const normalized = [];
-    for (const supported of SUPPORTED_COMMANDS) {
-        const source = values.find(command => {
-            const name = command?.name?.toLowerCase();
-            return name === supported || (supported === 'goal' && name === 'autopilot');
-        });
-        if (!source)
-            continue;
-        normalized.push({
-            id: `command:${supported}`,
-            name: supported,
-            invocation: `/${supported}`,
-            description: source.description || '',
-            kind: 'command',
-        });
-    }
-    return normalized;
-}
-export function normalizeCopilotCommands(input) {
-    const values = input?.commands;
-    if (!Array.isArray(values))
-        return [];
-    const normalized = [];
-    for (const supported of SUPPORTED_COMMANDS) {
-        const source = values.find(command => {
-            if (!command || typeof command.name !== 'string')
-                return false;
-            const names = [command.name, ...(Array.isArray(command.aliases) ? command.aliases : [])];
-            return names.some(name => name.toLowerCase() === supported);
-        });
-        if (!source)
-            continue;
-        normalized.push({
-            id: `command:${supported}`,
-            name: supported,
-            invocation: `/${supported}`,
-            description: typeof source.description === 'string' ? source.description : '',
-            kind: 'command',
-        });
-    }
-    return normalized;
-}
-export async function discoverCopilotCommands(scope) {
-    const runtime = new CopilotCommandRuntime({
-        providerId: scope.providerId,
-        workDir: scope.workDir,
-    });
-    let sessionId;
-    let disposableSession = false;
-    try {
-        await runtime.start();
-        const state = await import('./copilot.js');
-        const conversation = state.getCopilotConversation(scope.conversationId);
-        sessionId = conversation?.copilotSessionId || conversation?.lastCopilotSessionId || undefined;
-        if (!sessionId) {
-            sessionId = await runtime.openSession();
-            disposableSession = true;
-        }
-        if (!disposableSession)
-            await runtime.openSession(sessionId);
-        return { commands: await runtime.listSessionCommands(sessionId) };
-    }
-    catch (error) {
-        return {
-            commands: [],
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-    finally {
-        if (sessionId)
-            await runtime.destroySession(sessionId);
-        if (sessionId && disposableSession) {
-            try {
-                await runtime.deleteSession(sessionId);
-            }
-            catch { /* best-effort cleanup */ }
-        }
-        await runtime.stop();
-    }
-}
-function isRecord(value) {
-    return !!value && typeof value === 'object';
-}
-//# sourceMappingURL=copilot-command-bridge.js.map