@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/acp/connection.d.ts

@@ -0,0 +1,59 @@
+/**
+ * AcpConnection — Per-subagent ACP connection.
+ *
+ * Spawns a child process via Bun.spawn and connects to it via ClientSideConnection
+ * using ndJsonStream over stdio. Implements the ACP Client interface so the
+ * subagent can request permissions and send session updates.
+ */
+import type { SubagentInfo, SubagentResult, SubagentTask } from '@pellux/goodvibes-sdk/platform/acp/protocol';
+import type { PermissionRequestHandler } from '../permissions/prompt.js';
+import type { RuntimeEventBus } from '../runtime/events/index.js';
+import type { HookDispatcher } from '../hooks/index.js';
+/**
+ * AcpConnection manages the lifecycle of a single subagent child process.
+ *
+ * Lifecycle:
+ *   1. Construct with spawn params
+ *   2. Call run() — spawns child, performs ACP handshake, starts a session
+ *   3. Resolves with SubagentResult when the subagent completes or is cancelled
+ *   4. Call cancel() to abort
+ */
+export declare class AcpConnection {
+    private task;
+    readonly id: string;
+    private info;
+    private spawnCmd;
+    private requestPermission;
+    private runtimeBus;
+    private conn;
+    private sessionId;
+    private childProcess;
+    private toolCallsMade;
+    private lastProgressText;
+    private transportClosed;
+    private readonly hookDispatcher;
+    constructor(id: string, task: SubagentTask, spawnCmd: string[], requestPermission?: PermissionRequestHandler, runtimeBus?: RuntimeEventBus | null, hookDispatcher?: Pick<HookDispatcher, 'fire'> | null);
+    /** Current info snapshot. */
+    getInfo(): SubagentInfo;
+    /**
+     * Spawn the child process, perform the ACP handshake, and run the prompt.
+     * Resolves with SubagentResult when the subagent completes or errors.
+     */
+    run(): Promise<SubagentResult>;
+    /** Cancel the running subagent. */
+    cancel(): Promise<void>;
+    private emitterContext;
+    private transportId;
+    private transportEndpoint;
+    private emitTransportInitializing;
+    private emitTransportAuthenticating;
+    private emitTransportConnected;
+    private emitTransportSyncing;
+    private emitTransportDisconnected;
+    private emitTransportTerminalFailure;
+    private fireTransportHook;
+    private cleanup;
+    private buildClientImpl;
+    private buildPromptText;
+}
+//# sourceMappingURL=connection.d.ts.map

package/dist/_internal/platform/acp/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/acp/connection.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAUH,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,6CAA6C,CAAC;AAE9G,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAKzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAalE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAkBxD;;;;;;;;GAQG;AACH,qBAAa,aAAa;IAgBtB,OAAO,CAAC,IAAI;IAfd,SAAgB,EAAE,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,iBAAiB,CAA2B;IACpD,OAAO,CAAC,UAAU,CAAyB;IAC3C,OAAO,CAAC,IAAI,CAAqC;IACjD,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,YAAY,CAA6C;IACjE,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,gBAAgB,CAAM;IAC9B,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAsC;gBAGnE,EAAE,EAAE,MAAM,EACF,IAAI,EAAE,YAAY,EAC1B,QAAQ,EAAE,MAAM,EAAE,EAClB,iBAAiB,GAAE,wBAA6E,EAChG,UAAU,GAAE,eAAe,GAAG,IAAW,EACzC,cAAc,GAAE,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,GAAG,IAAW;IAe5D,6BAA6B;IAC7B,OAAO,IAAI,YAAY;IAIvB;;;OAGG;IACG,GAAG,IAAI,OAAO,CAAC,cAAc,CAAC;IAwHpC,mCAAmC;IAC7B,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAoB7B,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,yBAAyB;IAYjC,OAAO,CAAC,2BAA2B;IAUnC,OAAO,CAAC,sBAAsB;IAY9B,OAAO,CAAC,oBAAoB;IAU5B,OAAO,CAAC,yBAAyB;IAejC,OAAO,CAAC,4BAA4B;YAatB,iBAAiB;IAiB/B,OAAO,CAAC,OAAO;IAWf,OAAO,CAAC,eAAe;IAiEvB,OAAO,CAAC,eAAe;CAiBxB"}

package/dist/_internal/platform/acp/connection.js

@@ -0,0 +1,377 @@
+/**
+ * AcpConnection — Per-subagent ACP connection.
+ *
+ * Spawns a child process via Bun.spawn and connects to it via ClientSideConnection
+ * using ndJsonStream over stdio. Implements the ACP Client interface so the
+ * subagent can request permissions and send session updates.
+ */
+import { ClientSideConnection, ndJsonStream } from '@agentclientprotocol/sdk';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { analyzePermissionRequest } from '@pellux/goodvibes-sdk/platform/permissions/analysis';
+import { AcpError } from '@pellux/goodvibes-sdk/platform/types/errors';
+import { VERSION } from '../version.js';
+import { emitAgentCancelled, emitAgentCompleted, emitAgentFailed, emitAgentStreamDelta, emitTransportAuthenticating, emitTransportConnected, emitTransportDisconnected, emitTransportInitializing, emitTransportSyncing, emitTransportTerminalFailure, } from '../runtime/emitters/index.js';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+/** Runtime type guard for agent_message_chunk updates. */
+function isMessageChunk(update) {
+    return (update.sessionUpdate === 'agent_message_chunk' &&
+        ('content' in update));
+}
+/**
+ * AcpConnection manages the lifecycle of a single subagent child process.
+ *
+ * Lifecycle:
+ *   1. Construct with spawn params
+ *   2. Call run() — spawns child, performs ACP handshake, starts a session
+ *   3. Resolves with SubagentResult when the subagent completes or is cancelled
+ *   4. Call cancel() to abort
+ */
+export class AcpConnection {
+    task;
+    id;
+    info;
+    spawnCmd;
+    requestPermission;
+    runtimeBus;
+    conn = null;
+    sessionId = null;
+    childProcess = null;
+    toolCallsMade = 0;
+    lastProgressText = '';
+    transportClosed = false;
+    hookDispatcher;
+    constructor(id, task, spawnCmd, requestPermission = async () => ({ approved: false, remember: false }), runtimeBus = null, hookDispatcher = null) {
+        this.task = task;
+        this.id = id;
+        this.spawnCmd = spawnCmd;
+        this.requestPermission = requestPermission;
+        this.runtimeBus = runtimeBus;
+        this.hookDispatcher = hookDispatcher;
+        this.info = {
+            id,
+            task: task.description,
+            status: 'running',
+            startedAt: Date.now(),
+        };
+    }
+    /** Current info snapshot. */
+    getInfo() {
+        return { ...this.info };
+    }
+    /**
+     * Spawn the child process, perform the ACP handshake, and run the prompt.
+     * Resolves with SubagentResult when the subagent completes or errors.
+     */
+    async run() {
+        const startedAt = this.info.startedAt;
+        try {
+            this.transportClosed = false;
+            this.emitTransportInitializing();
+            // 1. Spawn child process with piped stdio
+            this.childProcess = Bun.spawn(this.spawnCmd, {
+                stdin: 'pipe',
+                stdout: 'pipe',
+                stderr: 'pipe',
+            });
+            // 2. Build ndJsonStream from child stdio.
+            //
+            // In Bun, childProcess.stdin is a FileSink (not a Web WritableStream).
+            // ndJsonStream requires a Web WritableStream<Uint8Array> so it can call
+            // .getWriter() internally.  Wrap the FileSink in a WritableStream adapter.
+            if (!this.childProcess.stdin) {
+                throw new AcpError('ACP subprocess stdin not available — was it spawned with stdin: "pipe"?');
+            }
+            const bunStdin = this.childProcess.stdin;
+            const stdinStream = new WritableStream({
+                write(chunk) {
+                    bunStdin.write(chunk);
+                },
+                close() {
+                    bunStdin.end();
+                },
+                abort() {
+                    bunStdin.end();
+                },
+            });
+            const stream = ndJsonStream(stdinStream, 
+            // Bun's piped stdout is ReadableStream-compatible at runtime — getReader() works
+            // correctly. The double-cast is safe here because Bun's ReadStream implements the
+            // same interface, unlike stdin (FileSink) which lacks getWriter().
+            this.childProcess.stdout);
+            // 3. Build the Client implementation that handles agent callbacks
+            const clientImpl = this.buildClientImpl();
+            // 4. Create the ClientSideConnection (TUI = ACP client, child = ACP agent)
+            this.conn = new ClientSideConnection((_agent) => clientImpl, stream);
+            // 5. ACP handshake: initialize (protocolVersion is a number)
+            this.emitTransportAuthenticating();
+            await this.conn.initialize({
+                protocolVersion: 1,
+                clientInfo: { name: 'goodvibes-sdk', version: VERSION },
+                clientCapabilities: {},
+            });
+            // 6. Create a session (cwd is required, mcpServers is required)
+            const sessionResp = await this.conn.newSession({
+                cwd: this.task.workingDirectory,
+                mcpServers: [],
+            });
+            this.sessionId = sessionResp.sessionId;
+            this.emitTransportConnected();
+            this.emitTransportSyncing();
+            // 7. Send the prompt (uses 'prompt' field with ContentBlock array)
+            const promptResp = await this.conn.prompt({
+                sessionId: this.sessionId,
+                prompt: [
+                    {
+                        type: 'text',
+                        text: this.buildPromptText(),
+                    },
+                ],
+            });
+            const output = this.lastProgressText || `Completed with stop reason: ${promptResp.stopReason}`;
+            const result = {
+                id: this.id,
+                success: promptResp.stopReason !== 'cancelled',
+                output,
+                toolCallsMade: this.toolCallsMade,
+                duration: Date.now() - startedAt,
+            };
+            this.info.status = result.success ? 'complete' : 'error';
+            if (this.runtimeBus) {
+                emitAgentCompleted(this.runtimeBus, this.emitterContext(), {
+                    agentId: this.id,
+                    durationMs: result.duration,
+                    output: result.output,
+                    toolCallsMade: result.toolCallsMade,
+                });
+            }
+            this.emitTransportDisconnected('ACP session completed', false);
+            return result;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(summarizeError(err));
+            this.info.status = 'error';
+            if (this.runtimeBus) {
+                emitAgentFailed(this.runtimeBus, this.emitterContext(), {
+                    agentId: this.id,
+                    error: error.message,
+                    durationMs: Date.now() - startedAt,
+                });
+            }
+            this.emitTransportTerminalFailure(error.message);
+            return {
+                id: this.id,
+                success: false,
+                output: error.message,
+                toolCallsMade: this.toolCallsMade,
+                duration: Date.now() - startedAt,
+            };
+        }
+        finally {
+            this.cleanup();
+        }
+    }
+    /** Cancel the running subagent. */
+    async cancel() {
+        if (this.conn && this.sessionId) {
+            try {
+                await this.conn.cancel({ sessionId: this.sessionId });
+            }
+            catch (err) {
+                // Best-effort — kill the child if cancel fails
+                logger.error('AcpConnection.cancel: failed to send cancel to subagent', { id: this.id, err: summarizeError(err) });
+            }
+        }
+        this.info.status = 'cancelled';
+        if (this.runtimeBus) {
+            emitAgentCancelled(this.runtimeBus, this.emitterContext(), {
+                agentId: this.id,
+                reason: 'ACP session cancelled',
+            });
+        }
+        this.emitTransportDisconnected('ACP session cancelled', false);
+        this.cleanup();
+    }
+    emitterContext() {
+        return {
+            sessionId: 'acp-connection',
+            traceId: `acp-connection:${this.id}`,
+            source: 'acp-connection',
+        };
+    }
+    transportId() {
+        return `acp:${this.id}`;
+    }
+    transportEndpoint() {
+        return `stdio://subagent/${this.id}`;
+    }
+    emitTransportInitializing() {
+        if (!this.runtimeBus)
+            return;
+        emitTransportInitializing(this.runtimeBus, this.emitterContext(), {
+            transportId: this.transportId(),
+            protocol: 'acp-stdio',
+        });
+        void this.fireTransportHook('initializing', {
+            transportId: this.transportId(),
+            protocol: 'acp-stdio',
+        });
+    }
+    emitTransportAuthenticating() {
+        if (!this.runtimeBus)
+            return;
+        emitTransportAuthenticating(this.runtimeBus, this.emitterContext(), {
+            transportId: this.transportId(),
+        });
+        void this.fireTransportHook('authenticating', {
+            transportId: this.transportId(),
+        });
+    }
+    emitTransportConnected() {
+        if (!this.runtimeBus)
+            return;
+        emitTransportConnected(this.runtimeBus, this.emitterContext(), {
+            transportId: this.transportId(),
+            endpoint: this.transportEndpoint(),
+        });
+        void this.fireTransportHook('connected', {
+            transportId: this.transportId(),
+            endpoint: this.transportEndpoint(),
+        });
+    }
+    emitTransportSyncing() {
+        if (!this.runtimeBus)
+            return;
+        emitTransportSyncing(this.runtimeBus, this.emitterContext(), {
+            transportId: this.transportId(),
+        });
+        void this.fireTransportHook('syncing', {
+            transportId: this.transportId(),
+        });
+    }
+    emitTransportDisconnected(reason, willRetry) {
+        if (!this.runtimeBus || this.transportClosed)
+            return;
+        this.transportClosed = true;
+        emitTransportDisconnected(this.runtimeBus, this.emitterContext(), {
+            transportId: this.transportId(),
+            reason,
+            willRetry,
+        });
+        void this.fireTransportHook('disconnected', {
+            transportId: this.transportId(),
+            reason,
+            willRetry,
+        });
+    }
+    emitTransportTerminalFailure(error) {
+        if (!this.runtimeBus || this.transportClosed)
+            return;
+        this.transportClosed = true;
+        emitTransportTerminalFailure(this.runtimeBus, this.emitterContext(), {
+            transportId: this.transportId(),
+            error,
+        });
+        void this.fireTransportHook('failed', {
+            transportId: this.transportId(),
+            error,
+        });
+    }
+    async fireTransportHook(specific, payload) {
+        if (!this.hookDispatcher)
+            return;
+        try {
+            await this.hookDispatcher.fire({
+                path: `Lifecycle:transport:${specific}`,
+                phase: 'Lifecycle',
+                category: 'transport',
+                specific,
+                sessionId: 'acp-connection',
+                timestamp: Date.now(),
+                payload,
+            });
+        }
+        catch {
+            // Transport hooks are best-effort and must not break ACP transport.
+        }
+    }
+    cleanup() {
+        try {
+            this.childProcess?.kill();
+        }
+        catch (err) {
+            logger.error('AcpConnection.cleanup: failed to kill child process', { id: this.id, err: summarizeError(err) });
+        }
+        this.childProcess = null;
+        this.conn = null;
+        this.sessionId = null;
+    }
+    buildClientImpl() {
+        return {
+            /** Forward permission requests through the shell-owned permission controller. */
+            requestPermission: (params) => {
+                const category = 'delegate';
+                const callId = `acp-${this.id}-${Date.now()}`;
+                const toolTitle = params.toolCall?.title ?? 'unknown';
+                const approveOptionId = params.options[0]?.optionId ?? 'allow';
+                return this.requestPermission({
+                    callId,
+                    tool: toolTitle,
+                    args: params.toolCall?.rawInput ?? {},
+                    category,
+                    analysis: analyzePermissionRequest(toolTitle, params.toolCall?.rawInput ?? {}, category),
+                }).then(({ approved }) => {
+                    if (approved) {
+                        return {
+                            outcome: {
+                                outcome: 'selected',
+                                optionId: approveOptionId,
+                            },
+                        };
+                    }
+                    return {
+                        outcome: { outcome: 'cancelled' },
+                    };
+                });
+            },
+            /** Handle session update notifications from the subagent. */
+            sessionUpdate: async (params) => {
+                const update = params.update;
+                // Count tool calls
+                if (update.sessionUpdate === 'tool_call') {
+                    this.toolCallsMade++;
+                }
+                // Collect streamed text chunks as progress
+                if (isMessageChunk(update)) {
+                    const text = update.content
+                        ?.filter((c) => c.type === 'text')
+                        .map((c) => c.text ?? '')
+                        .join('') ?? '';
+                    if (text) {
+                        this.lastProgressText = (this.lastProgressText + text).slice(-1000);
+                        this.info.progress = this.lastProgressText.slice(-200);
+                        if (this.runtimeBus) {
+                            emitAgentStreamDelta(this.runtimeBus, this.emitterContext(), {
+                                agentId: this.id,
+                                content: text,
+                                accumulated: this.lastProgressText,
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    }
+    buildPromptText() {
+        const parts = [`Task: ${this.task.description}`];
+        if (this.task.context) {
+            parts.push(`Context:\n${this.task.context}`);
+        }
+        if (this.task.tools.length > 0) {
+            parts.push(`Available tools: ${this.task.tools.join(', ')}`);
+        }
+        if (this.task.model) {
+            parts.push(`Use model: ${this.task.model}`);
+        }
+        return parts.join('\n\n');
+    }
+}

package/dist/_internal/platform/acp/index.d.ts

@@ -0,0 +1,3 @@
+export type { SubagentInfo, SubagentResult, SubagentTask, SubagentStatus, } from '@pellux/goodvibes-sdk/platform/acp/protocol';
+export { AcpManager } from './manager.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/acp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/acp/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,cAAc,GACf,MAAM,6CAA6C,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC"}

package/dist/_internal/platform/acp/index.js

@@ -0,0 +1 @@
+export { AcpManager } from './manager.js';

package/dist/_internal/platform/acp/manager.d.ts

@@ -0,0 +1,49 @@
+/**
+ * AcpManager — Manages the lifecycle of all subagent ACP connections.
+ *
+ * The TUI orchestrator calls spawn() when it needs to delegate work.
+ * The manager tracks active subagents and provides cancel / waitAll.
+ */
+import type { SubagentInfo, SubagentResult, SubagentTask } from '@pellux/goodvibes-sdk/platform/acp/protocol';
+import type { PermissionRequestHandler } from '../permissions/prompt.js';
+import type { RuntimeEventBus } from '../runtime/events/index.js';
+import type { HookDispatcher } from '../hooks/index.js';
+export declare function getDefaultAcpAgentCommand(): string[];
+/**
+ * AcpManager — Manages multiple concurrent subagent connections.
+ *
+ * @example
+ * ```ts
+ * const mgr = new AcpManager(bus);
+ * const id = await mgr.spawn({ description: 'Fix the bug', context: '...', tools: ['read'] });
+ * const results = await mgr.waitAll();
+ * ```
+ */
+export declare class AcpManager {
+    private connections;
+    private pending;
+    private agentCmd;
+    private readonly requestPermission?;
+    private readonly runtimeBus;
+    private readonly hookDispatcher;
+    constructor(permissionOrLegacyBus?: PermissionRequestHandler | {
+        emit?: unknown;
+    }, runtimeBus?: RuntimeEventBus | null, hookDispatcher?: Pick<HookDispatcher, 'fire'> | null);
+    /**
+     * Spawn a new subagent and start running the task.
+     * Returns the subagent ID immediately; the task runs in the background.
+     */
+    spawn(task: SubagentTask): Promise<string>;
+    /** Returns info snapshots for all active subagents. */
+    getActive(): SubagentInfo[];
+    /** Cancel a specific subagent by ID. No-op if not found. */
+    cancel(id: string): Promise<void>;
+    /** Cancel all active subagents. */
+    cancelAll(): Promise<void>;
+    /**
+     * Wait for all currently active subagents to finish.
+     * Returns results in completion order.
+     */
+    waitAll(): Promise<SubagentResult[]>;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/_internal/platform/acp/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/acp/manager.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,6CAA6C,CAAC;AAC9G,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAElE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAcxD,wBAAgB,yBAAyB,IAAI,MAAM,EAAE,CAEpD;AAED;;;;;;;;;GASG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,OAAO,CAA8C;IAC7D,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAA2B;IAC9D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAyB;IACpD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAsC;gBAGnE,qBAAqB,CAAC,EAAE,wBAAwB,GAAG;QAAE,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,EACrE,UAAU,GAAE,eAAe,GAAG,IAAW,EACzC,cAAc,GAAE,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,GAAG,IAAW;IAQ5D;;;OAGG;IACG,KAAK,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IAkChD,uDAAuD;IACvD,SAAS,IAAI,YAAY,EAAE;IAI3B,4DAA4D;IACtD,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASvC,mCAAmC;IAC7B,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAMhC;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;CAQ3C"}

package/dist/_internal/platform/acp/manager.js

@@ -0,0 +1,105 @@
+/**
+ * AcpManager — Manages the lifecycle of all subagent ACP connections.
+ *
+ * The TUI orchestrator calls spawn() when it needs to delegate work.
+ * The manager tracks active subagents and provides cancel / waitAll.
+ */
+import { randomUUID } from 'node:crypto';
+import { AcpConnection } from './connection.js';
+import { emitAgentSpawning } from '../runtime/emitters/index.js';
+/**
+ * Command used to spawn subagent processes.
+ * Defaults to the current Bun binary running the TUI in --acp (headless ACP) mode.
+ * Override via ACP_AGENT_CMD env var (space-separated).
+ */
+function resolveAgentCommand() {
+    const envCmd = process.env.ACP_AGENT_CMD;
+    if (envCmd)
+        return envCmd.split(' ');
+    // Default: re-launch self in ACP agent mode
+    return [process.execPath, 'run', process.argv[1] ?? 'src/main.ts', '--acp'];
+}
+export function getDefaultAcpAgentCommand() {
+    return [...resolveAgentCommand()];
+}
+/**
+ * AcpManager — Manages multiple concurrent subagent connections.
+ *
+ * @example
+ * ```ts
+ * const mgr = new AcpManager(bus);
+ * const id = await mgr.spawn({ description: 'Fix the bug', context: '...', tools: ['read'] });
+ * const results = await mgr.waitAll();
+ * ```
+ */
+export class AcpManager {
+    connections = new Map();
+    pending = new Map();
+    agentCmd;
+    requestPermission;
+    runtimeBus;
+    hookDispatcher;
+    constructor(permissionOrLegacyBus, runtimeBus = null, hookDispatcher = null) {
+        this.agentCmd = resolveAgentCommand();
+        this.requestPermission = typeof permissionOrLegacyBus === 'function' ? permissionOrLegacyBus : undefined;
+        this.runtimeBus = runtimeBus;
+        this.hookDispatcher = hookDispatcher;
+    }
+    /**
+     * Spawn a new subagent and start running the task.
+     * Returns the subagent ID immediately; the task runs in the background.
+     */
+    async spawn(task) {
+        const id = randomUUID();
+        const conn = new AcpConnection(id, task, this.agentCmd, this.requestPermission, this.runtimeBus, this.hookDispatcher);
+        this.connections.set(id, conn);
+        if (this.runtimeBus) {
+            emitAgentSpawning(this.runtimeBus, {
+                sessionId: 'acp-manager',
+                traceId: `acp-manager:${id}`,
+                source: 'acp-manager',
+            }, {
+                agentId: id,
+                task: task.description,
+            });
+        }
+        // Start running — store the promise so waitAll() can await it
+        const promise = conn.run().finally(() => {
+            // Clean up tracking once done
+            this.connections.delete(id);
+            this.pending.delete(id);
+        });
+        this.pending.set(id, promise);
+        return id;
+    }
+    /** Returns info snapshots for all active subagents. */
+    getActive() {
+        return Array.from(this.connections.values()).map((c) => c.getInfo());
+    }
+    /** Cancel a specific subagent by ID. No-op if not found. */
+    async cancel(id) {
+        const conn = this.connections.get(id);
+        if (conn) {
+            await conn.cancel();
+            this.connections.delete(id);
+            this.pending.delete(id);
+        }
+    }
+    /** Cancel all active subagents. */
+    async cancelAll() {
+        await Promise.allSettled(Array.from(this.connections.keys()).map((id) => this.cancel(id)));
+    }
+    /**
+     * Wait for all currently active subagents to finish.
+     * Returns results in completion order.
+     */
+    async waitAll() {
+        const promises = Array.from(this.pending.values());
+        if (promises.length === 0)
+            return [];
+        const settled = await Promise.allSettled(promises);
+        return settled
+            .filter((r) => r.status === 'fulfilled')
+            .map((r) => r.value);
+    }
+}

package/dist/_internal/platform/adapters/bluebubbles/index.d.ts

@@ -0,0 +1,3 @@
+import type { SurfaceAdapterContext } from '../types.js';
+export declare function handleBlueBubblesSurfaceWebhook(req: Request, context: SurfaceAdapterContext): Promise<Response>;
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/adapters/bluebubbles/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/adapters/bluebubbles/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAgBzD,wBAAsB,+BAA+B,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,QAAQ,CAAC,CA6GrH"}