@borgee/agents-host 0.1.5 → 0.1.7

package/dist/providers/copilot/adapter.d.ts

@@ -5,4 +5,5 @@ export declare class CopilotProviderAdapter implements ProviderAdapter {
     private readonly cli;
     constructor(cli: CopilotCliClient);
     generateReply(input: ProviderInput): Promise<ProviderReply>;
+    dispose(): Promise<void>;
 }

package/dist/providers/copilot/adapter.js

@@ -15,4 +15,7 @@ export class CopilotProviderAdapter {
         const text = await this.cli.generateReply(input.channelId, prompt);
         return { text };
     }
+    async dispose() {
+        await this.cli.dispose();
+    }
 }

package/dist/providers/copilot/cli-client.d.ts

@@ -1,24 +1,62 @@
+import spawn from 'cross-spawn';
+import { PROTOCOL_VERSION, client, methods, ndJsonStream } from '@agentclientprotocol/sdk';
+interface CopilotAcpRuntime {
+    spawn: typeof spawn;
+    client: typeof client;
+    ndJsonStream: typeof ndJsonStream;
+    methods: typeof methods;
+    protocolVersion: typeof PROTOCOL_VERSION;
+    cwd: string;
+    idleSessionTtlMs: number;
+    shutdownGracePeriodMs: number;
+    shutdownForceKillWaitMs: number;
+}
 /**
- * CLI client for the GitHub Copilot CLI (`copilot`) non-interactive mode,
- * with native per-channel session continuity.
- *
- * Unlike the Claude CLI, Copilot's non-interactive mode takes the prompt as
- * a `-p/--prompt` argument rather than reading it from stdin, so the prompt
- * is appended to the configured base args on every invocation instead of
- * being written to the child process's stdin.
+ * Persistent ACP-backed client for the GitHub Copilot CLI (`copilot --acp`).
  *
- * Verified CLI behavior (`copilot --help` + empirical check): `--session-id
- * <uuid>` both *creates* a new session pinned to that UUID (first call) and
- * *resumes* it (subsequent calls with the same UUID) — one flag covers both
- * cases, unlike Claude's `--session-id`/`--resume` split. No message history
- * is kept on our side — the CLI's own session storage is the single source
- * of truth for conversation memory.
+ * The legacy one-shot `COPILOT_ARGS` / constructor args are intentionally
+ * ignored here: the prototype always launches the child as `copilot --acp`,
+ * performs the ACP initialize handshake once, then reuses one ACP session per
+ * Borgee channel for the process lifetime.
  */
 export declare class CopilotCliClient {
     private readonly command;
-    private readonly args;
-    private readonly sessionIdsByChannel;
-    constructor(command: string, args: string[]);
+    private readonly runtime;
+    private readonly channels;
+    private readonly closingSessions;
+    private readonly pendingSessionStarts;
+    private readonly pendingSessionCloses;
+    private readonly fatalPromise;
+    private rejectFatalPromise;
+    private child?;
+    private connection?;
+    private startPromise?;
+    private shutdownPromise?;
+    private childExitPromise?;
+    private resolveChildExit?;
+    private fatalError;
+    private disposing;
+    private backendClosed;
+    constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotAcpRuntime>);
     generateReply(channelId: string, prompt: string): Promise<string>;
-    private run;
+    dispose(): Promise<void>;
+    private ensureStarted;
+    private startBackend;
+    private getOrCreateChannelState;
+    private processChannelQueue;
+    private getOrCreateSession;
+    private runTurn;
+    private raceWithFatal;
+    private failAll;
+    private invalidateSession;
+    private closeSession;
+    private rejectQueuedTurnsAfterSessionTaint;
+    private clearIdleTimer;
+    private reconcileIdleChannelState;
+    private evictIdleChannel;
+    private shutdownBackend;
+    private waitForPendingSessionStarts;
+    private waitForPendingSessionCloses;
+    private waitForChildExit;
 }
+export {};

package/dist/providers/copilot/cli-client.js

@@ -1,65 +1,508 @@
-import { randomUUID } from 'node:crypto';
+import { Readable, Writable } from 'node:stream';
 import spawn from 'cross-spawn';
+import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from '@agentclientprotocol/sdk';
+const SESSION_TAINTED_ERRORS = new WeakSet();
+const DEFAULT_IDLE_SESSION_TTL_MS = 2 * 24 * 60 * 60 * 1000;
+const DEFAULT_SHUTDOWN_GRACE_PERIOD_MS = 250;
+const DEFAULT_SHUTDOWN_FORCE_KILL_WAIT_MS = 250;
+const QUEUED_TURN_DROPPED_MESSAGE = 'Copilot ACP session was reset after a failed turn; queued turns were dropped instead of replaying them on a fresh session';
+const DEFAULT_RUNTIME = {
+    spawn,
+    client,
+    ndJsonStream,
+    methods,
+    protocolVersion: PROTOCOL_VERSION,
+    cwd: process.cwd(),
+    idleSessionTtlMs: DEFAULT_IDLE_SESSION_TTL_MS,
+    shutdownGracePeriodMs: DEFAULT_SHUTDOWN_GRACE_PERIOD_MS,
+    shutdownForceKillWaitMs: DEFAULT_SHUTDOWN_FORCE_KILL_WAIT_MS,
+};
+function createDeferredTurn(prompt) {
+    let settled = false;
+    let resolvePromise;
+    let rejectPromise;
+    const promise = new Promise((resolve, reject) => {
+        resolvePromise = resolve;
+        rejectPromise = reject;
+    });
+    return {
+        prompt,
+        promise,
+        resolve(value) {
+            if (settled)
+                return;
+            settled = true;
+            resolvePromise(value);
+        },
+        reject(error) {
+            if (settled)
+                return;
+            settled = true;
+            rejectPromise(normalizeError(error));
+        },
+    };
+}
+function normalizeError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function markSessionTainted(error) {
+    const normalized = normalizeError(error);
+    SESSION_TAINTED_ERRORS.add(normalized);
+    return normalized;
+}
+function isSessionTainted(error) {
+    return error instanceof Error && SESSION_TAINTED_ERRORS.has(error);
+}
+function selectPermissionOption(options) {
+    const option = options.find((candidate) => candidate.kind === 'allow_always') ??
+        options.find((candidate) => candidate.kind === 'allow_once');
+    if (!option) {
+        throw new Error('Copilot ACP requested permission but did not offer an allow option');
+    }
+    return option.optionId;
+}
 /**
- * CLI client for the GitHub Copilot CLI (`copilot`) non-interactive mode,
- * with native per-channel session continuity.
+ * Persistent ACP-backed client for the GitHub Copilot CLI (`copilot --acp`).
  *
- * Unlike the Claude CLI, Copilot's non-interactive mode takes the prompt as
- * a `-p/--prompt` argument rather than reading it from stdin, so the prompt
- * is appended to the configured base args on every invocation instead of
- * being written to the child process's stdin.
- *
- * Verified CLI behavior (`copilot --help` + empirical check): `--session-id
- * <uuid>` both *creates* a new session pinned to that UUID (first call) and
- * *resumes* it (subsequent calls with the same UUID) — one flag covers both
- * cases, unlike Claude's `--session-id`/`--resume` split. No message history
- * is kept on our side — the CLI's own session storage is the single source
- * of truth for conversation memory.
+ * The legacy one-shot `COPILOT_ARGS` / constructor args are intentionally
+ * ignored here: the prototype always launches the child as `copilot --acp`,
+ * performs the ACP initialize handshake once, then reuses one ACP session per
+ * Borgee channel for the process lifetime.
  */
 export class CopilotCliClient {
     command;
-    args;
-    sessionIdsByChannel = new Map();
-    constructor(command, args) {
+    runtime;
+    channels = new Map();
+    closingSessions = new WeakSet();
+    pendingSessionStarts = new Set();
+    pendingSessionCloses = new Set();
+    fatalPromise;
+    rejectFatalPromise;
+    child;
+    connection;
+    startPromise;
+    shutdownPromise;
+    childExitPromise;
+    resolveChildExit;
+    fatalError = null;
+    disposing = false;
+    backendClosed = false;
+    constructor(command, _ignoredArgs = [], runtimeOverrides = {}) {
         this.command = command;
-        this.args = args;
+        this.runtime = { ...DEFAULT_RUNTIME, ...runtimeOverrides };
+        this.fatalPromise = new Promise((_, reject) => {
+            this.rejectFatalPromise = reject;
+        });
+        void this.fatalPromise.catch(() => { });
     }
     async generateReply(channelId, prompt) {
-        const sessionId = this.sessionIdsByChannel.get(channelId) ?? randomUUID();
-        const text = await this.run([...this.args, `--session-id=${sessionId}`, '-p', prompt]);
-        this.sessionIdsByChannel.set(channelId, sessionId);
-        return text;
-    }
-    async run(args) {
-        return new Promise((resolve, reject) => {
-            const child = spawn(this.command, args, {
-                stdio: ['ignore', 'pipe', 'pipe'],
-            });
-            let stdout = '';
-            let stderr = '';
-            child.stdout.setEncoding('utf8');
-            child.stderr.setEncoding('utf8');
-            child.stdout.on('data', (chunk) => {
-                stdout += chunk;
-            });
-            child.stderr.on('data', (chunk) => {
-                stderr += chunk;
-            });
-            child.on('error', (error) => {
-                reject(error);
+        if (this.fatalError) {
+            throw this.fatalError;
+        }
+        const state = this.getOrCreateChannelState(channelId);
+        this.clearIdleTimer(state);
+        const turn = createDeferredTurn(prompt);
+        state.queue.push(turn);
+        this.processChannelQueue(channelId, state);
+        return turn.promise;
+    }
+    async dispose() {
+        const error = new Error('Copilot ACP backend stopped');
+        this.disposing = true;
+        const closed = this.connection?.closed ?? Promise.resolve();
+        this.failAll(error);
+        await Promise.all([closed, this.shutdownPromise ?? Promise.resolve()]);
+    }
+    async ensureStarted() {
+        if (this.fatalError) {
+            throw this.fatalError;
+        }
+        if (!this.startPromise) {
+            this.startPromise = this.startBackend();
+        }
+        await this.startPromise;
+        if (this.fatalError) {
+            throw this.fatalError;
+        }
+        if (!this.connection) {
+            throw new Error('Copilot ACP connection is not available');
+        }
+    }
+    async startBackend() {
+        const child = this.runtime.spawn(this.command, ['--acp'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.child = child;
+        child.stderr.resume();
+        child.once('error', (error) => {
+            this.failAll(new Error(`Copilot ACP process error: ${normalizeError(error).message}`));
+        });
+        child.once('exit', (code, signal) => {
+            this.resolveChildExit?.();
+            if (this.disposing)
+                return;
+            const suffix = signal ? `signal ${signal}` : `code ${String(code ?? 'unknown')}`;
+            this.failAll(new Error(`Copilot ACP process exited unexpectedly (${suffix})`));
+        });
+        this.childExitPromise = new Promise((resolve) => {
+            this.resolveChildExit = resolve;
+        });
+        const output = Writable.toWeb(child.stdin);
+        const input = Readable.toWeb(child.stdout);
+        const stream = this.runtime.ndJsonStream(output, input);
+        const app = this.runtime
+            .client({ name: 'borgee-agents-host' })
+            .onRequest(this.runtime.methods.client.session.requestPermission, ({ params }) => ({
+            outcome: {
+                outcome: 'selected',
+                optionId: selectPermissionOption(params.options),
+            },
+        }));
+        const connection = app.connect(stream);
+        this.connection = connection;
+        void connection.closed.then(() => {
+            if (!this.disposing) {
+                this.failAll(new Error('Copilot ACP connection closed unexpectedly'));
+            }
+        });
+        try {
+            await connection.agent.request(this.runtime.methods.agent.initialize, {
+                protocolVersion: this.runtime.protocolVersion,
+                clientCapabilities: {},
+                clientInfo: {
+                    name: '@borgee/agents-host',
+                    version: '0.1.6',
+                },
             });
-            child.on('close', (code) => {
-                if (code !== 0) {
-                    reject(new Error(`Copilot CLI failed with code ${code}: ${stderr.trim()}`));
-                    return;
+        }
+        catch (error) {
+            const normalized = new Error(`Copilot ACP initialize failed: ${normalizeError(error).message}`);
+            this.failAll(normalized);
+            throw normalized;
+        }
+    }
+    getOrCreateChannelState(channelId) {
+        let state = this.channels.get(channelId);
+        if (!state) {
+            state = {
+                idleTimerGeneration: 0,
+                processing: false,
+                queue: [],
+            };
+            this.channels.set(channelId, state);
+        }
+        return state;
+    }
+    processChannelQueue(channelId, state) {
+        if (state.processing) {
+            return;
+        }
+        state.processing = true;
+        void (async () => {
+            try {
+                while (!this.fatalError) {
+                    const turn = state.queue.shift();
+                    if (!turn) {
+                        return;
+                    }
+                    state.activeTurn = turn;
+                    try {
+                        await this.ensureStarted();
+                        const session = await this.getOrCreateSession(channelId, state);
+                        let reply;
+                        try {
+                            reply = await this.runTurn(session, turn.prompt);
+                        }
+                        catch (error) {
+                            if (isSessionTainted(error)) {
+                                this.invalidateSession(state, session);
+                                this.rejectQueuedTurnsAfterSessionTaint(state, error);
+                            }
+                            throw error;
+                        }
+                        turn.resolve(reply);
+                    }
+                    catch (error) {
+                        turn.reject(error);
+                    }
+                    finally {
+                        state.activeTurn = undefined;
+                    }
                 }
-                const text = stdout.trim();
-                if (!text) {
-                    reject(new Error('Copilot CLI returned empty output'));
-                    return;
+            }
+            finally {
+                state.processing = false;
+                this.reconcileIdleChannelState(channelId, state);
+            }
+        })();
+    }
+    async getOrCreateSession(channelId, state) {
+        if (state.session) {
+            return state.session;
+        }
+        if (state.sessionPromise) {
+            return state.sessionPromise;
+        }
+        if (!this.connection) {
+            throw new Error('Copilot ACP connection is not available');
+        }
+        const sessionPromise = this.connection.agent.buildSession(this.runtime.cwd).start();
+        this.pendingSessionStarts.add(sessionPromise);
+        state.sessionPromise = sessionPromise;
+        let sessionAdopted = false;
+        void sessionPromise
+            .then((session) => {
+            if (!sessionAdopted &&
+                (this.fatalError !== null || this.disposing || state.sessionPromise !== sessionPromise)) {
+                this.closeSession(session);
+            }
+        })
+            .finally(() => {
+            this.pendingSessionStarts.delete(sessionPromise);
+        })
+            .catch(() => { });
+        try {
+            const session = await this.raceWithFatal(sessionPromise);
+            if (this.fatalError) {
+                this.closeSession(session);
+                throw this.fatalError;
+            }
+            sessionAdopted = true;
+            state.session = session;
+            return session;
+        }
+        catch (error) {
+            state.session = undefined;
+            throw error;
+        }
+        finally {
+            if (state.sessionPromise === sessionPromise) {
+                state.sessionPromise = undefined;
+            }
+        }
+    }
+    async runTurn(session, prompt) {
+        const promptPromise = this.raceWithFatal(session.prompt(prompt));
+        const promptFailure = new Promise((_, reject) => {
+            void promptPromise.catch((error) => reject(markSessionTainted(error)));
+        });
+        let text = '';
+        for (;;) {
+            let update;
+            try {
+                update = await this.raceWithFatal(Promise.race([session.nextUpdate(), promptFailure]));
+            }
+            catch (error) {
+                if (this.fatalError && error === this.fatalError) {
+                    throw error;
                 }
-                resolve(text);
-            });
+                throw markSessionTainted(error);
+            }
+            if (update.kind === 'stop') {
+                let response;
+                try {
+                    response = await promptPromise;
+                }
+                catch (error) {
+                    throw markSessionTainted(error);
+                }
+                if (response.stopReason !== 'end_turn') {
+                    throw new Error(`Copilot ACP turn stopped with stopReason "${response.stopReason}"`);
+                }
+                const output = text.trim();
+                if (!output) {
+                    throw new Error('Copilot ACP returned empty output');
+                }
+                return output;
+            }
+            if (update.update.sessionUpdate === 'agent_message_chunk' &&
+                update.update.content.type === 'text') {
+                text += update.update.content.text;
+            }
+        }
+    }
+    async raceWithFatal(promise) {
+        if (this.fatalError) {
+            throw this.fatalError;
+        }
+        return Promise.race([promise, this.fatalPromise]);
+    }
+    failAll(error) {
+        if (this.fatalError) {
+            return;
+        }
+        this.fatalError = error;
+        this.rejectFatalPromise(error);
+        for (const [channelId, state] of this.channels.entries()) {
+            this.clearIdleTimer(state);
+            state.activeTurn?.reject(error);
+            for (const turn of state.queue) {
+                turn.reject(error);
+            }
+            state.queue.length = 0;
+            if (state.session) {
+                this.closeSession(state.session);
+            }
+            state.session = undefined;
+            state.sessionPromise = undefined;
+            state.activeTurn = undefined;
+            if (!state.processing) {
+                this.channels.delete(channelId);
+            }
+        }
+        this.channels.clear();
+        this.shutdownPromise = this.shutdownBackend(error);
+    }
+    invalidateSession(state, session) {
+        this.clearIdleTimer(state);
+        if (state.session === session) {
+            state.session = undefined;
+        }
+        this.closeSession(session);
+    }
+    closeSession(session) {
+        if (this.closingSessions.has(session)) {
+            return;
+        }
+        this.closingSessions.add(session);
+        const agent = this.connection?.agent;
+        const closeMethod = this.runtime.methods.agent.session?.close;
+        const closePromise = typeof agent?.closeSession === 'function'
+            ? agent.closeSession({ sessionId: session.sessionId })
+            : closeMethod
+                ? this.connection?.agent.request(closeMethod, { sessionId: session.sessionId })
+                : undefined;
+        session.dispose();
+        if (!closePromise) {
+            return;
+        }
+        let trackedClosePromise;
+        trackedClosePromise = Promise.resolve(closePromise)
+            .then(() => undefined)
+            .catch(() => { })
+            .finally(() => {
+            this.pendingSessionCloses.delete(trackedClosePromise);
+        });
+        this.pendingSessionCloses.add(trackedClosePromise);
+    }
+    rejectQueuedTurnsAfterSessionTaint(state, error) {
+        if (state.queue.length === 0) {
+            return;
+        }
+        const rejection = new Error(QUEUED_TURN_DROPPED_MESSAGE, {
+            cause: normalizeError(error),
         });
+        for (const turn of state.queue) {
+            turn.reject(rejection);
+        }
+        state.queue.length = 0;
+    }
+    clearIdleTimer(state) {
+        state.idleTimerGeneration += 1;
+        if (!state.idleTimer) {
+            return;
+        }
+        clearTimeout(state.idleTimer);
+        state.idleTimer = undefined;
+    }
+    reconcileIdleChannelState(channelId, state) {
+        if (this.channels.get(channelId) !== state) {
+            return;
+        }
+        if (this.disposing || this.fatalError || this.backendClosed) {
+            this.clearIdleTimer(state);
+            return;
+        }
+        if (state.activeTurn || state.queue.length > 0 || state.sessionPromise || state.processing) {
+            this.clearIdleTimer(state);
+            return;
+        }
+        if (!state.session) {
+            this.clearIdleTimer(state);
+            this.channels.delete(channelId);
+            return;
+        }
+        this.clearIdleTimer(state);
+        const generation = state.idleTimerGeneration;
+        state.idleTimer = setTimeout(() => {
+            this.evictIdleChannel(channelId, state, generation);
+        }, this.runtime.idleSessionTtlMs);
+    }
+    evictIdleChannel(channelId, state, generation) {
+        if (this.disposing || this.fatalError || this.backendClosed) {
+            return;
+        }
+        if (this.channels.get(channelId) !== state || state.idleTimerGeneration !== generation) {
+            return;
+        }
+        state.idleTimer = undefined;
+        if (state.activeTurn || state.queue.length > 0 || state.sessionPromise || state.processing) {
+            return;
+        }
+        const session = state.session;
+        state.session = undefined;
+        if (session) {
+            this.closeSession(session);
+        }
+        this.channels.delete(channelId);
+    }
+    async shutdownBackend(error) {
+        if (this.backendClosed) {
+            return;
+        }
+        this.backendClosed = true;
+        const connection = this.connection;
+        const child = this.child;
+        await this.waitForPendingSessionStarts();
+        await this.waitForPendingSessionCloses();
+        connection?.close(error);
+        this.connection = undefined;
+        if (!child) {
+            this.child = undefined;
+            return;
+        }
+        const childExitPromise = this.childExitPromise ?? Promise.resolve();
+        child.kill('SIGTERM');
+        const exitedAfterTerm = await this.waitForChildExit(childExitPromise, this.runtime.shutdownGracePeriodMs);
+        if (exitedAfterTerm) {
+            this.child = undefined;
+            return;
+        }
+        child.kill('SIGKILL');
+        await this.waitForChildExit(childExitPromise, this.runtime.shutdownForceKillWaitMs);
+        this.child = undefined;
+    }
+    async waitForPendingSessionStarts() {
+        if (this.pendingSessionStarts.size === 0) {
+            return;
+        }
+        await Promise.race([
+            Promise.allSettled([...this.pendingSessionStarts]).then(() => undefined),
+            new Promise((resolve) => {
+                setTimeout(resolve, this.runtime.shutdownGracePeriodMs);
+            }),
+        ]);
+    }
+    async waitForPendingSessionCloses() {
+        if (this.pendingSessionCloses.size === 0) {
+            return;
+        }
+        await Promise.race([
+            Promise.allSettled([...this.pendingSessionCloses]).then(() => undefined),
+            new Promise((resolve) => {
+                setTimeout(resolve, this.runtime.shutdownGracePeriodMs);
+            }),
+        ]);
+    }
+    async waitForChildExit(childExitPromise, timeoutMs) {
+        if (timeoutMs <= 0) {
+            return false;
+        }
+        return Promise.race([
+            childExitPromise.then(() => true),
+            new Promise((resolve) => {
+                setTimeout(() => resolve(false), timeoutMs);
+            }),
+        ]);
     }
 }

package/dist/providers/create-provider.js

@@ -9,7 +9,9 @@ export function createProvider(config) {
             return new ClaudeProviderAdapter(cli);
         }
         case 'copilot': {
-            const cli = new CopilotCliClient(config.copilotCommand, config.copilotArgs);
+            const cli = new CopilotCliClient(config.copilotCommand, config.copilotArgs, {
+                idleSessionTtlMs: config.copilotSessionTtlMinutes * 60 * 1000,
+            });
             return new CopilotProviderAdapter(cli);
         }
         default:

package/dist/providers/provider-adapter.d.ts

@@ -1,4 +1,5 @@
 import type { ProviderInput, ProviderReply } from '../types.js';
 export interface ProviderAdapter {
     generateReply(input: ProviderInput): Promise<ProviderReply>;
+    dispose?(): Promise<void>;
 }