factory-factory 0.2.7 → 0.3.0

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

@@ -0,0 +1,713 @@
+import { spawn } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { Readable, Writable } from 'node:stream';
+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(binaryPath, error) {
+    const normalized = normalizeUnknownError(error);
+    return new Error(`Failed to spawn ACP adapter "${binaryPath}": ${normalized.message}`);
+}
+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;
+    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 binaryName = isCodex ? 'codex-acp' : 'claude-code-acp';
+        const packageName = isCodex ? '@zed-industries/codex-acp' : '@zed-industries/claude-code-acp';
+        const binaryPath = options.adapterBinaryPath ?? resolveAcpBinary(packageName, binaryName);
+        logger.info('Spawning ACP subprocess', {
+            sessionId,
+            binaryPath,
+            provider: options.provider,
+            workingDir: options.workingDir,
+        });
+        const child = spawn(binaryPath, [], {
+            cwd: options.workingDir,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env },
+            detached: false,
+        });
+        let startupErrorListener = null;
+        const startupError = new Promise((_, reject) => {
+            startupErrorListener = (error) => reject(createAcpSpawnError(binaryPath, 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;
+        try {
+            initResult = await Promise.race([
+                connection.initialize({
+                    protocolVersion: PROTOCOL_VERSION,
+                    clientCapabilities: {},
+                    clientInfo: {
+                        name: 'factory-factory',
+                        title: 'Factory Factory',
+                        version: '1.2.0',
+                    },
+                }),
+                startupError,
+            ]);
+            logger.info('ACP connection initialized', {
+                sessionId,
+                agentCapabilities: initResult.agentCapabilities,
+            });
+            const agentCapabilities = initResult.agentCapabilities ?? {};
+            sessionInfo = await Promise.race([
+                this.createOrResumeSession(connection, sessionId, options, agentCapabilities),
+                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;
+    }
+}
+export const acpRuntimeManager = new AcpRuntimeManager();
+//# sourceMappingURL=acp-runtime-manager.js.map