devchain-cli 0.16.1 → 0.17.0

package/dist/server/modules/orchestrator/worktrees/services/worktrees.service.js

@@ -16,15 +16,15 @@ exports.WorktreesService = void 0;
 const common_1 = require("@nestjs/common");
 const event_emitter_1 = require("@nestjs/event-emitter");
 const crypto_1 = require("crypto");
-const fs_1 = require("fs");
 const logger_1 = require("../../../../common/logging/logger");
 const env_config_1 = require("../../../../common/config/env.config");
 const event_log_service_1 = require("../../../events/services/event-log.service");
 const worktree_dto_1 = require("../dtos/worktree.dto");
 const worktrees_store_1 = require("../worktrees.store");
 const git_worktree_service_1 = require("../../git/services/git-worktree.service");
-const docker_service_1 = require("../../docker/services/docker.service");
 const seed_preparation_service_1 = require("../../docker/services/seed-preparation.service");
+const container_runtime_1 = require("../runtime/container-runtime");
+const process_runtime_1 = require("../runtime/process-runtime");
 const task_merge_events_1 = require("../../sync/events/task-merge.events");
 const worktree_events_1 = require("../events/worktree.events");
 const promises_1 = require("fs/promises");
@@ -33,33 +33,26 @@ const worktree_validation_1 = require("../worktree-validation");
 const storage_interface_1 = require("../../../storage/interfaces/storage.interface");
 const error_types_1 = require("../../../../common/errors/error-types");
 const path_validation_1 = require("../../../../common/validation/path-validation");
-const process_executor_port_1 = require("../../../terminal/services/process-executor/process-executor.port");
 const logger = (0, logger_1.createLogger)('OrchestratorWorktreesService');
 const CONTAINER_HEALTH_TIMEOUT_MS = 60_000;
 const HEALTH_MONITOR_INTERVAL_MS = 15_000;
 const HEALTH_MONITOR_PROBE_TIMEOUT_MS = 1_500;
 const MAX_CONSECUTIVE_HEALTH_FAILURES = 3;
 const OVERVIEW_FETCH_TIMEOUT_MS = 2_500;
-const PROCESS_SHUTDOWN_TIMEOUT_MS = 30_000;
-const PROCESS_KILL_TIMEOUT_MS = 5_000;
-const PROCESS_LOG_FILE_NAME = 'devchain.log';
-const PROCESS_DB_FILE_NAME = 'devchain.db';
-const PROCESS_RUNTIME_PORT_FILE = 'runtime-port.json';
-const PROCESS_HEALTH_POLL_INTERVAL_MS = 1_000;
-const PROCESS_RUNTIME_TIMEOUT_MS = 1_500;
 const WORKTREE_ACTIVITY_EVENT_NAME = 'orchestrator.worktree.activity';
 const WORKTREE_STATUS_VALUES = worktree_dto_1.WorktreeStatusSchema.options;
 let WorktreesService = class WorktreesService {
-    constructor(store, dockerService, gitService, seedPreparationService, eventEmitter, eventLogService, storage, executor) {
+    constructor(store, containerRuntime, processRuntime, gitService, seedPreparationService, eventEmitter, eventLogService, storage) {
         this.store = store;
-        this.dockerService = dockerService;
+        this.containerRuntime = containerRuntime;
+        this.processRuntime = processRuntime;
         this.gitService = gitService;
         this.seedPreparationService = seedPreparationService;
         this.eventEmitter = eventEmitter;
         this.eventLogService = eventLogService;
         this.storage = storage;
-        this.executor = executor;
         this.consecutiveHealthFailures = new Map();
+        this.inFlightOperations = new Map();
     }
     async onModuleInit() {
         this.monitorTimer = setInterval(() => {
@@ -71,7 +64,7 @@ let WorktreesService = class WorktreesService {
             logger.warn({ error }, 'Failed process-runtime orphan detection on startup');
         });
         try {
-            this.unsubscribeDockerEvents = await this.dockerService.subscribeToContainerEvents((event) => {
+            this.unsubscribeDockerEvents = await this.containerRuntime.subscribeToContainerEvents((event) => {
                 this.handleContainerEvent(event).catch((error) => {
                     logger.error({ error, event }, 'Failed handling docker container event');
                 });
@@ -166,7 +159,7 @@ let WorktreesService = class WorktreesService {
             await (0, promises_1.mkdir)(dataPath, { recursive: true });
             await this.seedPreparationService.prepareSeedData(dataPath);
             if (runtimeType === 'process') {
-                const runtime = await this.startProcessRuntime({
+                const runtime = await this.processRuntime.startProcessRuntime({
                     worktreePath,
                     dataPath,
                     projectId,
@@ -192,7 +185,7 @@ let WorktreesService = class WorktreesService {
                 }));
             }
             else {
-                const container = await this.dockerService.createContainer({
+                const container = await this.containerRuntime.createContainer({
                     name: containerName,
                     worktreePath,
                     dataPath,
@@ -205,10 +198,10 @@ let WorktreesService = class WorktreesService {
                     },
                 });
                 containerId = container.id;
-                await this.dockerService
+                await this.containerRuntime
                     .ensureWorktreeOnComposeNetwork(input.name, container.id)
                     .catch(() => undefined);
-                const healthy = await this.dockerService.waitForHealthy(container.id, CONTAINER_HEALTH_TIMEOUT_MS);
+                const healthy = await this.containerRuntime.waitForHealthy(container.id, CONTAINER_HEALTH_TIMEOUT_MS);
                 if (!healthy) {
                     throw new Error('Container did not become healthy before timeout');
                 }
@@ -251,10 +244,10 @@ let WorktreesService = class WorktreesService {
                 errorMessage,
             });
             if (containerId) {
-                await this.dockerService.removeContainer(containerId, true).catch(() => undefined);
+                await this.containerRuntime.removeContainer(containerId, true).catch(() => undefined);
             }
             if (processId) {
-                await this.terminateProcess(processId).catch(() => undefined);
+                await this.processRuntime.terminateProcess(processId).catch(() => undefined);
             }
             if (gitWorktreeCreated) {
                 await this.gitService.removeWorktree(worktreePath, repoPath, true).catch(() => undefined);
@@ -268,14 +261,9 @@ let WorktreesService = class WorktreesService {
                     }, 'Failed to clean up branch after create-worktree error'));
                 }
             }
-            const logPath = this.resolveProcessLogPath(dataPath);
-            try {
-                const logContent = await (0, promises_1.readFile)(logPath, 'utf-8');
-                if (logContent.trim()) {
-                    logger.error({ worktreeId: created.id, logContent: logContent.slice(-2000) }, 'Process runtime log before cleanup');
-                }
-            }
-            catch {
+            const crashLog = await this.processRuntime.readRecentLog(dataPath);
+            if (crashLog) {
+                logger.error({ worktreeId: created.id, logContent: crashLog }, 'Process runtime log before cleanup');
             }
             await (0, promises_1.rm)(dataPath, { recursive: true, force: true }).catch(() => undefined);
             throw new common_1.BadRequestException(`Failed to create worktree: ${errorMessage}`);
@@ -307,6 +295,9 @@ let WorktreesService = class WorktreesService {
         return this.buildWorktreeOverview(row);
     }
     async deleteWorktree(id, options = {}) {
+        return this.withOperationGuard(id, 'delete', () => this.executeDelete(id, options));
+    }
+    async executeDelete(id, options) {
         const row = await this.requireWorktree(id);
         const runtimeType = this.resolveRuntimeType(row.runtimeType);
         const shouldDeleteBranch = options.deleteBranch ?? true;
@@ -317,19 +308,21 @@ let WorktreesService = class WorktreesService {
             : null;
         const dataPath = this.resolveDataPath(repoPath, row.name);
         if (runtimeType === 'container' || row.containerId) {
-            await this.dockerService
+            await this.containerRuntime
                 .cleanupWorktreeProjectContainers(row.name, row.containerId)
                 .catch((error) => logger.warn({ error, worktreeId: row.id }, 'Failed cleaning project sub-containers'));
             if (row.containerId) {
-                await this.dockerService.stopContainer(row.containerId).catch(() => undefined);
-                await this.dockerService.removeContainer(row.containerId, true).catch(() => undefined);
+                await this.containerRuntime.stopContainer(row.containerId).catch(() => undefined);
+                await this.containerRuntime.removeContainer(row.containerId, true).catch(() => undefined);
             }
-            await this.dockerService
+            await this.containerRuntime
                 .removeWorktreeNetwork(row.name)
                 .catch((error) => logger.warn({ error, worktreeId: row.id }, 'Failed removing worktree docker network'));
         }
         else {
-            await this.terminateProcess(row.processId).catch((error) => logger.warn({ error, worktreeId: row.id }, 'Failed stopping worktree process during delete'));
+            await this.processRuntime
+                .terminateProcess(row.processId)
+                .catch((error) => logger.warn({ error, worktreeId: row.id }, 'Failed stopping worktree process during delete'));
         }
         if (worktreePath) {
             await this.gitService.removeWorktree(worktreePath, repoPath, true).catch(() => undefined);
@@ -357,6 +350,9 @@ let WorktreesService = class WorktreesService {
         return { success: true };
     }
     async startWorktree(id) {
+        return this.withOperationGuard(id, 'start', () => this.executeStart(id));
+    }
+    async executeStart(id) {
         const row = await this.requireWorktree(id);
         const runtimeType = this.resolveRuntimeType(row.runtimeType);
         if (runtimeType === 'process') {
@@ -369,7 +365,7 @@ let WorktreesService = class WorktreesService {
             const dataPath = this.resolveDataPath(repoPath, row.name);
             await (0, promises_1.mkdir)(dataPath, { recursive: true });
             try {
-                const runtime = await this.startProcessRuntime({
+                const runtime = await this.processRuntime.startProcessRuntime({
                     worktreePath,
                     dataPath,
                     projectId,
@@ -394,18 +390,18 @@ let WorktreesService = class WorktreesService {
         if (!row.containerId) {
             throw new common_1.BadRequestException('Worktree has no container to start');
         }
-        await this.dockerService.startContainer(row.containerId);
-        const healthy = await this.dockerService.waitForHealthy(row.containerId, CONTAINER_HEALTH_TIMEOUT_MS);
+        await this.containerRuntime.startContainer(row.containerId);
+        const healthy = await this.containerRuntime.waitForHealthy(row.containerId, CONTAINER_HEALTH_TIMEOUT_MS);
         if (!healthy) {
             await this.tryUpdateStatus(row.id, 'error', {
                 errorMessage: 'Container failed readiness check after start',
             });
             throw new common_1.BadRequestException('Container started but failed readiness check');
         }
-        await this.dockerService
+        await this.containerRuntime
             .ensureWorktreeOnComposeNetwork(row.name, row.containerId)
             .catch(() => undefined);
-        const hostPort = await this.dockerService
+        const hostPort = await this.containerRuntime
             .getContainerHostPort(row.containerId)
             .catch(() => null);
         const updated = await this.tryUpdateStatus(row.id, 'running', {
@@ -415,10 +411,13 @@ let WorktreesService = class WorktreesService {
         return this.toResponse(updated ?? row);
     }
     async stopWorktree(id) {
+        return this.withOperationGuard(id, 'stop', () => this.executeStop(id));
+    }
+    async executeStop(id) {
         const row = await this.requireWorktree(id);
         const runtimeType = this.resolveRuntimeType(row.runtimeType);
         if (runtimeType === 'process') {
-            await this.terminateProcess(row.processId);
+            await this.processRuntime.terminateProcess(row.processId);
             this.consecutiveHealthFailures.set(row.id, 0);
             const updated = await this.tryUpdateStatus(row.id, 'stopped', {
                 processId: null,
@@ -432,7 +431,7 @@ let WorktreesService = class WorktreesService {
         if (!row.containerId) {
             throw new common_1.BadRequestException('Worktree has no container to stop');
         }
-        await this.dockerService.stopContainer(row.containerId);
+        await this.containerRuntime.stopContainer(row.containerId);
         this.consecutiveHealthFailures.set(row.id, 0);
         const updated = await this.tryUpdateStatus(row.id, 'stopped');
         return this.toResponse(updated ?? row);
@@ -465,6 +464,9 @@ let WorktreesService = class WorktreesService {
         };
     }
     async mergeWorktree(id) {
+        return this.withOperationGuard(id, 'merge', () => this.executeMerge(id));
+    }
+    async executeMerge(id) {
         const row = await this.requireWorktree(id);
         const currentStatus = String(row.status).toLowerCase();
         if (currentStatus === 'merged') {
@@ -477,7 +479,7 @@ let WorktreesService = class WorktreesService {
         const extractionRow = currentStatus === 'running' ? row : await this.ensureContainerReadyForTaskExtraction(row);
         await this.extractTasksForMergedHistory(extractionRow);
         if (row.containerId) {
-            await this.dockerService.stopContainer(row.containerId).catch(() => undefined);
+            await this.containerRuntime.stopContainer(row.containerId).catch(() => undefined);
         }
         const mergeResult = await this.gitService.executeMerge(row.repoPath, row.branchName, row.baseBranch, {
             message: this.buildMergeCommitMessage(row),
@@ -511,6 +513,9 @@ let WorktreesService = class WorktreesService {
         return this.toResponse(updated ?? row);
     }
     async rebaseWorktree(id) {
+        return this.withOperationGuard(id, 'rebase', () => this.executeRebase(id));
+    }
+    async executeRebase(id) {
         const row = await this.requireWorktree(id);
         const currentStatus = String(row.status).toLowerCase();
         if (currentStatus === 'merged') {
@@ -521,7 +526,7 @@ let WorktreesService = class WorktreesService {
         }
         await this.assertCleanWorkingTree(row.worktreePath ?? row.repoPath, 'Rebase');
         if (row.containerId) {
-            await this.dockerService.stopContainer(row.containerId).catch(() => undefined);
+            await this.containerRuntime.stopContainer(row.containerId).catch(() => undefined);
         }
         const rebaseResult = await this.gitService.executeRebase(row.worktreePath ?? row.repoPath, row.branchName, row.baseBranch);
         if (!rebaseResult.success) {
@@ -544,8 +549,8 @@ let WorktreesService = class WorktreesService {
             throw new common_1.BadRequestException(`Rebase failed: ${message}`);
         }
         if (row.containerId) {
-            await this.dockerService.startContainer(row.containerId).catch(() => undefined);
-            const healthy = await this.dockerService.waitForHealthy(row.containerId, CONTAINER_HEALTH_TIMEOUT_MS);
+            await this.containerRuntime.startContainer(row.containerId).catch(() => undefined);
+            const healthy = await this.containerRuntime.waitForHealthy(row.containerId, CONTAINER_HEALTH_TIMEOUT_MS);
             if (!healthy) {
                 await this.tryUpdateStatus(row.id, 'error', {
                     errorMessage: 'Container failed readiness check after rebase',
@@ -631,8 +636,8 @@ let WorktreesService = class WorktreesService {
             return false;
         }
         try {
-            await this.dockerService.startContainer(row.containerId).catch(() => undefined);
-            const healthy = await this.dockerService.waitForHealthy(row.containerId, CONTAINER_HEALTH_TIMEOUT_MS);
+            await this.containerRuntime.startContainer(row.containerId).catch(() => undefined);
+            const healthy = await this.containerRuntime.waitForHealthy(row.containerId, CONTAINER_HEALTH_TIMEOUT_MS);
             if (!healthy) {
                 return false;
             }
@@ -690,26 +695,13 @@ let WorktreesService = class WorktreesService {
     async getWorktreeLogs(id, query) {
         const row = await this.requireWorktree(id);
         if (this.resolveRuntimeType(row.runtimeType) === 'process') {
-            const logPath = this.resolveProcessLogPath(this.resolveDataPath(row.repoPath, row.name));
-            const content = await (0, promises_1.readFile)(logPath, 'utf8').catch((error) => {
-                if (error?.code === 'ENOENT') {
-                    return '';
-                }
-                throw error;
-            });
-            const lines = content.split(/\r?\n/).filter((line, index, all) => {
-                if (line.length > 0) {
-                    return true;
-                }
-                return index < all.length - 1;
-            });
-            const tailed = lines.slice(-query.tail).join('\n');
-            return { logs: tailed ? `${tailed}\n` : '' };
+            const dataPath = this.resolveDataPath(row.repoPath, row.name);
+            return { logs: await this.processRuntime.readLogs(dataPath, query.tail) };
         }
         if (!row.containerId) {
             throw new common_1.BadRequestException('Worktree has no container');
         }
-        const logs = await this.dockerService.getContainerLogs(row.containerId, query.tail);
+        const logs = await this.containerRuntime.getContainerLogs(row.containerId, query.tail);
         return { logs };
     }
     async buildWorktreeOverview(row) {
@@ -794,10 +786,10 @@ let WorktreesService = class WorktreesService {
             if (!row.containerId) {
                 return;
             }
-            await this.dockerService
+            await this.containerRuntime
                 .ensureWorktreeOnComposeNetwork(row.name, row.containerId)
                 .catch(() => undefined);
-            const healthy = await this.dockerService.waitForHealthy(row.containerId, HEALTH_MONITOR_PROBE_TIMEOUT_MS);
+            const healthy = await this.containerRuntime.waitForHealthy(row.containerId, HEALTH_MONITOR_PROBE_TIMEOUT_MS);
             if (healthy) {
                 this.consecutiveHealthFailures.set(row.id, 0);
                 if (row.status === 'error') {
@@ -817,8 +809,12 @@ let WorktreesService = class WorktreesService {
         }));
     }
     async monitorProcessWorktree(row) {
-        const pid = row.processId ?? null;
-        if (!pid || !this.isProcessAlive(pid)) {
+        const verdict = await this.processRuntime.probeHealth({
+            pid: row.processId ?? null,
+            hostPort: row.containerPort ?? null,
+            runtimeToken: row.runtimeToken?.trim() || null,
+        });
+        if (verdict === 'dead' || verdict === 'token-mismatch') {
             this.consecutiveHealthFailures.set(row.id, 0);
             await this.tryUpdateStatus(row.id, 'stopped', {
                 processId: null,
@@ -829,30 +825,10 @@ let WorktreesService = class WorktreesService {
             });
             return;
         }
-        const hostPort = row.containerPort ?? null;
-        const runtimeToken = row.runtimeToken?.trim() || null;
-        if (!hostPort || !runtimeToken) {
+        if (verdict === 'unreachable') {
             await this.handleProcessProbeFailure(row.id, row.status);
             return;
         }
-        const healthy = await this.checkRuntimeReady(hostPort);
-        if (!healthy) {
-            await this.handleProcessProbeFailure(row.id, row.status);
-            return;
-        }
-        const runtimeMetadata = await this.fetchRuntimeMetadata(hostPort);
-        const runtimeTokenMatches = runtimeMetadata?.runtimeToken === runtimeToken;
-        if (!runtimeTokenMatches) {
-            this.consecutiveHealthFailures.set(row.id, 0);
-            await this.tryUpdateStatus(row.id, 'stopped', {
-                processId: null,
-                runtimeToken: null,
-                startedAt: null,
-                containerPort: null,
-                errorMessage: null,
-            });
-            return;
-        }
         this.consecutiveHealthFailures.set(row.id, 0);
         if (row.status === 'error') {
             await this.tryUpdateStatus(row.id, 'running', {
@@ -874,7 +850,7 @@ let WorktreesService = class WorktreesService {
         const candidates = rows.filter((row) => this.resolveRuntimeType(row.runtimeType) === 'process' && row.status === 'running');
         await Promise.all(candidates.map(async (row) => {
             const pid = row.processId ?? null;
-            if (!pid || !this.isProcessAlive(pid)) {
+            if (!pid || !this.processRuntime.isProcessAlive(pid)) {
                 await this.tryUpdateStatus(row.id, 'stopped', {
                     processId: null,
                     runtimeToken: null,
@@ -894,7 +870,7 @@ let WorktreesService = class WorktreesService {
                 });
                 return;
             }
-            const metadata = await this.fetchRuntimeMetadata(row.containerPort);
+            const metadata = await this.processRuntime.fetchRuntimeMetadata(row.containerPort);
             if (!metadata || metadata.runtimeToken !== row.runtimeToken) {
                 await this.tryUpdateStatus(row.id, 'stopped', {
                     processId: null,
@@ -909,217 +885,6 @@ let WorktreesService = class WorktreesService {
     resolveRuntimeType(runtimeType) {
         return runtimeType === 'process' ? 'process' : 'container';
     }
-    async startProcessRuntime(input) {
-        const runtimeToken = (0, crypto_1.randomUUID)();
-        const portFilePath = (0, path_1.join)(input.dataPath, PROCESS_RUNTIME_PORT_FILE);
-        await (0, promises_1.rm)(portFilePath, { force: true }).catch(() => undefined);
-        const processId = await this.spawnProcessRuntime({
-            worktreePath: input.worktreePath,
-            dataPath: input.dataPath,
-            projectId: input.projectId,
-            runtimeToken,
-        });
-        const portInfo = await this.waitForRuntimePortFile(portFilePath, CONTAINER_HEALTH_TIMEOUT_MS, processId);
-        if (!portInfo) {
-            await this.terminateProcess(processId).catch(() => undefined);
-            throw new Error('Process runtime did not report its port before timeout');
-        }
-        if (portInfo.runtimeToken !== runtimeToken) {
-            await this.terminateProcess(processId).catch(() => undefined);
-            throw new Error(`Runtime port file token mismatch: expected ${runtimeToken}, ` +
-                `got ${portInfo.runtimeToken ?? 'none'}`);
-        }
-        const hostPort = portInfo.port;
-        const healthy = await this.waitForRuntimeHealthy(hostPort, CONTAINER_HEALTH_TIMEOUT_MS, processId);
-        if (!healthy) {
-            await this.terminateProcess(processId).catch(() => undefined);
-            throw new Error('Process runtime did not become healthy before timeout');
-        }
-        return { processId, hostPort, runtimeToken, startedAt: new Date() };
-    }
-    async spawnProcessRuntime(input) {
-        const cliPath = this.resolveCliPath();
-        const logPath = this.resolveProcessLogPath(input.dataPath);
-        const portFilePath = (0, path_1.join)(input.dataPath, PROCESS_RUNTIME_PORT_FILE);
-        await (0, promises_1.mkdir)(input.dataPath, { recursive: true });
-        const result = await this.executor.spawnDaemon({
-            argv: [
-                process.execPath,
-                cliPath,
-                'start',
-                '--foreground',
-                '--worktree-runtime',
-                'process',
-                '--port',
-                '0',
-            ],
-            cwd: input.worktreePath,
-            logPath,
-            env: {
-                ...process.env,
-                PORT: '0',
-                HOST: '127.0.0.1',
-                NODE_ENV: 'production',
-                DB_PATH: input.dataPath,
-                DB_FILENAME: PROCESS_DB_FILE_NAME,
-                DEVCHAIN_MODE: 'normal',
-                CONTAINER_PROJECT_ID: input.projectId,
-                RUNTIME_TOKEN: input.runtimeToken,
-                RUNTIME_PORT_FILE: portFilePath,
-            },
-        });
-        return result.pid;
-    }
-    async waitForRuntimeHealthy(hostPort, timeoutMs, pid) {
-        if (timeoutMs <= 0) {
-            return false;
-        }
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            if (pid && !this.isProcessAlive(pid)) {
-                logger.warn({ pid, hostPort }, 'Child process exited during health polling');
-                return false;
-            }
-            const isReady = await this.checkRuntimeReady(hostPort);
-            if (isReady) {
-                return true;
-            }
-            await this.sleep(PROCESS_HEALTH_POLL_INTERVAL_MS);
-        }
-        return false;
-    }
-    async waitForRuntimePortFile(filePath, timeoutMs, pid) {
-        if (timeoutMs <= 0) {
-            return null;
-        }
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            if (pid && !this.isProcessAlive(pid)) {
-                logger.warn({ pid, filePath }, 'Child process exited before writing port file');
-                return null;
-            }
-            try {
-                const raw = await (0, promises_1.readFile)(filePath, 'utf-8');
-                const parsed = JSON.parse(raw);
-                if (typeof parsed.port === 'number' && parsed.port > 0) {
-                    return { port: parsed.port, runtimeToken: parsed.runtimeToken ?? null };
-                }
-            }
-            catch {
-            }
-            await this.sleep(PROCESS_HEALTH_POLL_INTERVAL_MS);
-        }
-        return null;
-    }
-    async checkRuntimeReady(hostPort) {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), PROCESS_RUNTIME_TIMEOUT_MS);
-        try {
-            const response = await fetch(`http://127.0.0.1:${hostPort}/health/ready`, {
-                signal: controller.signal,
-            });
-            return response.ok;
-        }
-        catch {
-            return false;
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-    }
-    async fetchRuntimeMetadata(hostPort) {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), PROCESS_RUNTIME_TIMEOUT_MS);
-        try {
-            const response = await fetch(`http://127.0.0.1:${hostPort}/api/runtime`, {
-                headers: { accept: 'application/json' },
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                return null;
-            }
-            return (await response.json());
-        }
-        catch {
-            return null;
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-    }
-    resolveCliPath() {
-        const candidates = [
-            (0, path_1.resolve)(process.cwd(), 'scripts', 'cli.js'),
-            (0, path_1.resolve)(__dirname, '../../../../../../../../scripts/cli.js'),
-            (0, path_1.resolve)(__dirname, '../../../../../../../scripts/cli.js'),
-            (0, path_1.resolve)(__dirname, '../../../../../cli.js'),
-        ];
-        if (process.argv[1] && !candidates.includes((0, path_1.resolve)(process.argv[1]))) {
-            candidates.push((0, path_1.resolve)(process.argv[1]));
-        }
-        for (const candidate of candidates) {
-            if ((0, fs_1.existsSync)(candidate)) {
-                return candidate;
-            }
-        }
-        throw new Error('Unable to locate CLI entry point for process runtime start. ' +
-            `Searched: ${candidates.join(', ')}`);
-    }
-    resolveProcessLogPath(dataPath) {
-        return (0, path_1.join)(dataPath, PROCESS_LOG_FILE_NAME);
-    }
-    async terminateProcess(pid) {
-        if (!pid) {
-            return;
-        }
-        const stillRunningAfterSigterm = await this.signalProcessAndAwaitExit(pid, 'SIGTERM', PROCESS_SHUTDOWN_TIMEOUT_MS);
-        if (!stillRunningAfterSigterm) {
-            return;
-        }
-        await this.signalProcessAndAwaitExit(pid, 'SIGKILL', PROCESS_KILL_TIMEOUT_MS).catch((error) => {
-            logger.warn({ error, pid }, 'Failed sending SIGKILL to worktree process');
-        });
-    }
-    async signalProcessAndAwaitExit(pid, signal, timeoutMs) {
-        const signalPid = process.platform === 'win32' ? pid : -pid;
-        try {
-            process.kill(signalPid, signal);
-        }
-        catch (error) {
-            const code = error.code;
-            if (code === 'ESRCH') {
-                return false;
-            }
-            throw error;
-        }
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            if (!this.isProcessAlive(pid)) {
-                return false;
-            }
-            await this.sleep(200);
-        }
-        return this.isProcessAlive(pid);
-    }
-    isProcessAlive(pid) {
-        try {
-            process.kill(pid, 0);
-            return true;
-        }
-        catch (error) {
-            const code = error.code;
-            if (code === 'ESRCH') {
-                return false;
-            }
-            if (code === 'EPERM') {
-                return true;
-            }
-            return false;
-        }
-    }
-    async sleep(ms) {
-        await new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
-    }
     async handleContainerEvent(event) {
         const containerId = event.id;
         if (!containerId) {
@@ -1154,6 +919,20 @@ let WorktreesService = class WorktreesService {
         }
         return row;
     }
+    withOperationGuard(worktreeId, operation, run) {
+        const inFlight = this.inFlightOperations.get(worktreeId);
+        if (inFlight) {
+            if (inFlight.operation === operation) {
+                return inFlight.promise;
+            }
+            throw new common_1.ConflictException(`Worktree is already running an in-flight "${inFlight.operation}" operation`);
+        }
+        const promise = run().finally(() => {
+            this.inFlightOperations.delete(worktreeId);
+        });
+        this.inFlightOperations.set(worktreeId, { operation, promise });
+        return promise;
+    }
     async registerProjectInContainer(hostPort, input) {
         if (!hostPort) {
             throw new Error('Container did not expose a host port');
@@ -1475,13 +1254,13 @@ exports.WorktreesService = WorktreesService;
 exports.WorktreesService = WorktreesService = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Inject)(worktrees_store_1.WORKTREES_STORE)),
-    __param(6, (0, common_1.Optional)()),
-    __param(6, (0, common_1.Inject)(storage_interface_1.STORAGE_SERVICE)),
     __param(7, (0, common_1.Optional)()),
-    __metadata("design:paramtypes", [Object, docker_service_1.OrchestratorDockerService,
+    __param(7, (0, common_1.Inject)(storage_interface_1.STORAGE_SERVICE)),
+    __metadata("design:paramtypes", [Object, container_runtime_1.ContainerRuntime,
+        process_runtime_1.ProcessRuntime,
         git_worktree_service_1.GitWorktreeService,
         seed_preparation_service_1.SeedPreparationService,
         event_emitter_1.EventEmitter2,
-        event_log_service_1.EventLogService, Object, process_executor_port_1.ProcessExecutor])
+        event_log_service_1.EventLogService, Object])
 ], WorktreesService);
 //# sourceMappingURL=worktrees.service.js.map