@jcjeon/integration-cli 0.2.0 → 0.2.1

package/apps/server/dist/modules/tasks/task-execution.service.js

@@ -0,0 +1,842 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var TaskExecutionService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskExecutionService = void 0;
+const child_process_1 = require("child_process");
+const IS_WIN = process.platform === 'win32';
+const uuid_1 = require("uuid");
+const events_1 = require("events");
+const fs = __importStar(require("fs"));
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const task_agent_entity_1 = require("../../database/entities/task-agent.entity");
+const task_agent_run_entity_1 = require("../../database/entities/task-agent-run.entity");
+const task_entity_1 = require("../../database/entities/task.entity");
+const task_run_entity_1 = require("../../database/entities/task-run.entity");
+const gemini_auth_manager_1 = require("../agents/gemini/gemini-auth.manager");
+const conversation_service_1 = require("../conversations/conversation.service");
+const conversation_enum_1 = require("../conversations/enums/conversation.enum");
+const changelog_service_1 = require("../changelog/changelog.service");
+const harness_service_1 = require("../harness/harness.service");
+let TaskExecutionService = TaskExecutionService_1 = class TaskExecutionService extends events_1.EventEmitter {
+    agentRepo;
+    agentRunRepo;
+    taskRepo;
+    runRepo;
+    geminiAuthManager;
+    conversationService;
+    gitChangelogService;
+    harnessService;
+    logger = new common_1.Logger(TaskExecutionService_1.name);
+    claudeBin = 'claude';
+    geminiBin = 'gemini';
+    codexBin = 'codex';
+    logBuffer = new Map();
+    pendingMap = new Map();
+    promptIdMap = new Map();
+    worktreeMap = new Map();
+    directorySnapshotMap = new Map();
+    resultReceivedSet = new Set();
+    runIdMap = new Map();
+    taskRunIdMap = new Map();
+    processMap = new Map();
+    stoppingAgentSet = new Set();
+    isShuttingDown = false;
+    constructor(agentRepo, agentRunRepo, taskRepo, runRepo, geminiAuthManager, conversationService, gitChangelogService, harnessService) {
+        super();
+        this.agentRepo = agentRepo;
+        this.agentRunRepo = agentRunRepo;
+        this.taskRepo = taskRepo;
+        this.runRepo = runRepo;
+        this.geminiAuthManager = geminiAuthManager;
+        this.conversationService = conversationService;
+        this.gitChangelogService = gitChangelogService;
+        this.harnessService = harnessService;
+    }
+    async onModuleInit() {
+        this.claudeBin = this.resolveClaude();
+        this.logger.log(`claude 경로: ${this.claudeBin}`);
+        this.geminiBin = this.resolveGemini();
+        this.logger.log(`gemini 경로: ${this.geminiBin}`);
+        this.codexBin = this.resolveCodex();
+        this.logger.log(`codex 경로: ${this.codexBin}`);
+        await this.recoverStuckTasks();
+    }
+    async recoverStuckTasks() {
+        const [stuckAgents, stuckTasks, stuckRuns] = await Promise.all([
+            this.agentRepo.find({ where: { status: 'running' } }),
+            this.taskRepo.find({ where: { status: 'running' } }),
+            this.runRepo.find({ where: { status: 'running' } }),
+        ]);
+        if (stuckAgents.length === 0 && stuckTasks.length === 0 && stuckRuns.length === 0)
+            return;
+        const taskIds = new Set([
+            ...stuckAgents.map((a) => a.taskId),
+            ...stuckTasks.map((t) => t.id),
+            ...stuckRuns.map((r) => r.taskId),
+        ]);
+        const now = new Date();
+        if (stuckAgents.length > 0) {
+            await this.agentRepo.update(stuckAgents.map((a) => a.id), { status: 'stopped' });
+        }
+        const stuckAgentIds = stuckAgents.map((a) => a.id);
+        if (stuckAgentIds.length > 0) {
+            const stuckAgentRuns = await this.agentRunRepo.find({
+                where: stuckAgentIds.map((id) => ({ agentId: id, status: 'running' })),
+            });
+            if (stuckAgentRuns.length > 0) {
+                await this.agentRunRepo.update(stuckAgentRuns.map((r) => r.id), { status: 'stopped' });
+            }
+        }
+        if (taskIds.size > 0) {
+            const ids = Array.from(taskIds);
+            await Promise.all([
+                this.taskRepo.update({ id: (0, typeorm_2.In)(ids), status: 'running' }, { status: 'stopped' }),
+                this.runRepo.update({ taskId: (0, typeorm_2.In)(ids), status: 'running' }, { status: 'stopped', completedAt: now }),
+            ]);
+        }
+        this.logger.warn(`서버 재시작 복구: ${stuckAgents.length}개 에이전트, ${taskIds.size}개 작업을 stopped으로 변경`);
+    }
+    onModuleDestroy() {
+        this.isShuttingDown = true;
+        for (const [key, proc] of this.processMap.entries()) {
+            this.stoppingAgentSet.add(key);
+            try {
+                proc.kill('SIGTERM');
+            }
+            catch (err) {
+                this.logger.warn(`프로세스 종료 실패 (${key}): ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        this.logBuffer.clear();
+        this.pendingMap.clear();
+        this.promptIdMap.clear();
+        this.worktreeMap.clear();
+        this.directorySnapshotMap.clear();
+        this.resultReceivedSet.clear();
+        this.runIdMap.clear();
+        this.taskRunIdMap.clear();
+        this.processMap.clear();
+        this.stoppingAgentSet.clear();
+    }
+    async spawnTask(task, supplementNote, runId, options = {}) {
+        if (!task.agents.length) {
+            throw new Error('에이전트가 없습니다. 최소 하나의 에이전트를 추가하세요.');
+        }
+        const workingDir = this.resolveWorkingDir(task.workingDir);
+        const isGitRepo = this.gitChangelogService.isGitRepo(workingDir);
+        const reqList = [...task.requirements]
+            .sort((a, b) => a.orderIndex - b.orderIndex)
+            .map((r, i) => `${i + 1}. ${r.content}`)
+            .join('\n');
+        this.logBuffer.set(task.id, new Map());
+        this.pendingMap.set(task.id, new Set(task.agents.map((a) => a.id)));
+        if (runId != null) {
+            this.taskRunIdMap.set(task.id, runId);
+        }
+        const testCodeAgentIds = new Set(options.testCodeAgentIds ?? []);
+        for (const agent of task.agents) {
+            const roleLabel = agent.role === 'other' && agent.customRole ? agent.customRole : agent.role;
+            const shouldWriteTestCode = testCodeAgentIds.has(agent.id);
+            const commonHarness = this.harnessService.findOne('common');
+            const roleHarness = this.harnessService.findOne(agent.role);
+            const harnessSection = [
+                commonHarness?.content?.trim() ? `[공통 하네스]\n${commonHarness.content.trim()}` : '',
+                roleHarness?.content?.trim() ? `[${roleLabel} 하네스]\n${roleHarness.content.trim()}` : '',
+            ].filter(Boolean).join('\n\n');
+            const prompt = [
+                harnessSection ? `${harnessSection}\n\n` : '',
+                `당신은 ${roleLabel} 역할의 AI 에이전트입니다.`,
+                `\n\n[작업 목표]\n${task.title}`,
+                reqList ? `\n\n[요구사항]\n${reqList}` : '',
+                supplementNote ? `\n\n[이전 결과 보완 사항]\n${supplementNote}` : '',
+                shouldWriteTestCode
+                    ? '\n\n[테스트 코드 작성 지시]\n이번 실행에서는 구현 변경뿐 아니라 관련 테스트 코드를 반드시 작성하세요. 프로젝트의 기존 테스트 프레임워크, 파일 위치, 네이밍 패턴을 따르고 가능한 경우 테스트를 실행해 결과를 남기세요.'
+                    : '',
+                `\n\n위 작업을 수행해주세요.`,
+            ].join('');
+            await this.agentRepo.update(agent.id, { status: 'running' });
+            this.initAgentBuffer(task.id, agent.id);
+            if (runId != null) {
+                this.runIdMap.set(`${task.id}-${agent.id}`, runId);
+                const agentRun = this.agentRunRepo.create({
+                    runId,
+                    agentId: agent.id,
+                    status: 'running',
+                });
+                const savedAgentRun = await this.agentRunRepo.save(agentRun);
+                this.runIdMap.set(`agentRunId-${task.id}-${agent.id}`, savedAgentRun.id);
+            }
+            const promptId = (0, uuid_1.v4)();
+            this.promptIdMap.set(`${task.id}-${agent.id}`, promptId);
+            await this.conversationService.create({
+                sessionId: task.id,
+                promptId,
+                content: prompt,
+                agentModel: this.getAgentModel(agent.agentType),
+                type: conversation_enum_1.ConversationType.USER_MESSAGE,
+                agentId: agent.id,
+                runId: runId ?? null,
+            });
+            let agentWorkDir = workingDir;
+            const agentKey = this.getAgentKey(task.id, agent.id);
+            this.directorySnapshotMap.set(agentKey, {
+                workingDir,
+                snapshot: this.gitChangelogService.createDirectorySnapshot(workingDir),
+            });
+            if (isGitRepo) {
+                try {
+                    const { worktreePath, branchName, agentWorkDir: worktreeAgentDir } = this.gitChangelogService.createWorktree(workingDir, agent.agentType);
+                    const startCommitHash = this.gitChangelogService.getCurrentHead(workingDir);
+                    await this.agentRepo.update(agent.id, { worktreePath, startCommitHash });
+                    if (runId != null) {
+                        const agentRunId = this.runIdMap.get(`agentRunId-${task.id}-${agent.id}`);
+                        if (agentRunId != null) {
+                            await this.agentRunRepo.update(agentRunId, { worktreePath, startCommitHash });
+                        }
+                    }
+                    this.worktreeMap.set(agentKey, { worktreePath, branchName, mainRepoDir: workingDir });
+                    agentWorkDir = worktreeAgentDir;
+                }
+                catch (err) {
+                    this.logger.warn(`Agent ${agent.id} worktree 생성 실패, 원본 디렉토리 사용: ${err}`);
+                }
+            }
+            if (agent.agentType === 'gemini') {
+                this.spawnGeminiAgent(task.id, task.title, agent.id, agentWorkDir, prompt);
+            }
+            else if (agent.agentType === 'codex') {
+                this.spawnCodexAgent(task.id, task.title, agent.id, agentWorkDir, prompt);
+            }
+            else {
+                this.spawnClaudeAgent(task.id, task.title, agent.id, agentWorkDir, prompt);
+            }
+        }
+        await this.taskRepo.update(task.id, { status: 'running' });
+        this.emit('task:status', { taskId: task.id, status: 'running', title: task.title });
+    }
+    async stopTask(task) {
+        const pending = this.pendingMap.get(task.id);
+        if (pending) {
+            pending.clear();
+            this.pendingMap.delete(task.id);
+        }
+        for (const agent of task.agents) {
+            const isRunning = agent.status === 'running' || this.processMap.has(this.getAgentKey(task.id, agent.id));
+            if (isRunning) {
+                this.requestAgentStop(task.id, agent.id);
+                await this.agentRepo.update(agent.id, { status: 'stopped' });
+                this.updateAgentBuffer(task.id, agent.id, { status: 'stopped' });
+                await this.updateAgentRunStatus(task.id, agent.id, 'stopped');
+                const ev = { taskId: task.id, agentId: agent.id, message: '수동으로 중지됐습니다.' };
+                this.emit('agent:error', ev);
+            }
+        }
+        await this.taskRepo.update(task.id, { status: 'stopped' });
+        const taskRunId = this.taskRunIdMap.get(task.id);
+        if (taskRunId != null) {
+            await this.runRepo.update(taskRunId, { status: 'stopped', completedAt: new Date() });
+            this.taskRunIdMap.delete(task.id);
+        }
+        this.emit('task:status', { taskId: task.id, status: 'stopped', title: task.title });
+    }
+    getBufferedLogs(taskId) {
+        const agentMap = this.logBuffer.get(taskId);
+        if (!agentMap)
+            return [];
+        return Array.from(agentMap.values());
+    }
+    spawnClaudeAgent(taskId, taskTitle, agentId, workingDir, prompt) {
+        const args = [
+            '--output-format', 'stream-json',
+            '--verbose',
+            '--print',
+            '--dangerously-skip-permissions',
+            '-p', prompt,
+        ];
+        this.logger.log(`[Task:${taskTitle}] Claude Agent ${agentId} 실행 — cwd: ${workingDir}`);
+        const proc = (0, child_process_1.spawn)(this.claudeBin, args, {
+            cwd: workingDir,
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        this.registerProcess(taskId, agentId, proc);
+        let buffer = '';
+        proc.stdout.on('data', (chunk) => {
+            if (this.isAgentStopping(taskId, agentId))
+                return;
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed)
+                    this.handleClaudeLine(taskId, agentId, trimmed);
+            }
+        });
+        proc.stderr.on('data', (chunk) => {
+            if (this.isAgentStopping(taskId, agentId))
+                return;
+            this.logger.warn(`[Task:${taskId}] Claude Agent ${agentId} stderr: ${chunk.toString().slice(0, 200)}`);
+        });
+        proc.on('close', (exitCode) => {
+            if (this.isAgentStopping(taskId, agentId)) {
+                this.cleanupAgentRuntime(taskId, agentId);
+                return;
+            }
+            if (buffer.trim())
+                this.handleClaudeLine(taskId, agentId, buffer.trim());
+            const key = `${taskId}-${agentId}`;
+            const hadResult = this.resultReceivedSet.delete(key);
+            if (!hadResult) {
+                this.logger.warn(`[Task:${taskId}] Claude Agent ${agentId} exited (code: ${exitCode}) without result`);
+                void this.agentRepo.update(agentId, { status: 'error' });
+                this.updateAgentBuffer(taskId, agentId, { status: 'error', errorMessage: `종료 코드: ${exitCode}` });
+                void this.updateAgentRunStatus(taskId, agentId, 'error');
+                this.emit('agent:error', { taskId, agentId, message: `프로세스가 코드 ${exitCode}로 종료됐습니다.` });
+            }
+            void this.finalizeAgent(taskId, agentId);
+        });
+        proc.on('error', (err) => {
+            if (this.isAgentStopping(taskId, agentId))
+                return;
+            this.logger.error(`[Task:${taskId}] Claude Agent ${agentId} spawn error: ${err.message}`);
+            this.resultReceivedSet.delete(`${taskId}-${agentId}`);
+            void this.agentRepo.update(agentId, { status: 'error' });
+            this.updateAgentBuffer(taskId, agentId, { status: 'error', errorMessage: err.message });
+            void this.updateAgentRunStatus(taskId, agentId, 'error');
+            this.emit('agent:error', { taskId, agentId, message: err.message });
+            void this.finalizeAgent(taskId, agentId);
+        });
+    }
+    spawnCodexAgent(taskId, taskTitle, agentId, workingDir, prompt) {
+        this.logger.log(`[Task:${taskTitle}] Codex Agent ${agentId} 실행 — cwd: ${workingDir}`);
+        const codexArgs = ['exec', '-c', 'approval_policy=never', '-c', 'sandbox_mode=danger-full-access', prompt];
+        const [codexCmd, codexSpawnArgs] = IS_WIN
+            ? ['cmd.exe', ['/c', 'codex', ...codexArgs]]
+            : [this.codexBin, codexArgs];
+        const proc = (0, child_process_1.spawn)(codexCmd, codexSpawnArgs, {
+            cwd: workingDir,
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        this.registerProcess(taskId, agentId, proc);
+        let output = '';
+        const handleChunk = (chunk) => {
+            if (this.isAgentStopping(taskId, agentId))
+                return;
+            const raw = chunk.toString();
+            const text = raw
+                .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '')
+                .replace(/\x1b\][^\x07]*\x07/g, '')
+                .replace(/\r/g, '');
+            if (!text.trim())
+                return;
+            output += text;
+            const prev = this.getAgentBuffer(taskId, agentId);
+            this.updateAgentBuffer(taskId, agentId, { output: prev.output + text });
+            this.emit('agent:output', { taskId, agentId, text });
+        };
+        proc.stdout.on('data', handleChunk);
+        proc.stderr.on('data', handleChunk);
+        proc.on('close', (exitCode) => {
+            if (this.isAgentStopping(taskId, agentId)) {
+                this.cleanupAgentRuntime(taskId, agentId);
+                return;
+            }
+            const isError = (exitCode ?? 0) !== 0;
+            const status = isError ? 'error' : 'completed';
+            void this.agentRepo.update(agentId, { status });
+            this.updateAgentBuffer(taskId, agentId, { status });
+            void this.updateAgentRunStatus(taskId, agentId, status, 0, 0);
+            if (isError) {
+                this.updateAgentBuffer(taskId, agentId, { errorMessage: `종료 코드: ${exitCode}` });
+            }
+            this.emit('agent:done', {
+                taskId,
+                agentId,
+                result: output.trim(),
+                isError,
+                durationMs: 0,
+                costUsd: 0,
+            });
+            void this.finalizeAgent(taskId, agentId);
+        });
+        proc.on('error', (err) => {
+            if (this.isAgentStopping(taskId, agentId))
+                return;
+            this.logger.error(`[Task:${taskId}] Codex Agent ${agentId} spawn error: ${err.message}`);
+            void this.agentRepo.update(agentId, { status: 'error' });
+            this.updateAgentBuffer(taskId, agentId, { status: 'error', errorMessage: err.message });
+            void this.updateAgentRunStatus(taskId, agentId, 'error');
+            this.emit('agent:error', { taskId, agentId, message: err.message });
+            void this.finalizeAgent(taskId, agentId);
+        });
+    }
+    spawnGeminiAgent(taskId, taskTitle, agentId, workingDir, prompt) {
+        this.logger.log(`[Task:${taskTitle}] Gemini Agent ${agentId} 실행 — bin: ${this.geminiBin}, cwd: ${workingDir}`);
+        const proc = (0, child_process_1.spawn)(this.geminiBin, ['-y', '-p', prompt], {
+            cwd: workingDir,
+            env: this.geminiAuthManager.getEnvForGemini(),
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        this.registerProcess(taskId, agentId, proc);
+        let output = '';
+        const handleChunk = (chunk) => {
+            if (this.isAgentStopping(taskId, agentId))
+                return;
+            const raw = chunk.toString();
+            const text = raw
+                .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '')
+                .replace(/\x1b\][^\x07]*\x07/g, '')
+                .replace(/\r/g, '');
+            if (!text.trim())
+                return;
+            output += text;
+            const prev = this.getAgentBuffer(taskId, agentId);
+            this.updateAgentBuffer(taskId, agentId, { output: prev.output + text });
+            this.emit('agent:output', { taskId, agentId, text });
+        };
+        proc.stdout.on('data', handleChunk);
+        proc.stderr.on('data', handleChunk);
+        proc.on('close', (exitCode) => {
+            if (this.isAgentStopping(taskId, agentId)) {
+                this.cleanupAgentRuntime(taskId, agentId);
+                return;
+            }
+            const isError = (exitCode ?? 0) !== 0;
+            const status = isError ? 'error' : 'completed';
+            void this.agentRepo.update(agentId, { status });
+            this.updateAgentBuffer(taskId, agentId, { status });
+            void this.updateAgentRunStatus(taskId, agentId, status, 0, 0);
+            if (isError) {
+                this.updateAgentBuffer(taskId, agentId, { errorMessage: `종료 코드: ${exitCode}` });
+            }
+            this.emit('agent:done', {
+                taskId,
+                agentId,
+                result: output.trim(),
+                isError,
+                durationMs: 0,
+                costUsd: 0,
+            });
+            void this.finalizeAgent(taskId, agentId);
+        });
+        proc.on('error', (err) => {
+            if (this.isAgentStopping(taskId, agentId))
+                return;
+            this.logger.error(`[Task:${taskId}] Gemini Agent ${agentId} spawn error: ${err.message}`);
+            void this.agentRepo.update(agentId, { status: 'error' });
+            this.updateAgentBuffer(taskId, agentId, { status: 'error', errorMessage: err.message });
+            void this.updateAgentRunStatus(taskId, agentId, 'error');
+            this.emit('agent:error', { taskId, agentId, message: err.message });
+            void this.finalizeAgent(taskId, agentId);
+        });
+    }
+    handleClaudeLine(taskId, agentId, line) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        switch (event.type) {
+            case 'assistant': {
+                const e = event;
+                for (const block of e.message.content) {
+                    if (block.type === 'text' && block.text.trim()) {
+                        const prev = this.getAgentBuffer(taskId, agentId);
+                        this.updateAgentBuffer(taskId, agentId, { output: prev.output + block.text });
+                        this.emit('agent:output', { taskId, agentId, text: block.text });
+                    }
+                    if (block.type === 'tool_use') {
+                        const toolLine = `\n⚙ ${block.name}(${JSON.stringify(block.input).slice(0, 120)})\n`;
+                        const prev = this.getAgentBuffer(taskId, agentId);
+                        this.updateAgentBuffer(taskId, agentId, { output: prev.output + toolLine });
+                        this.emit('agent:tool', { taskId, agentId, tool: block.name, input: block.input });
+                    }
+                }
+                break;
+            }
+            case 'result': {
+                const e = event;
+                const status = e.is_error ? 'error' : 'completed';
+                this.resultReceivedSet.add(`${taskId}-${agentId}`);
+                void this.agentRepo.update(agentId, { status });
+                this.updateAgentBuffer(taskId, agentId, {
+                    status,
+                    durationMs: e.duration_ms,
+                    costUsd: e.total_cost_usd,
+                });
+                void this.updateAgentRunStatus(taskId, agentId, status, e.duration_ms, e.total_cost_usd);
+                this.emit('agent:done', {
+                    taskId,
+                    agentId,
+                    result: e.result,
+                    isError: e.is_error,
+                    durationMs: e.duration_ms,
+                    costUsd: e.total_cost_usd,
+                });
+                break;
+            }
+        }
+    }
+    async finalizeAgent(taskId, agentId) {
+        try {
+            const worktreeKey = this.getAgentKey(taskId, agentId);
+            const worktreeInfo = this.worktreeMap.get(worktreeKey);
+            const directorySnapshotInfo = this.directorySnapshotMap.get(worktreeKey);
+            this.worktreeMap.delete(worktreeKey);
+            this.directorySnapshotMap.delete(worktreeKey);
+            if (worktreeInfo) {
+                const { worktreePath } = worktreeInfo;
+                const [agent, task] = await Promise.all([
+                    this.agentRepo.findOne({ where: { id: agentId } }),
+                    this.taskRepo.findOne({ where: { id: taskId } }),
+                ]);
+                if (agent?.startCommitHash) {
+                    const roleLabel = agent.role === 'other' && agent.customRole
+                        ? agent.customRole
+                        : agent.role;
+                    const commitMessage = `feat(${agent.agentType}/${roleLabel}): ${task?.title ?? taskId}`;
+                    const runId = this.runIdMap.get(`${taskId}-${agentId}`);
+                    await this.gitChangelogService.captureAndSave(taskId, agentId, worktreePath, agent.startCommitHash, commitMessage, runId);
+                }
+            }
+            if (directorySnapshotInfo) {
+                const runId = this.runIdMap.get(`${taskId}-${agentId}`);
+                await this.gitChangelogService.captureDirectoryAndSave(taskId, agentId, directorySnapshotInfo.workingDir, directorySnapshotInfo.snapshot, runId);
+            }
+            await this.checkTaskCompletion(taskId, agentId);
+        }
+        finally {
+            this.cleanupAgentRuntime(taskId, agentId);
+        }
+    }
+    async checkTaskCompletion(taskId, agentId) {
+        const pending = this.pendingMap.get(taskId);
+        if (!pending)
+            return;
+        pending.delete(agentId);
+        await this.saveAgentMessage(taskId, agentId);
+        if (pending.size > 0)
+            return;
+        this.pendingMap.delete(taskId);
+        const [agents, taskEntity] = await Promise.all([
+            this.agentRepo.find({ where: { taskId } }),
+            this.taskRepo.findOne({ where: { id: taskId } }),
+        ]);
+        const hasError = agents.some((a) => a.status === 'error');
+        const newStatus = hasError ? 'error' : 'completed';
+        await this.taskRepo.update(taskId, { status: newStatus });
+        const taskRunId = this.taskRunIdMap.get(taskId);
+        if (taskRunId != null) {
+            await this.runRepo.update(taskRunId, { status: newStatus, completedAt: new Date() });
+            this.taskRunIdMap.delete(taskId);
+        }
+        this.emit('task:status', { taskId, status: newStatus, title: taskEntity?.title });
+        this.logger.log(`Task ${taskId} → ${newStatus}`);
+    }
+    async saveAgentMessage(taskId, agentId) {
+        const promptId = this.promptIdMap.get(`${taskId}-${agentId}`);
+        if (!promptId)
+            return;
+        this.promptIdMap.delete(`${taskId}-${agentId}`);
+        const buf = this.getAgentBuffer(taskId, agentId);
+        if (!buf.output.trim())
+            return;
+        const agent = await this.agentRepo.findOne({ where: { id: agentId } });
+        const agentModel = this.getAgentModel(agent?.agentType ?? 'claude');
+        const runId = this.runIdMap.get(`${taskId}-${agentId}`);
+        try {
+            await this.conversationService.create({
+                sessionId: taskId,
+                promptId,
+                content: buf.output.trim(),
+                agentModel,
+                type: conversation_enum_1.ConversationType.AGENT_MESSAGE,
+                agentId,
+                runId: runId ?? null,
+            });
+        }
+        catch (err) {
+            this.logger.error(`Agent ${agentId} 메시지 저장 실패: ${err}`);
+        }
+    }
+    async getLogsFromDb(taskId) {
+        const agents = await this.agentRepo.find({ where: { taskId } });
+        if (!agents.length)
+            return [];
+        const latestRun = await this.agentRunRepo.findOne({
+            where: { agentId: agents[0].id },
+            order: { runId: 'DESC' },
+        });
+        let conversations;
+        if (latestRun?.runId != null) {
+            conversations = await this.conversationService.findByRun(latestRun.runId);
+        }
+        else {
+            conversations = await this.conversationService.findBySession(taskId);
+        }
+        const statusMap = new Map(agents.map((a) => [a.id, a.status]));
+        const agentMessages = conversations.filter((c) => c.type === conversation_enum_1.ConversationType.AGENT_MESSAGE && c.agentId != null);
+        const byAgent = new Map();
+        for (const msg of agentMessages) {
+            const id = Number(msg.agentId);
+            byAgent.set(id, (byAgent.get(id) ?? '') + msg.content);
+        }
+        return agents.map((agent) => ({
+            agentId: agent.id,
+            status: statusMap.get(agent.id) ?? 'stopped',
+            output: byAgent.get(agent.id) ?? '',
+        }));
+    }
+    async updateAgentRunStatus(taskId, agentId, status, durationMs, costUsd) {
+        const agentRunId = this.runIdMap.get(`agentRunId-${taskId}-${agentId}`);
+        if (agentRunId == null)
+            return;
+        await this.agentRunRepo.update(agentRunId, {
+            status,
+            ...(durationMs != null ? { durationMs } : {}),
+            ...(costUsd != null ? { costUsd } : {}),
+        });
+    }
+    initAgentBuffer(taskId, agentId) {
+        if (!this.logBuffer.has(taskId))
+            this.logBuffer.set(taskId, new Map());
+        this.logBuffer.get(taskId).set(agentId, { agentId, status: 'running', output: '' });
+    }
+    getAgentBuffer(taskId, agentId) {
+        return this.logBuffer.get(taskId)?.get(agentId) ?? { agentId, status: 'running', output: '' };
+    }
+    updateAgentBuffer(taskId, agentId, patch) {
+        const agentMap = this.logBuffer.get(taskId);
+        if (!agentMap)
+            return;
+        const cur = agentMap.get(agentId) ?? { agentId, status: 'running', output: '' };
+        agentMap.set(agentId, { ...cur, ...patch });
+    }
+    getAgentKey(taskId, agentId) {
+        return `${taskId}-${agentId}`;
+    }
+    getAgentModel(agentType) {
+        if (agentType === 'gemini')
+            return conversation_enum_1.AgentModel.GEMINI;
+        if (agentType === 'codex')
+            return conversation_enum_1.AgentModel.CODEX;
+        if (agentType === 'opencode')
+            return conversation_enum_1.AgentModel.OPENCODE;
+        return conversation_enum_1.AgentModel.CLAUDE;
+    }
+    registerProcess(taskId, agentId, proc) {
+        this.processMap.set(this.getAgentKey(taskId, agentId), proc);
+    }
+    isAgentStopping(taskId, agentId) {
+        return this.isShuttingDown || this.stoppingAgentSet.has(this.getAgentKey(taskId, agentId));
+    }
+    requestAgentStop(taskId, agentId) {
+        const key = this.getAgentKey(taskId, agentId);
+        const proc = this.processMap.get(key);
+        if (!proc)
+            return;
+        this.stoppingAgentSet.add(key);
+        try {
+            proc.kill('SIGTERM');
+            const forceKill = setTimeout(() => {
+                if (!this.processMap.has(key))
+                    return;
+                try {
+                    proc.kill('SIGKILL');
+                }
+                catch (err) {
+                    this.logger.warn(`프로세스 강제 종료 실패 (${key}): ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }, 5000);
+            forceKill.unref?.();
+        }
+        catch (err) {
+            this.logger.warn(`프로세스 종료 실패 (${key}): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    cleanupAgentRuntime(taskId, agentId) {
+        const key = this.getAgentKey(taskId, agentId);
+        this.processMap.delete(key);
+        this.stoppingAgentSet.delete(key);
+        this.resultReceivedSet.delete(key);
+        this.promptIdMap.delete(key);
+        this.worktreeMap.delete(key);
+        this.directorySnapshotMap.delete(key);
+        this.runIdMap.delete(key);
+        this.runIdMap.delete(`agentRunId-${key}`);
+    }
+    resolveClaude() {
+        const candidates = [
+            () => (0, child_process_1.execSync)('which claude', { encoding: 'utf8', timeout: 2000 }).trim(),
+            () => {
+                const home = process.env.HOME ?? '';
+                const nvmDefault = `${home}/.nvm/versions/node/${process.version}/bin/claude`;
+                if (fs.existsSync(nvmDefault))
+                    return nvmDefault;
+                throw new Error('not found');
+            },
+            () => {
+                const npmBin = (0, child_process_1.execSync)('npm bin -g', { encoding: 'utf8', timeout: 2000 }).trim();
+                const p = `${npmBin}/claude`;
+                if (fs.existsSync(p))
+                    return p;
+                throw new Error('not found');
+            },
+        ];
+        for (const fn of candidates) {
+            try {
+                const p = fn();
+                if (p)
+                    return p;
+            }
+            catch { }
+        }
+        this.logger.warn('claude 바이너리 경로를 자동 탐지하지 못했습니다. "claude"로 폴백합니다.');
+        return 'claude';
+    }
+    resolveGemini() {
+        const candidates = [
+            () => (0, child_process_1.execSync)('which gemini', { encoding: 'utf8', timeout: 2000 }).trim(),
+            () => {
+                const home = process.env.HOME ?? '';
+                const nvmDefault = `${home}/.nvm/versions/node/${process.version}/bin/gemini`;
+                if (fs.existsSync(nvmDefault))
+                    return nvmDefault;
+                throw new Error('not found');
+            },
+            () => {
+                const npmBin = (0, child_process_1.execSync)('npm bin -g', { encoding: 'utf8', timeout: 2000 }).trim();
+                const p = `${npmBin}/gemini`;
+                if (fs.existsSync(p))
+                    return p;
+                throw new Error('not found');
+            },
+        ];
+        for (const fn of candidates) {
+            try {
+                const p = fn();
+                if (p)
+                    return p;
+            }
+            catch { }
+        }
+        this.logger.warn('gemini 바이너리 경로를 자동 탐지하지 못했습니다. "gemini"로 폴백합니다.');
+        return 'gemini';
+    }
+    resolveCodex() {
+        const candidates = [
+            () => (0, child_process_1.execSync)('which codex', { encoding: 'utf8', timeout: 2000 }).trim(),
+            () => {
+                const home = process.env.HOME ?? '';
+                const nvmDefault = `${home}/.nvm/versions/node/${process.version}/bin/codex`;
+                if (fs.existsSync(nvmDefault))
+                    return nvmDefault;
+                throw new Error('not found');
+            },
+            () => {
+                const npmBin = (0, child_process_1.execSync)('npm bin -g', { encoding: 'utf8', timeout: 2000 }).trim();
+                const p = `${npmBin}/codex`;
+                if (fs.existsSync(p))
+                    return p;
+                throw new Error('not found');
+            },
+        ];
+        for (const fn of candidates) {
+            try {
+                const p = fn();
+                if (p)
+                    return p;
+            }
+            catch { }
+        }
+        this.logger.warn('codex 바이너리 경로를 자동 탐지하지 못했습니다. "codex"로 폴백합니다.');
+        return 'codex';
+    }
+    resolveWorkingDir(workingDir) {
+        try {
+            if (!workingDir) {
+                return process.cwd();
+            }
+            if (!fs.existsSync(workingDir)) {
+                throw new common_1.BadRequestException(`작업 디렉토리가 존재하지 않습니다: ${workingDir}`);
+            }
+            if (!fs.statSync(workingDir).isDirectory()) {
+                throw new common_1.BadRequestException(`작업 디렉토리가 폴더가 아닙니다: ${workingDir}`);
+            }
+            return workingDir;
+        }
+        catch (err) {
+            if (err instanceof common_1.BadRequestException)
+                throw err;
+            throw new common_1.BadRequestException(`작업 디렉토리를 확인할 수 없습니다: ${workingDir}`);
+        }
+    }
+};
+exports.TaskExecutionService = TaskExecutionService;
+exports.TaskExecutionService = TaskExecutionService = TaskExecutionService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(task_agent_entity_1.TaskAgentEntity)),
+    __param(1, (0, typeorm_1.InjectRepository)(task_agent_run_entity_1.TaskAgentRunEntity)),
+    __param(2, (0, typeorm_1.InjectRepository)(task_entity_1.TaskEntity)),
+    __param(3, (0, typeorm_1.InjectRepository)(task_run_entity_1.TaskRunEntity)),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        gemini_auth_manager_1.GeminiAuthManager,
+        conversation_service_1.ConversationService,
+        changelog_service_1.GitChangelogService,
+        harness_service_1.HarnessService])
+], TaskExecutionService);
+//# sourceMappingURL=task-execution.service.js.map