factory-factory 0.3.9 → 0.3.11

package/dist/src/backend/services/run-script/service/run-script.service.js

@@ -0,0 +1,754 @@
+import { spawn } from 'node:child_process';
+import treeKill from 'tree-kill';
+import { toError } from '../../../../backend/lib/error-utils.js';
+import { FactoryConfigService } from '../../../../backend/services/factory-config.service.js';
+import { createLogger } from '../../../../backend/services/logger.service.js';
+import { PortAllocationService } from '../../../../backend/services/port-allocation.service.js';
+import { runScriptConfigPersistenceService, } from '../../../../backend/services/run-script-config-persistence.service.js';
+import { runScriptProxyService } from '../../../../backend/services/run-script-proxy.service.js';
+import { workspaceAccessor } from '../../../../backend/services/workspace/index.js';
+import { runScriptStateMachine } from './run-script-state-machine.service.js';
+const logger = createLogger('run-script-service');
+const MAX_OUTPUT_BUFFER_SIZE = 500 * 1024;
+export class RunScriptService {
+    runningProcesses = new Map();
+    postRunProcesses = new Map();
+    outputBuffers = new Map();
+    outputListeners = new Map();
+    postRunOutputBuffers = new Map();
+    postRunOutputListeners = new Map();
+    isShuttingDown = false;
+    shutdownHandlersRegistered = false;
+    async startRunScript(workspaceId) {
+        try {
+            const workspace = await workspaceAccessor.findById(workspaceId);
+            if (!workspace) {
+                throw new Error('Workspace not found');
+            }
+            if (!workspace.worktreePath) {
+                throw new Error('Workspace worktree not initialized');
+            }
+            const commands = await this.reconcileWorkspaceCommands(workspace);
+            if (!commands.runScriptCommand) {
+                throw new Error('No run script configured for this workspace');
+            }
+            const started = await runScriptStateMachine.start(workspaceId);
+            if (!started) {
+                const fresh = await workspaceAccessor.findById(workspaceId);
+                return {
+                    success: false,
+                    error: 'Run script is already running',
+                    pid: fresh?.runScriptPid ?? undefined,
+                    port: fresh?.runScriptPort ?? undefined,
+                };
+            }
+            let command = commands.runScriptCommand;
+            let port;
+            if (command.includes('{port}')) {
+                port = await PortAllocationService.findFreePort();
+                command = FactoryConfigService.substitutePort(command, port);
+                logger.info('Allocated port for run script', {
+                    workspaceId,
+                    port,
+                });
+            }
+            logger.info('Starting run script', {
+                workspaceId,
+                command,
+                cwd: workspace.worktreePath,
+            });
+            const childProcess = spawn('bash', ['-c', command], {
+                cwd: workspace.worktreePath,
+                detached: false,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            const pid = childProcess.pid;
+            if (!pid) {
+                throw new Error('Failed to spawn run script process');
+            }
+            this.runningProcesses.set(workspaceId, childProcess);
+            const startMessage = `\x1b[36m[Factory Factory]\x1b[0m Starting ${command}\n\n`;
+            this.outputBuffers.set(workspaceId, startMessage);
+            this.postRunOutputBuffers.delete(workspaceId);
+            this.registerProcessHandlers(workspaceId, childProcess, pid);
+            return await this.transitionToRunning(workspaceId, childProcess, pid, port, commands.runScriptPostRunCommand, workspace.worktreePath);
+        }
+        catch (error) {
+            return this.handleStartError(workspaceId, toError(error));
+        }
+    }
+    reconcileWorkspaceCommands(workspace) {
+        return runScriptConfigPersistenceService.reconcileWorkspaceCommandCache({
+            workspace,
+            persistWorkspaceCommands: async () => Promise.resolve(),
+        });
+    }
+    registerProcessHandlers(workspaceId, childProcess, pid) {
+        childProcess.on('exit', (code, signal) => {
+            void this.handleProcessExit(workspaceId, childProcess, pid, code, signal).catch((error) => {
+                logger.error('Failed to handle run script exit', toError(error), {
+                    workspaceId,
+                    pid,
+                    code,
+                    signal,
+                });
+            });
+        });
+        const handleOutput = (data) => {
+            this.appendOutput(workspaceId, data.toString());
+        };
+        childProcess.stdout?.on('data', handleOutput);
+        childProcess.stdout?.on('error', (error) => {
+            logger.warn('Run script stdout stream error', { workspaceId, error, pid });
+        });
+        childProcess.stderr?.on('data', handleOutput);
+        childProcess.stderr?.on('error', (error) => {
+            logger.warn('Run script stderr stream error', { workspaceId, error, pid });
+        });
+        childProcess.on('error', async (error) => {
+            logger.error('Run script spawn error', error, { workspaceId, pid });
+            this.runningProcesses.delete(workspaceId);
+            try {
+                await runScriptStateMachine.markFailed(workspaceId);
+            }
+            catch (stateError) {
+                logger.warn('Failed to transition to FAILED on spawn error (likely already transitioned)', {
+                    workspaceId,
+                    error: stateError,
+                });
+            }
+        });
+    }
+    async handleProcessExit(workspaceId, childProcess, pid, code, signal) {
+        logger.info('Run script exited', { workspaceId, pid, code, signal });
+        const trackedProcess = this.runningProcesses.get(workspaceId);
+        if (trackedProcess && trackedProcess !== childProcess) {
+            logger.info('Ignoring stale run script exit from non-active process', {
+                workspaceId,
+                exitingPid: pid,
+                activePid: trackedProcess.pid,
+            });
+            return;
+        }
+        this.runningProcesses.delete(workspaceId);
+        this.outputListeners.delete(workspaceId);
+        await this.killPostRunProcess(workspaceId);
+        await runScriptProxyService.stopTunnel(workspaceId);
+        try {
+            const ws = await workspaceAccessor.findById(workspaceId);
+            const status = ws?.runScriptStatus;
+            if (status === 'STOPPING') {
+                try {
+                    await runScriptStateMachine.completeStopping(workspaceId);
+                }
+                catch (error) {
+                    logger.warn('Failed to complete STOPPING after process exit (likely already transitioned)', {
+                        workspaceId,
+                        error,
+                    });
+                }
+                return;
+            }
+            if (status === 'IDLE' || status === 'COMPLETED' || status === 'FAILED') {
+                logger.debug(`Process exited while in ${status} state, skipping exit transition`, {
+                    workspaceId,
+                });
+                return;
+            }
+            if (code === 0) {
+                await runScriptStateMachine.markCompleted(workspaceId);
+            }
+            else {
+                await runScriptStateMachine.markFailed(workspaceId);
+            }
+        }
+        catch (error) {
+            logger.warn('Exit handler state transition failed (likely already transitioned)', {
+                workspaceId,
+                error,
+            });
+        }
+    }
+    appendOutput(workspaceId, output) {
+        const currentBuffer = this.outputBuffers.get(workspaceId) ?? '';
+        let newBuffer = currentBuffer + output;
+        if (newBuffer.length > MAX_OUTPUT_BUFFER_SIZE) {
+            newBuffer = newBuffer.slice(-MAX_OUTPUT_BUFFER_SIZE);
+        }
+        this.outputBuffers.set(workspaceId, newBuffer);
+        const listeners = this.outputListeners.get(workspaceId);
+        if (listeners) {
+            for (const listener of listeners) {
+                listener(output);
+            }
+        }
+    }
+    appendPostRunOutput(workspaceId, output) {
+        const currentBuffer = this.postRunOutputBuffers.get(workspaceId) ?? '';
+        let newBuffer = currentBuffer + output;
+        if (newBuffer.length > MAX_OUTPUT_BUFFER_SIZE) {
+            newBuffer = newBuffer.slice(-MAX_OUTPUT_BUFFER_SIZE);
+        }
+        this.postRunOutputBuffers.set(workspaceId, newBuffer);
+        const listeners = this.postRunOutputListeners.get(workspaceId);
+        if (listeners) {
+            for (const listener of listeners) {
+                listener(output);
+            }
+        }
+    }
+    async transitionToRunning(workspaceId, childProcess, pid, port, runScriptPostRunCommand = null, worktreePath = null) {
+        try {
+            await runScriptStateMachine.markRunning(workspaceId, { pid, port });
+            let proxyUrl = null;
+            if (port) {
+                proxyUrl = await this.ensureTunnelForActiveProcess(workspaceId, childProcess, pid, port);
+            }
+            if (runScriptPostRunCommand && worktreePath) {
+                void this.spawnPostRunScript(workspaceId, runScriptPostRunCommand, worktreePath, port).catch((error) => {
+                    logger.warn('Failed to start postRun script', { workspaceId, error });
+                });
+            }
+            return { success: true, port, pid, proxyUrl: proxyUrl ?? undefined };
+        }
+        catch (markRunningError) {
+            return this.handleMarkRunningRace(workspaceId, childProcess, pid, port, markRunningError);
+        }
+    }
+    async ensureTunnelForActiveProcess(workspaceId, childProcess, pid, port) {
+        const proxyUrl = await runScriptProxyService.ensureTunnel(workspaceId, port);
+        if (!proxyUrl) {
+            return null;
+        }
+        const isStillActive = this.runningProcesses.get(workspaceId) === childProcess && childProcess.exitCode === null;
+        if (isStillActive) {
+            return proxyUrl;
+        }
+        logger.info('Run script exited while tunnel was starting; cleaning up tunnel', {
+            workspaceId,
+            pid,
+            port,
+        });
+        await runScriptProxyService.stopTunnel(workspaceId);
+        return null;
+    }
+    async handleMarkRunningRace(workspaceId, childProcess, pid, port, markRunningError) {
+        const ws = await workspaceAccessor.findById(workspaceId);
+        const currentStatus = ws?.runScriptStatus;
+        if (currentStatus === 'COMPLETED' || currentStatus === 'FAILED') {
+            logger.info('Process exited before markRunning -- exit handler already transitioned state', {
+                workspaceId,
+                pid,
+                currentStatus,
+            });
+            return { success: true, port, pid };
+        }
+        if (currentStatus === 'IDLE' || currentStatus === 'STOPPING') {
+            logger.info('Concurrent stop completed before markRunning -- killing orphaned process', {
+                workspaceId,
+                pid,
+                currentStatus,
+            });
+            try {
+                childProcess.kill('SIGTERM');
+            }
+            catch {
+            }
+            this.runningProcesses.delete(workspaceId);
+            return { success: false, error: 'Run script was stopped before it could start' };
+        }
+        throw markRunningError;
+    }
+    async handleStartError(workspaceId, error) {
+        logger.error('Failed to start run script', error, { workspaceId });
+        if (error.name !== 'RunScriptStateMachineError') {
+            try {
+                const workspace = await workspaceAccessor.findById(workspaceId);
+                if (workspace?.runScriptStatus === 'STARTING') {
+                    await runScriptStateMachine.markFailed(workspaceId);
+                }
+            }
+            catch (stateError) {
+                logger.error('Failed to transition to FAILED state', toError(stateError), {
+                    workspaceId,
+                });
+            }
+        }
+        return { success: false, error: error.message };
+    }
+    async stopRunScript(workspaceId) {
+        try {
+            const workspace = await workspaceAccessor.findById(workspaceId);
+            if (!workspace) {
+                throw new Error('Workspace not found');
+            }
+            const childProcess = this.runningProcesses.get(workspaceId);
+            const pid = workspace.runScriptPid;
+            const status = workspace.runScriptStatus;
+            if (status === 'IDLE') {
+                await runScriptProxyService.stopTunnel(workspaceId);
+                return { success: true };
+            }
+            if (status === 'STOPPING') {
+                if (childProcess || pid) {
+                    await this.killProcessTree(workspaceId, childProcess, pid);
+                    await this.killPostRunProcess(workspaceId);
+                    await this.waitForProcessExit(workspaceId, childProcess, pid);
+                }
+                await this.completeStoppingAfterStop(workspaceId);
+                await runScriptProxyService.stopTunnel(workspaceId);
+                return { success: true };
+            }
+            if (status === 'COMPLETED' || status === 'FAILED') {
+                const result = await this.handleTerminalStateStop(workspaceId, childProcess);
+                await runScriptProxyService.stopTunnel(workspaceId);
+                return result;
+            }
+            if (!(childProcess || pid)) {
+                return { success: false, error: 'No run script is running' };
+            }
+            const raced = await this.attemptBeginStopping(workspaceId);
+            if (raced) {
+                await runScriptProxyService.stopTunnel(workspaceId);
+                return { success: true };
+            }
+            let runScriptCleanupCommand = workspace.runScriptCleanupCommand;
+            try {
+                const commands = await this.reconcileWorkspaceCommands(workspace);
+                runScriptCleanupCommand = commands.runScriptCleanupCommand;
+            }
+            catch (error) {
+                logger.warn('Failed to reconcile workspace commands during stop; using cached cleanup', {
+                    workspaceId,
+                    error,
+                });
+            }
+            if (runScriptCleanupCommand && workspace.worktreePath) {
+                await this.runCleanupScript(workspaceId, {
+                    runScriptCleanupCommand,
+                    worktreePath: workspace.worktreePath,
+                    runScriptPort: workspace.runScriptPort,
+                });
+            }
+            await this.killProcessTree(workspaceId, childProcess, pid);
+            await this.killPostRunProcess(workspaceId);
+            await this.waitForProcessExit(workspaceId, childProcess, pid);
+            await this.completeStoppingAfterStop(workspaceId);
+            await runScriptProxyService.stopTunnel(workspaceId);
+            return { success: true };
+        }
+        catch (error) {
+            const normalizedError = toError(error);
+            logger.error('Failed to stop run script', normalizedError, { workspaceId });
+            return { success: false, error: normalizedError.message };
+        }
+    }
+    async handleTerminalStateStop(workspaceId, childProcess) {
+        if (childProcess) {
+            logger.warn('Killing orphaned process in terminal state', {
+                workspaceId,
+                pid: childProcess.pid,
+            });
+            try {
+                childProcess.kill('SIGTERM');
+            }
+            catch {
+            }
+            this.runningProcesses.delete(workspaceId);
+        }
+        try {
+            await runScriptStateMachine.reset(workspaceId);
+        }
+        catch {
+        }
+        return { success: true };
+    }
+    async attemptBeginStopping(workspaceId) {
+        try {
+            await runScriptStateMachine.beginStopping(workspaceId);
+            return false;
+        }
+        catch (error) {
+            const fresh = await workspaceAccessor.findById(workspaceId);
+            const freshStatus = fresh?.runScriptStatus;
+            if (freshStatus === 'COMPLETED' ||
+                freshStatus === 'FAILED' ||
+                freshStatus === 'IDLE' ||
+                freshStatus === 'STOPPING') {
+                logger.debug('beginStopping raced with exit handler, treating as stopped', {
+                    workspaceId,
+                    freshStatus,
+                });
+                return true;
+            }
+            throw error;
+        }
+    }
+    async completeStoppingAfterStop(workspaceId) {
+        try {
+            await runScriptStateMachine.completeStopping(workspaceId);
+        }
+        catch (error) {
+            const fresh = await workspaceAccessor.findById(workspaceId);
+            if (fresh?.runScriptStatus === 'IDLE') {
+                logger.debug('completeStopping raced with exit handler, already IDLE', {
+                    workspaceId,
+                });
+                return;
+            }
+            throw error;
+        }
+    }
+    async runCleanupScript(workspaceId, workspace) {
+        logger.info('Running cleanup script before stopping', {
+            workspaceId,
+            cleanupCommand: workspace.runScriptCleanupCommand,
+        });
+        try {
+            const cleanupCommand = workspace.runScriptPort
+                ? FactoryConfigService.substitutePort(workspace.runScriptCleanupCommand, workspace.runScriptPort)
+                : workspace.runScriptCleanupCommand;
+            const cleanupProcess = spawn('bash', ['-c', cleanupCommand], {
+                cwd: workspace.worktreePath,
+                detached: false,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            cleanupProcess.stdout?.on('error', (error) => {
+                logger.warn('Cleanup script stdout stream error', { workspaceId, error });
+            });
+            cleanupProcess.stderr?.on('error', (error) => {
+                logger.warn('Cleanup script stderr stream error', { workspaceId, error });
+            });
+            await new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    logger.warn('Cleanup script timed out, proceeding anyway', { workspaceId });
+                    cleanupProcess.kill('SIGTERM');
+                    resolve();
+                }, 5000);
+                cleanupProcess.on('exit', (code) => {
+                    clearTimeout(timeout);
+                    logger.info('Cleanup script completed', { workspaceId, exitCode: code });
+                    resolve();
+                });
+                cleanupProcess.on('error', (error) => {
+                    clearTimeout(timeout);
+                    logger.error('Cleanup script error', error, { workspaceId });
+                    resolve();
+                });
+            });
+        }
+        catch (error) {
+            logger.error('Failed to run cleanup script', toError(error), { workspaceId });
+        }
+    }
+    async spawnPostRunScript(workspaceId, runScriptPostRunCommand, worktreePath, port) {
+        await Promise.resolve();
+        let command = runScriptPostRunCommand;
+        if (port && command.includes('{port}')) {
+            command = FactoryConfigService.substitutePort(command, port);
+        }
+        logger.info('Starting postRun script', { workspaceId, command });
+        const postRunProcess = spawn('bash', ['-c', command], {
+            cwd: worktreePath,
+            detached: false,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        if (!postRunProcess.pid) {
+            logger.warn('Failed to spawn postRun process', { workspaceId });
+            return;
+        }
+        this.postRunProcesses.set(workspaceId, postRunProcess);
+        const postRunStartMessage = `\x1b[36m[Factory Factory]\x1b[0m Starting postRun: ${command}\n`;
+        this.appendOutput(workspaceId, postRunStartMessage);
+        this.appendPostRunOutput(workspaceId, postRunStartMessage);
+        const handleOutput = (data) => {
+            this.appendPostRunOutput(workspaceId, data.toString());
+        };
+        postRunProcess.stdout?.on('data', handleOutput);
+        postRunProcess.stdout?.on('error', (error) => {
+            logger.warn('PostRun stdout stream error', { workspaceId, error });
+        });
+        postRunProcess.stderr?.on('data', handleOutput);
+        postRunProcess.stderr?.on('error', (error) => {
+            logger.warn('PostRun stderr stream error', { workspaceId, error });
+        });
+        postRunProcess.on('exit', (code, signal) => {
+            logger.info('PostRun script exited', {
+                workspaceId,
+                pid: postRunProcess.pid,
+                code,
+                signal,
+            });
+            this.postRunProcesses.delete(workspaceId);
+        });
+        postRunProcess.on('error', (error) => {
+            logger.error('PostRun spawn error', error, { workspaceId });
+            this.postRunProcesses.delete(workspaceId);
+        });
+    }
+    async killPostRunProcess(workspaceId) {
+        const postRunProcess = this.postRunProcesses.get(workspaceId);
+        if (!postRunProcess) {
+            return;
+        }
+        const postRunPid = postRunProcess.pid;
+        if (!postRunPid) {
+            this.postRunProcesses.delete(workspaceId);
+            return;
+        }
+        logger.info('Stopping postRun process', { workspaceId, pid: postRunPid });
+        await new Promise((resolve) => {
+            treeKill(postRunPid, 'SIGTERM', (err) => {
+                if (err) {
+                    const errorCode = err.code;
+                    const message = err.message;
+                    if (errorCode !== 'ESRCH' && !message.includes('No such process')) {
+                        logger.warn('Failed to tree-kill postRun process', {
+                            workspaceId,
+                            pid: postRunPid,
+                            error: message,
+                        });
+                    }
+                }
+                this.postRunProcesses.delete(workspaceId);
+                resolve();
+            });
+        });
+    }
+    async killProcessTree(workspaceId, childProcess, pid) {
+        const targetPid = childProcess?.pid ?? pid;
+        if (!targetPid) {
+            return;
+        }
+        const source = childProcess?.pid ? 'stored process' : 'PID';
+        logger.info(`Stopping run script via ${source}`, { workspaceId, pid: targetPid });
+        await new Promise((resolve) => {
+            treeKill(targetPid, 'SIGTERM', (err) => {
+                if (err) {
+                    const errorCode = err.code;
+                    const message = err.message;
+                    if (errorCode === 'ESRCH' || message.includes('No such process')) {
+                        logger.debug('Run script process already exited before tree-kill', {
+                            workspaceId,
+                            pid: targetPid,
+                            error: message,
+                        });
+                    }
+                    else {
+                        logger.warn('Failed to tree-kill run script process', {
+                            workspaceId,
+                            pid: targetPid,
+                            error: message,
+                        });
+                    }
+                }
+                this.runningProcesses.delete(workspaceId);
+                resolve();
+            });
+        });
+    }
+    async waitForProcessExit(workspaceId, childProcess, pid) {
+        if (!childProcess) {
+            return;
+        }
+        if (childProcess.exitCode !== null) {
+            return;
+        }
+        if (typeof childProcess.once !== 'function' || typeof childProcess.off !== 'function') {
+            return;
+        }
+        const waitPid = childProcess.pid ?? pid ?? undefined;
+        await new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                cleanup();
+                logger.warn('Timed out waiting for run script process exit after stop', {
+                    workspaceId,
+                    pid: waitPid,
+                });
+                resolve();
+            }, 10_000);
+            const cleanup = () => {
+                clearTimeout(timeout);
+                childProcess.off('exit', onExit);
+                childProcess.off('error', onError);
+            };
+            const onExit = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = (error) => {
+                cleanup();
+                logger.warn('Run script process emitted error while waiting for exit', {
+                    workspaceId,
+                    pid: waitPid,
+                    error,
+                });
+                resolve();
+            };
+            childProcess.once('exit', onExit);
+            childProcess.once('error', onError);
+            if (childProcess.exitCode !== null) {
+                cleanup();
+                resolve();
+            }
+        });
+    }
+    async getRunScriptStatus(workspaceId) {
+        const workspace = await workspaceAccessor.findById(workspaceId);
+        if (!workspace) {
+            throw new Error('Workspace not found');
+        }
+        const status = await runScriptStateMachine.verifyRunning(workspaceId);
+        const freshWorkspace = await workspaceAccessor.findById(workspaceId);
+        if (!freshWorkspace) {
+            throw new Error('Workspace not found');
+        }
+        return {
+            status,
+            pid: freshWorkspace.runScriptPid,
+            port: freshWorkspace.runScriptPort,
+            proxyUrl: runScriptProxyService.getTunnelUrl(workspaceId),
+            startedAt: freshWorkspace.runScriptStartedAt,
+            hasRunScript: !!freshWorkspace.runScriptCommand,
+            runScriptCommand: freshWorkspace.runScriptCommand,
+            runScriptPostRunCommand: freshWorkspace.runScriptPostRunCommand,
+            runScriptCleanupCommand: freshWorkspace.runScriptCleanupCommand,
+        };
+    }
+    getOutputBuffer(workspaceId) {
+        return this.outputBuffers.get(workspaceId) ?? '';
+    }
+    evictWorkspaceBuffers(workspaceId) {
+        this.outputBuffers.delete(workspaceId);
+        this.outputListeners.delete(workspaceId);
+        this.postRunOutputBuffers.delete(workspaceId);
+        this.postRunOutputListeners.delete(workspaceId);
+    }
+    subscribeToOutput(workspaceId, listener) {
+        let listeners = this.outputListeners.get(workspaceId);
+        if (!listeners) {
+            listeners = new Set();
+            this.outputListeners.set(workspaceId, listeners);
+        }
+        listeners.add(listener);
+        return () => {
+            const listeners = this.outputListeners.get(workspaceId);
+            if (listeners) {
+                listeners.delete(listener);
+                if (listeners.size === 0) {
+                    this.outputListeners.delete(workspaceId);
+                }
+            }
+        };
+    }
+    getPostRunOutputBuffer(workspaceId) {
+        return this.postRunOutputBuffers.get(workspaceId) ?? '';
+    }
+    subscribeToPostRunOutput(workspaceId, listener) {
+        let listeners = this.postRunOutputListeners.get(workspaceId);
+        if (!listeners) {
+            listeners = new Set();
+            this.postRunOutputListeners.set(workspaceId, listeners);
+        }
+        listeners.add(listener);
+        return () => {
+            const listeners = this.postRunOutputListeners.get(workspaceId);
+            if (listeners) {
+                listeners.delete(listener);
+                if (listeners.size === 0) {
+                    this.postRunOutputListeners.delete(workspaceId);
+                }
+            }
+        };
+    }
+    async cleanup() {
+        logger.info('Cleaning up all running scripts', {
+            count: this.runningProcesses.size,
+        });
+        const workspaceIds = Array.from(this.runningProcesses.keys());
+        await Promise.all(workspaceIds.map(async (workspaceId) => {
+            try {
+                await this.stopRunScript(workspaceId);
+            }
+            catch (error) {
+                logger.error('Failed to stop run script during cleanup', toError(error), {
+                    workspaceId,
+                });
+            }
+        }));
+        this.runningProcesses.clear();
+        this.postRunProcesses.clear();
+        await runScriptProxyService.cleanup();
+    }
+    cleanupSync() {
+        logger.info('Process exiting, killing any remaining run scripts');
+        for (const [workspaceId, childProcess] of this.runningProcesses.entries()) {
+            try {
+                if (!childProcess.killed) {
+                    childProcess.kill('SIGKILL');
+                }
+                logger.info('Force killed run script on exit', {
+                    workspaceId,
+                    pid: childProcess.pid,
+                });
+            }
+            catch {
+            }
+        }
+        this.runningProcesses.clear();
+        for (const [workspaceId, postRunProcess] of this.postRunProcesses.entries()) {
+            try {
+                if (!postRunProcess.killed) {
+                    postRunProcess.kill('SIGKILL');
+                }
+                logger.info('Force killed postRun script on exit', {
+                    workspaceId,
+                    pid: postRunProcess.pid,
+                });
+            }
+            catch {
+            }
+        }
+        this.postRunProcesses.clear();
+        runScriptProxyService.cleanupSync();
+        this.outputBuffers.clear();
+        this.outputListeners.clear();
+        this.postRunOutputBuffers.clear();
+        this.postRunOutputListeners.clear();
+    }
+    registerShutdownHandlers() {
+        if (this.shutdownHandlersRegistered) {
+            return;
+        }
+        this.shutdownHandlersRegistered = true;
+        process.on('SIGINT', async () => {
+            if (this.isShuttingDown) {
+                return;
+            }
+            this.isShuttingDown = true;
+            logger.info('Received SIGINT, cleaning up run scripts');
+            await this.cleanup();
+        });
+        process.on('SIGTERM', async () => {
+            if (this.isShuttingDown) {
+                return;
+            }
+            this.isShuttingDown = true;
+            logger.info('Received SIGTERM, cleaning up run scripts');
+            await this.cleanup();
+        });
+        process.on('exit', () => {
+            if (!this.isShuttingDown) {
+                this.cleanupSync();
+            }
+        });
+    }
+}
+export function createRunScriptService(options = {}) {
+    const service = new RunScriptService();
+    if (options.registerShutdownHandlers) {
+        service.registerShutdownHandlers();
+    }
+    return service;
+}
+//# sourceMappingURL=run-script.service.js.map