factory-factory 0.3.9 → 0.3.10

package/dist/src/backend/domains/session/acp/acp-runtime-manager.js

@@ -1,878 +0,0 @@
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { Readable, Writable } from 'node:stream';
-import { fileURLToPath } from 'node:url';
-import { ClientSideConnection, ndJsonStream, PROTOCOL_VERSION, } from '@agentclientprotocol/sdk';
-import pLimit from 'p-limit';
-import { createLogger } from '../../../../backend/services/logger.service.js';
-import { AcpClientHandler } from './acp-client-handler.js';
-import { AcpProcessHandle } from './acp-process-handle.js';
-const logger = createLogger('acp-runtime-manager');
-function resolveAcpBinary(packageName, binaryName) {
-    try {
-        const packageJsonPath = require.resolve(`${packageName}/package.json`);
-        const packageDir = dirname(packageJsonPath);
-        const pkg = require(packageJsonPath);
-        const binPath = typeof pkg.bin === 'string'
-            ? pkg.bin
-            : typeof pkg.bin?.[binaryName] === 'string'
-                ? pkg.bin[binaryName]
-                : undefined;
-        if (binPath) {
-            return join(packageDir, binPath);
-        }
-    }
-    catch {
-        logger.debug('Could not resolve binary via package.json, falling back to PATH', {
-            packageName,
-            binaryName,
-        });
-    }
-    return binaryName;
-}
-function normalizeUnknownError(error) {
-    return error instanceof Error ? error : new Error(String(error));
-}
-function createAcpSpawnError(commandLabel, error) {
-    const normalized = normalizeUnknownError(error);
-    return new Error(`Failed to spawn ACP adapter "${commandLabel}": ${normalized.message}`);
-}
-const DEFAULT_ACP_STARTUP_TIMEOUT_MS = 30_000;
-const MAX_FACTORY_ROOT_SEARCH_DEPTH = 20;
-async function withTimeout(params) {
-    return await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            reject(new Error(`ACP ${params.description} timed out after ${params.timeoutMs}ms`));
-        }, params.timeoutMs);
-        timeout.unref?.();
-        const clearTimer = () => {
-            clearTimeout(timeout);
-        };
-        if (typeof params.cancelOn !== 'undefined') {
-            void params.cancelOn.finally(clearTimer).catch(() => {
-            });
-        }
-        params.promise.then((value) => {
-            clearTimer();
-            resolve(value);
-        }, (error) => {
-            clearTimer();
-            reject(error);
-        });
-    });
-}
-function findFactoryRoot(startDir) {
-    let currentDir = startDir;
-    for (let depth = 0; depth < MAX_FACTORY_ROOT_SEARCH_DEPTH; depth += 1) {
-        const hasPackageJson = existsSync(join(currentDir, 'package.json'));
-        const hasCliDistEntrypoint = existsSync(join(currentDir, 'dist', 'src', 'cli', 'index.js'));
-        const hasCliSourceEntrypoint = existsSync(join(currentDir, 'src', 'cli', 'index.ts'));
-        if (hasPackageJson && (hasCliDistEntrypoint || hasCliSourceEntrypoint)) {
-            return currentDir;
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            return null;
-        }
-        currentDir = parentDir;
-    }
-    return null;
-}
-function resolveFactoryRootForInternalCodexAdapter() {
-    const moduleDir = dirname(fileURLToPath(import.meta.url));
-    const candidateStarts = [process.cwd(), moduleDir];
-    for (const candidate of candidateStarts) {
-        const root = findFactoryRoot(candidate);
-        if (root) {
-            return root;
-        }
-    }
-    throw new Error('Cannot resolve Factory Factory root for CODEX ACP adapter spawn');
-}
-function resolveInternalCodexAcpSpawnCommand() {
-    const projectRoot = resolveFactoryRootForInternalCodexAdapter();
-    const cliSourceEntrypoint = join(projectRoot, 'src', 'cli', 'index.ts');
-    const cliDistEntrypoint = join(projectRoot, 'dist', 'src', 'cli', 'index.js');
-    const tsconfigPath = join(projectRoot, 'tsconfig.json');
-    const tsxBin = join(projectRoot, 'node_modules', '.bin', process.platform === 'win32' ? 'tsx.cmd' : 'tsx');
-    const hasTypeScriptRuntime = process.execArgv.some((arg) => arg.includes('tsx')) ||
-        process.execArgv.some((arg) => arg.includes('ts-node'));
-    const preferSourceEntrypoint = process.env.NODE_ENV !== 'production';
-    const buildNodeSpawnCommand = (entrypoint) => {
-        const args = [entrypoint, 'internal', 'codex-app-server-acp'];
-        return {
-            command: process.execPath,
-            args,
-            commandLabel: `${process.execPath} ${args.join(' ')}`.trim(),
-        };
-    };
-    const resolveSourceSpawnCommand = () => {
-        if (!existsSync(cliSourceEntrypoint)) {
-            return null;
-        }
-        if (existsSync(tsxBin)) {
-            const args = [
-                ...(existsSync(tsconfigPath) ? ['--tsconfig', tsconfigPath] : []),
-                cliSourceEntrypoint,
-                'internal',
-                'codex-app-server-acp',
-            ];
-            return {
-                command: tsxBin,
-                args,
-                commandLabel: `${tsxBin} ${args.join(' ')}`.trim(),
-            };
-        }
-        if (hasTypeScriptRuntime) {
-            const args = [...process.execArgv, cliSourceEntrypoint, 'internal', 'codex-app-server-acp'];
-            return {
-                command: process.execPath,
-                args,
-                commandLabel: `${process.execPath} ${args.join(' ')}`.trim(),
-            };
-        }
-        return null;
-    };
-    if (preferSourceEntrypoint) {
-        const sourceCommand = resolveSourceSpawnCommand();
-        if (sourceCommand) {
-            return sourceCommand;
-        }
-        if (existsSync(cliDistEntrypoint)) {
-            return buildNodeSpawnCommand(cliDistEntrypoint);
-        }
-    }
-    else {
-        if (existsSync(cliDistEntrypoint)) {
-            return buildNodeSpawnCommand(cliDistEntrypoint);
-        }
-        const sourceCommand = resolveSourceSpawnCommand();
-        if (sourceCommand) {
-            return sourceCommand;
-        }
-    }
-    throw new Error('Cannot resolve CLI entrypoint for CODEX ACP adapter spawn');
-}
-function getAcpErrorLogDetails(error) {
-    if (error instanceof Error) {
-        return { message: error.message };
-    }
-    if (typeof error === 'object' && error !== null) {
-        const maybe = error;
-        const message = typeof maybe.message === 'string'
-            ? maybe.message
-            : (() => {
-                try {
-                    return JSON.stringify(error);
-                }
-                catch {
-                    return String(error);
-                }
-            })();
-        const code = typeof maybe.code === 'number' || typeof maybe.code === 'string' ? maybe.code : undefined;
-        return {
-            message,
-            ...(code !== undefined ? { code } : {}),
-            ...(typeof maybe.data !== 'undefined' ? { data: maybe.data } : {}),
-        };
-    }
-    return { message: String(error) };
-}
-function isMethodNotFoundError(error) {
-    const details = getAcpErrorLogDetails(error);
-    return details.code === -32_601 || details.message.includes('Method not found');
-}
-const REQUIRED_CONFIG_CATEGORIES = ['model', 'mode'];
-function isNonEmptyString(value) {
-    return typeof value === 'string' && value.length > 0;
-}
-function resolveModelFamilyName(description) {
-    if (!isNonEmptyString(description)) {
-        return null;
-    }
-    const familyName = description.split('·')[0]?.trim();
-    return familyName && familyName.length > 0 ? familyName : null;
-}
-function normalizeClaudeModelOption(option) {
-    if (option.value !== 'default') {
-        return option;
-    }
-    const modelFamilyName = resolveModelFamilyName(option.description);
-    if (!modelFamilyName) {
-        return option;
-    }
-    return {
-        ...option,
-        name: modelFamilyName,
-    };
-}
-function isOptionGroup(option) {
-    return 'group' in option;
-}
-function isOptionGroupArray(options) {
-    const [firstOption] = options;
-    return firstOption ? isOptionGroup(firstOption) : false;
-}
-function normalizeClaudeConfigOptions(configOptions) {
-    return configOptions.map((configOption) => {
-        if (configOption.category !== 'model') {
-            return configOption;
-        }
-        if (isOptionGroupArray(configOption.options)) {
-            const normalizedGroups = configOption.options.map((group) => ({
-                ...group,
-                options: group.options.map(normalizeClaudeModelOption),
-            }));
-            return {
-                ...configOption,
-                options: normalizedGroups,
-            };
-        }
-        const normalizedOptions = configOption.options.map(normalizeClaudeModelOption);
-        return {
-            ...configOption,
-            options: normalizedOptions,
-        };
-    });
-}
-function normalizeSessionConfigOptions(provider, configOptions) {
-    const providerNormalized = provider === 'CLAUDE' ? normalizeClaudeConfigOptions(configOptions) : configOptions;
-    return providerNormalized.map((configOption) => {
-        if (configOption.category || (configOption.id !== 'model' && configOption.id !== 'mode')) {
-            return configOption;
-        }
-        return {
-            ...configOption,
-            category: configOption.id,
-        };
-    });
-}
-function resolveModelConfigOption(models) {
-    if (!(models && Array.isArray(models.availableModels))) {
-        return null;
-    }
-    const options = models.availableModels
-        .filter((entry) => isNonEmptyString(entry.modelId))
-        .map((entry) => ({
-        value: entry.modelId,
-        name: isNonEmptyString(entry.name) ? entry.name : entry.modelId,
-        ...(isNonEmptyString(entry.description) ? { description: entry.description } : {}),
-    }));
-    if (options.length === 0) {
-        return null;
-    }
-    const preferredValue = isNonEmptyString(models.currentModelId) ? models.currentModelId : null;
-    const currentValue = (preferredValue && options.some((option) => option.value === preferredValue)
-        ? preferredValue
-        : options[0]?.value) ?? null;
-    if (!currentValue) {
-        return null;
-    }
-    return {
-        id: 'model',
-        name: 'Model',
-        type: 'select',
-        category: 'model',
-        currentValue,
-        options,
-    };
-}
-function resolveModeConfigOption(modes) {
-    if (!(modes && Array.isArray(modes.availableModes))) {
-        return null;
-    }
-    const options = modes.availableModes
-        .filter((entry) => isNonEmptyString(entry.id))
-        .map((entry) => ({
-        value: entry.id,
-        name: isNonEmptyString(entry.name) ? entry.name : entry.id,
-        ...(isNonEmptyString(entry.description) ? { description: entry.description } : {}),
-    }));
-    if (options.length === 0) {
-        return null;
-    }
-    const preferredValue = isNonEmptyString(modes.currentModeId) ? modes.currentModeId : null;
-    const currentValue = (preferredValue && options.some((option) => option.value === preferredValue)
-        ? preferredValue
-        : options[0]?.value) ?? null;
-    if (!currentValue) {
-        return null;
-    }
-    return {
-        id: 'mode',
-        name: 'Mode',
-        type: 'select',
-        category: 'mode',
-        currentValue,
-        options,
-    };
-}
-function fallbackSessionConfigOptions(sessionResult) {
-    const fallbackOptions = [];
-    const modelOption = resolveModelConfigOption(sessionResult.models);
-    if (modelOption) {
-        fallbackOptions.push(modelOption);
-    }
-    const modeOption = resolveModeConfigOption(sessionResult.modes);
-    if (modeOption) {
-        fallbackOptions.push(modeOption);
-    }
-    return fallbackOptions;
-}
-function requireSessionConfigOptions(provider, sessionSource, sessionResult) {
-    let configOptions = Array.isArray(sessionResult.configOptions) ? sessionResult.configOptions : [];
-    if (sessionSource !== 'setSessionConfigOption') {
-        const fallbackOptions = fallbackSessionConfigOptions(sessionResult);
-        if (configOptions.length === 0 && fallbackOptions.length > 0) {
-            logger.warn('ACP session response missing configOptions; deriving from models/modes', {
-                provider,
-                sessionSource,
-            });
-            configOptions = fallbackOptions;
-        }
-    }
-    if (configOptions.length === 0) {
-        throw new Error(`ACP ${provider} ${sessionSource} response did not include required configOptions`);
-    }
-    const normalizedConfigOptions = normalizeSessionConfigOptions(provider, configOptions);
-    const missingCategories = REQUIRED_CONFIG_CATEGORIES.filter((category) => !normalizedConfigOptions.some((option) => option.category === category));
-    if (missingCategories.length > 0) {
-        throw new Error(`ACP ${provider} ${sessionSource} response missing required config option categories: ${missingCategories.join(', ')}`);
-    }
-    return normalizedConfigOptions;
-}
-export class AcpRuntimeManager {
-    sessions = new Map();
-    pendingCreation = new Map();
-    stoppingInProgress = new Set();
-    creationLocks = new Map();
-    lockRefCounts = new Map();
-    onClientCreatedCallback = null;
-    acpStartupTimeoutMs = DEFAULT_ACP_STARTUP_TIMEOUT_MS;
-    constructor(options) {
-        this.setAcpStartupTimeoutMs(options?.acpStartupTimeoutMs ?? DEFAULT_ACP_STARTUP_TIMEOUT_MS);
-    }
-    setAcpStartupTimeoutMs(timeoutMs) {
-        if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-            this.acpStartupTimeoutMs = DEFAULT_ACP_STARTUP_TIMEOUT_MS;
-            return;
-        }
-        this.acpStartupTimeoutMs = Math.floor(timeoutMs);
-    }
-    setOnClientCreated(callback) {
-        this.onClientCreatedCallback = callback;
-    }
-    isStopInProgress(sessionId) {
-        return this.stoppingInProgress.has(sessionId);
-    }
-    getClient(sessionId) {
-        const handle = this.sessions.get(sessionId);
-        return handle?.isRunning() ? handle : undefined;
-    }
-    getPendingClient(sessionId) {
-        return this.pendingCreation.get(sessionId);
-    }
-    getOrCreateClient(sessionId, options, handlers, context) {
-        let lock = this.creationLocks.get(sessionId);
-        if (!lock) {
-            lock = pLimit(1);
-            this.creationLocks.set(sessionId, lock);
-            this.lockRefCounts.set(sessionId, 0);
-        }
-        const currentCount = this.lockRefCounts.get(sessionId) ?? 0;
-        this.lockRefCounts.set(sessionId, currentCount + 1);
-        return lock(async () => {
-            try {
-                const existing = this.sessions.get(sessionId);
-                if (existing?.isRunning()) {
-                    logger.debug('Returning existing running ACP client', { sessionId });
-                    return existing;
-                }
-                const pending = this.pendingCreation.get(sessionId);
-                if (pending) {
-                    logger.debug('Waiting for pending ACP client creation', { sessionId });
-                    return await pending;
-                }
-                logger.info('Creating new ACP client', { sessionId, provider: options.provider });
-                const createPromise = this.createClient(sessionId, options, handlers, context);
-                this.pendingCreation.set(sessionId, createPromise);
-                try {
-                    return await createPromise;
-                }
-                finally {
-                    this.pendingCreation.delete(sessionId);
-                }
-            }
-            finally {
-                const refCount = this.lockRefCounts.get(sessionId) ?? 1;
-                const newCount = refCount - 1;
-                if (newCount <= 0) {
-                    this.creationLocks.delete(sessionId);
-                    this.lockRefCounts.delete(sessionId);
-                }
-                else {
-                    this.lockRefCounts.set(sessionId, newCount);
-                }
-            }
-        });
-    }
-    async createClient(sessionId, options, handlers, context) {
-        const isCodex = options.provider === 'CODEX';
-        const spawnCommand = options.adapterBinaryPath
-            ? {
-                command: options.adapterBinaryPath,
-                args: [],
-                commandLabel: options.adapterBinaryPath,
-            }
-            : isCodex
-                ? resolveInternalCodexAcpSpawnCommand()
-                : (() => {
-                    const binaryName = 'claude-code-acp';
-                    const packageName = '@zed-industries/claude-code-acp';
-                    const binaryPath = resolveAcpBinary(packageName, binaryName);
-                    return {
-                        command: binaryPath,
-                        args: [],
-                        commandLabel: binaryPath,
-                    };
-                })();
-        logger.info('Spawning ACP subprocess', {
-            sessionId,
-            command: spawnCommand.command,
-            args: spawnCommand.args,
-            provider: options.provider,
-            workingDir: options.workingDir,
-        });
-        const spawnEnv = {
-            ...process.env,
-            BROWSER: 'none',
-            ...(isCodex ? { DOTENV_CONFIG_QUIET: 'true' } : {}),
-        };
-        const child = spawn(spawnCommand.command, spawnCommand.args, {
-            cwd: options.workingDir,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            env: spawnEnv,
-            detached: false,
-        });
-        let startupErrorListener = null;
-        const startupError = new Promise((_, reject) => {
-            startupErrorListener = (error) => reject(createAcpSpawnError(spawnCommand.commandLabel, error));
-            child.once('error', startupErrorListener);
-        });
-        this.wireChildErrorHandler(child, sessionId, handlers);
-        child.stderr?.on('data', (chunk) => {
-            handlers.onAcpLog?.(options.sessionId, {
-                eventType: 'acp_stderr',
-                data: chunk.toString(),
-            });
-        });
-        if (!(child.stdout && child.stdin)) {
-            throw new Error('ACP subprocess stdio streams not available');
-        }
-        const input = Readable.toWeb(child.stdout);
-        const output = Writable.toWeb(child.stdin);
-        const stream = ndJsonStream(output, input);
-        const acpEventHandler = handlers.onAcpEvent;
-        const onEvent = acpEventHandler
-            ? (sid, event) => acpEventHandler(sid, event)
-            : (_sid, _event) => {
-                logger.debug('ACP event received but no handler registered', { sessionId });
-            };
-        const connection = new ClientSideConnection((_agent) => new AcpClientHandler(sessionId, onEvent, handlers.permissionBridge, handlers.onAcpLog), stream);
-        let initResult;
-        let sessionInfo;
-        const startupTimeoutMs = this.acpStartupTimeoutMs;
-        const startupErrorSettled = startupError.catch(() => undefined);
-        try {
-            initResult = await Promise.race([
-                withTimeout({
-                    promise: connection.initialize({
-                        protocolVersion: PROTOCOL_VERSION,
-                        clientCapabilities: {},
-                        clientInfo: {
-                            name: 'factory-factory',
-                            title: 'Factory Factory',
-                            version: '1.2.0',
-                        },
-                    }),
-                    timeoutMs: startupTimeoutMs,
-                    description: 'initialize handshake',
-                    cancelOn: startupErrorSettled,
-                }),
-                startupError,
-            ]);
-            logger.info('ACP connection initialized', {
-                sessionId,
-                agentCapabilities: initResult.agentCapabilities,
-            });
-            const agentCapabilities = initResult.agentCapabilities ?? {};
-            sessionInfo = await Promise.race([
-                withTimeout({
-                    promise: this.createOrResumeSession(connection, sessionId, options, agentCapabilities),
-                    timeoutMs: startupTimeoutMs,
-                    description: 'session creation',
-                    cancelOn: startupErrorSettled,
-                }),
-                startupError,
-            ]);
-        }
-        catch (error) {
-            this.cleanupFailedClientCreation(child, sessionId);
-            throw error;
-        }
-        finally {
-            if (startupErrorListener) {
-                child.removeListener('error', startupErrorListener);
-                startupErrorListener = null;
-            }
-        }
-        const agentCapabilities = initResult.agentCapabilities ?? {};
-        const handle = new AcpProcessHandle({
-            connection,
-            child,
-            provider: options.provider,
-            providerSessionId: sessionInfo.providerSessionId,
-            agentCapabilities,
-        });
-        handle.configOptions = sessionInfo.configOptions;
-        this.sessions.set(sessionId, handle);
-        this.wireChildExitHandler(sessionId, child, handlers);
-        await this.notifyClientCreated(sessionId, handle, context, handlers);
-        return handle;
-    }
-    cleanupFailedClientCreation(child, sessionId) {
-        if (child.exitCode !== null) {
-            return;
-        }
-        try {
-            child.kill('SIGTERM');
-            if (child.exitCode === null) {
-                child.kill('SIGKILL');
-            }
-        }
-        catch {
-        }
-        logger.warn('Cleaned up ACP subprocess after initialization failure', {
-            sessionId,
-            pid: child.pid,
-        });
-    }
-    wireChildExitHandler(sessionId, child, handlers) {
-        child.on('exit', async (code) => {
-            this.sessions.delete(sessionId);
-            this.pendingCreation.delete(sessionId);
-            if (this.stoppingInProgress.has(sessionId)) {
-                logger.debug('Skipping exit handler - stop in progress', { sessionId, code });
-                return;
-            }
-            if (handlers.onExit) {
-                try {
-                    await handlers.onExit(sessionId, code);
-                }
-                catch (error) {
-                    logger.warn('Failed to handle ACP exit event', {
-                        sessionId,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            }
-        });
-    }
-    async notifyClientCreated(sessionId, handle, context, handlers) {
-        if (this.onClientCreatedCallback) {
-            this.onClientCreatedCallback(sessionId, handle, context);
-        }
-        if (handlers.onSessionId) {
-            try {
-                await handlers.onSessionId(sessionId, handle.providerSessionId);
-            }
-            catch (error) {
-                logger.warn('Failed to handle ACP session ID event', {
-                    sessionId,
-                    providerSessionId: handle.providerSessionId,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-    }
-    wireChildErrorHandler(child, sessionId, handlers) {
-        child.on('error', async (error) => {
-            const normalizedError = normalizeUnknownError(error);
-            if (handlers.onError) {
-                try {
-                    await handlers.onError(sessionId, normalizedError);
-                }
-                catch (handlerError) {
-                    logger.warn('Failed to handle ACP error event', {
-                        sessionId,
-                        originalError: normalizedError.message,
-                        handlerError: handlerError instanceof Error ? handlerError.message : String(handlerError),
-                    });
-                }
-            }
-            else {
-                logger.warn('ACP child process error (no handler provided)', {
-                    sessionId,
-                    error: normalizedError.message,
-                });
-            }
-        });
-    }
-    async createOrResumeSession(connection, sessionId, options, agentCapabilities) {
-        const storedId = options.resumeProviderSessionId;
-        const canResume = agentCapabilities.loadSession === true && !!storedId;
-        if (canResume && storedId) {
-            let loadResult = null;
-            try {
-                loadResult = await connection.loadSession({
-                    sessionId: storedId,
-                    cwd: options.workingDir,
-                    mcpServers: [],
-                });
-            }
-            catch (error) {
-                const details = getAcpErrorLogDetails(error);
-                logger.warn('loadSession failed, falling back to newSession', {
-                    sessionId,
-                    storedProviderSessionId: storedId,
-                    error: details.message,
-                    ...(details.code !== undefined ? { errorCode: details.code } : {}),
-                    ...(typeof details.data !== 'undefined' ? { errorData: details.data } : {}),
-                });
-            }
-            if (loadResult !== null) {
-                logger.info('ACP session resumed via loadSession', {
-                    sessionId,
-                    providerSessionId: storedId,
-                });
-                return {
-                    providerSessionId: storedId,
-                    configOptions: requireSessionConfigOptions(options.provider, 'loadSession', loadResult),
-                };
-            }
-        }
-        const sessionResult = await connection.newSession({
-            cwd: options.workingDir,
-            mcpServers: [],
-        });
-        logger.info('ACP session created', {
-            sessionId,
-            providerSessionId: sessionResult.sessionId,
-        });
-        return {
-            providerSessionId: sessionResult.sessionId,
-            configOptions: requireSessionConfigOptions(options.provider, 'newSession', sessionResult),
-        };
-    }
-    async stopClient(sessionId) {
-        if (this.stoppingInProgress.has(sessionId)) {
-            logger.debug('ACP session stop already in progress', { sessionId });
-            return;
-        }
-        const handle = this.sessions.get(sessionId);
-        if (!handle) {
-            return;
-        }
-        this.stoppingInProgress.add(sessionId);
-        try {
-            if (handle.isPromptInFlight) {
-                try {
-                    await handle.connection.cancel({
-                        sessionId: handle.providerSessionId,
-                    });
-                }
-                catch (error) {
-                    logger.debug('Failed to cancel prompt during stop (expected)', {
-                        sessionId,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            }
-            const exitPromise = new Promise((resolve) => {
-                handle.child.on('exit', () => resolve());
-                if (handle.child.exitCode !== null) {
-                    resolve();
-                }
-            });
-            handle.child.kill('SIGTERM');
-            const timeoutPromise = new Promise((resolve) => setTimeout(resolve, 5000));
-            await Promise.race([exitPromise, timeoutPromise]);
-            if (handle.child.exitCode === null) {
-                logger.warn('ACP process did not exit after SIGTERM, escalating to SIGKILL', {
-                    sessionId,
-                    pid: handle.getPid(),
-                });
-                handle.child.kill('SIGKILL');
-            }
-        }
-        finally {
-            this.stoppingInProgress.delete(sessionId);
-            this.sessions.delete(sessionId);
-        }
-    }
-    async sendPrompt(sessionId, content) {
-        const handle = this.sessions.get(sessionId);
-        if (!handle) {
-            throw new Error(`No ACP session found for sessionId: ${sessionId}`);
-        }
-        handle.isPromptInFlight = true;
-        try {
-            const result = await handle.connection.prompt({
-                sessionId: handle.providerSessionId,
-                prompt: [{ type: 'text', text: content }],
-            });
-            handle.isPromptInFlight = false;
-            return { stopReason: result.stopReason };
-        }
-        catch (error) {
-            handle.isPromptInFlight = false;
-            throw error;
-        }
-    }
-    async cancelPrompt(sessionId) {
-        const handle = this.sessions.get(sessionId);
-        if (!handle) {
-            return;
-        }
-        if (handle.isPromptInFlight) {
-            await handle.connection.cancel({
-                sessionId: handle.providerSessionId,
-            });
-        }
-    }
-    async setConfigOption(sessionId, configId, value) {
-        const handle = this.sessions.get(sessionId);
-        if (!handle) {
-            throw new Error(`No ACP session found for sessionId: ${sessionId}`);
-        }
-        try {
-            const response = await handle.connection.setSessionConfigOption({
-                sessionId: handle.providerSessionId,
-                configId,
-                value,
-            });
-            const configOptions = requireSessionConfigOptions(handle.provider, 'setSessionConfigOption', {
-                configOptions: response.configOptions,
-            });
-            handle.configOptions = configOptions;
-            return configOptions;
-        }
-        catch (error) {
-            logger.warn('setSessionConfigOption failed', {
-                sessionId,
-                configId,
-                provider: handle.provider,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw error;
-        }
-    }
-    async setSessionMode(sessionId, modeId) {
-        const handle = this.sessions.get(sessionId);
-        if (!handle) {
-            throw new Error(`No ACP session found for sessionId: ${sessionId}`);
-        }
-        try {
-            await handle.connection.setSessionMode({
-                sessionId: handle.providerSessionId,
-                modeId,
-            });
-            handle.configOptions = handle.configOptions.map((option) => option.category === 'mode' ? { ...option, currentValue: modeId } : option);
-            return [...handle.configOptions];
-        }
-        catch (error) {
-            logger.warn('setSessionMode failed', {
-                sessionId,
-                modeId,
-                provider: handle.provider,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw error;
-        }
-    }
-    async setSessionModel(sessionId, modelId) {
-        const handle = this.sessions.get(sessionId);
-        if (!handle) {
-            throw new Error(`No ACP session found for sessionId: ${sessionId}`);
-        }
-        const applyModelToCache = () => {
-            handle.configOptions = handle.configOptions.map((option) => option.category === 'model' ? { ...option, currentValue: modelId } : option);
-            return [...handle.configOptions];
-        };
-        if (handle.provider === 'CLAUDE') {
-            try {
-                await handle.connection.unstable_setSessionModel({
-                    sessionId: handle.providerSessionId,
-                    modelId,
-                });
-                return applyModelToCache();
-            }
-            catch (error) {
-                if (!isMethodNotFoundError(error)) {
-                    logger.warn('setSessionModel failed', {
-                        sessionId,
-                        modelId,
-                        provider: handle.provider,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                    throw error;
-                }
-                logger.warn('unstable_setSessionModel unavailable, falling back to setSessionConfigOption', {
-                    sessionId,
-                    modelId,
-                    provider: handle.provider,
-                });
-            }
-        }
-        return await this.setConfigOption(sessionId, 'model', modelId);
-    }
-    async stopAllClients(timeoutMs = 5000) {
-        const stopPromises = [];
-        for (const sessionId of this.sessions.keys()) {
-            const stopPromise = Promise.race([
-                this.stopClient(sessionId),
-                new Promise((resolve) => setTimeout(resolve, timeoutMs)),
-            ]);
-            stopPromises.push(stopPromise);
-        }
-        await Promise.all(stopPromises);
-        this.sessions.clear();
-        this.creationLocks.clear();
-        this.lockRefCounts.clear();
-        logger.info('All ACP clients stopped and cleaned up');
-    }
-    getAllClients() {
-        return this.sessions.entries();
-    }
-    isSessionRunning(sessionId) {
-        const handle = this.sessions.get(sessionId);
-        return handle?.isRunning() ?? false;
-    }
-    isSessionWorking(sessionId) {
-        const handle = this.sessions.get(sessionId);
-        return handle?.isPromptInFlight ?? false;
-    }
-    isAnySessionWorking(sessionIds) {
-        return sessionIds.some((id) => this.isSessionWorking(id));
-    }
-    getAllActiveProcesses() {
-        const processes = [];
-        for (const [sessionId, handle] of this.sessions) {
-            processes.push({
-                sessionId,
-                pid: handle.getPid(),
-                status: handle.isRunning() ? 'running' : 'stopped',
-                isRunning: handle.isRunning(),
-                isPromptInFlight: handle.isPromptInFlight,
-                provider: handle.provider,
-            });
-        }
-        return processes;
-    }
-}
-function createAcpRuntimeManager() {
-    return new AcpRuntimeManager();
-}
-export const acpRuntimeManager = createAcpRuntimeManager();
-//# sourceMappingURL=acp-runtime-manager.js.map