@jcjeon/integration-cli 0.2.0

package/apps/server/src/modules/tasks/task.gateway.ts

@@ -0,0 +1,140 @@
+import { Logger } from '@nestjs/common';
+import {
+  ConnectedSocket,
+  MessageBody,
+  OnGatewayConnection,
+  OnGatewayDisconnect,
+  OnGatewayInit,
+  SubscribeMessage,
+  WebSocketGateway,
+  WebSocketServer,
+} from '@nestjs/websockets';
+import { Server, Socket } from 'socket.io';
+
+import { TaskExecutionService } from './task-execution.service';
+import type {
+  AgentDoneEvent,
+  AgentErrorEvent,
+  AgentOutputEvent,
+  AgentToolEvent,
+  TaskStatusEvent,
+} from './task-execution.service';
+
+/**
+ * WebSocket 프로토콜 (/tasks 네임스페이스)
+ *
+ * Client → Server
+ *   task:subscribe    { taskId }  특정 태스크 룸 구독 (에이전트 출력 수신)
+ *   task:unsubscribe  { taskId }  특정 태스크 룸 구독 해제
+ *   task:get-logs     { taskId }  버퍼된 로그 요청 (늦은 구독자)
+ *   task:watch-all              전역 알림 룸 구독 (모든 task:status 수신)
+ *   task:unwatch-all            전역 알림 룸 구독 해제
+ *
+ * Server → Client
+ *   agent:output        { taskId, agentId, text }
+ *   agent:tool          { taskId, agentId, tool, input }
+ *   agent:done          { taskId, agentId, result, isError, durationMs, costUsd }
+ *   agent:error         { taskId, agentId, message }
+ *   task:status         { taskId, status, title? }  — 특정 룸 + 전역 알림 룸
+ *   task:buffered-logs  { taskId, logs }
+ */
+
+const NOTIFICATIONS_ROOM = 'task:notifications';
+
+@WebSocketGateway({ namespace: '/tasks', cors: { origin: '*' } })
+export class TaskGateway implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect {
+  @WebSocketServer()
+  private readonly server!: Server;
+
+  private readonly logger = new Logger(TaskGateway.name);
+
+  constructor(private readonly executionService: TaskExecutionService) {}
+
+  afterInit(): void {
+    this.executionService.on('agent:output', (e: AgentOutputEvent) => {
+      this.server.to(`task:${e.taskId}`).emit('agent:output', e);
+    });
+
+    this.executionService.on('agent:tool', (e: AgentToolEvent) => {
+      this.server.to(`task:${e.taskId}`).emit('agent:tool', e);
+    });
+
+    this.executionService.on('agent:done', (e: AgentDoneEvent) => {
+      this.server.to(`task:${e.taskId}`).emit('agent:done', e);
+    });
+
+    this.executionService.on('agent:error', (e: AgentErrorEvent) => {
+      this.server.to(`task:${e.taskId}`).emit('agent:error', e);
+    });
+
+    this.executionService.on('task:status', (e: TaskStatusEvent) => {
+      // 1. 특정 태스크 룸 (에이전트 출력 패널용)
+      this.server.to(`task:${e.taskId}`).emit('task:status', e);
+      // 2. 전역 알림 룸 (useTaskNotification 구독자 전체)
+      this.server.to(NOTIFICATIONS_ROOM).emit('task:status', e);
+    });
+
+    this.logger.log('TaskGateway initialised — namespace: /tasks');
+  }
+
+  handleConnection(client: Socket): void {
+    this.logger.debug(`Client connected: ${client.id}`);
+  }
+
+  handleDisconnect(client: Socket): void {
+    this.logger.debug(`Client disconnected: ${client.id}`);
+  }
+
+  // ─── 특정 태스크 구독 ─────────────────────────────────────────────────────
+
+  @SubscribeMessage('task:subscribe')
+  handleSubscribe(
+    @ConnectedSocket() client: Socket,
+    @MessageBody('taskId') taskId: string,
+  ): void {
+    void client.join(`task:${taskId}`);
+    this.logger.debug(`${client.id} subscribed to task:${taskId}`);
+  }
+
+  @SubscribeMessage('task:unsubscribe')
+  handleUnsubscribe(
+    @ConnectedSocket() client: Socket,
+    @MessageBody('taskId') taskId: string,
+  ): void {
+    void client.leave(`task:${taskId}`);
+  }
+
+  /** 늦은 구독자용 — 버퍼 우선, 없으면 DB에서 복원 */
+  @SubscribeMessage('task:get-logs')
+  handleGetLogs(
+    @ConnectedSocket() client: Socket,
+    @MessageBody('taskId') taskId: string,
+  ): void {
+    const buffered = this.executionService.getBufferedLogs(taskId);
+
+    if (buffered.length > 0) {
+      client.emit('task:buffered-logs', { taskId, logs: buffered });
+      return;
+    }
+
+    // 서버 재시작 후 버퍼 소실 — DB에서 복원
+    void this.executionService.getLogsFromDb(taskId).then((logs) => {
+      client.emit('task:buffered-logs', { taskId, logs });
+    });
+  }
+
+  // ─── 전역 알림 룸 ─────────────────────────────────────────────────────────
+
+  /** 모든 task:status 이벤트를 받는 전역 알림 룸 가입 */
+  @SubscribeMessage('task:watch-all')
+  handleWatchAll(@ConnectedSocket() client: Socket): void {
+    void client.join(NOTIFICATIONS_ROOM);
+    this.logger.debug(`${client.id} joined notifications room`);
+  }
+
+  /** 전역 알림 룸 탈퇴 */
+  @SubscribeMessage('task:unwatch-all')
+  handleUnwatchAll(@ConnectedSocket() client: Socket): void {
+    void client.leave(NOTIFICATIONS_ROOM);
+  }
+}

package/apps/server/src/modules/tasks/tasks.controller.spec.ts

@@ -0,0 +1,210 @@
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { TasksController } from './tasks.controller';
+import { TasksService } from './tasks.service';
+import type { TaskEntity } from '../../database/entities/task.entity';
+import type { TaskRunEntity } from '../../database/entities/task-run.entity';
+
+const mockTask: TaskEntity = {
+  id: 'task-1',
+  title: 'Test Task',
+  status: 'pending',
+  workingDir: '/tmp/project',
+  claudeSessionId: null,
+  archived: false,
+  createdAt: new Date('2024-01-01'),
+  updatedAt: new Date('2024-01-01'),
+  requirements: [],
+  agents: [],
+};
+
+describe('TasksController', () => {
+  let controller: TasksController;
+  let service: jest.Mocked<TasksService>;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [TasksController],
+      providers: [
+        {
+          provide: TasksService,
+          useValue: {
+            create: jest.fn(),
+            findAll: jest.fn(),
+            findOne: jest.fn(),
+            update: jest.fn(),
+            execute: jest.fn(),
+            stop: jest.fn(),
+            rerun: jest.fn(),
+            rerunAgent: jest.fn(),
+            getRuns: jest.fn(),
+            archive: jest.fn(),
+            mergeAgentAll: jest.fn(),
+            mergeAgentFile: jest.fn(),
+            remove: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    controller = module.get(TasksController);
+    service = module.get(TasksService) as jest.Mocked<TasksService>;
+  });
+
+  afterEach(() => jest.clearAllMocks());
+
+  describe('create', () => {
+    it('service.create를 호출하고 결과를 반환한다', async () => {
+      service.create.mockResolvedValue(mockTask);
+
+      const result = await controller.create({ title: 'Test Task' });
+
+      expect(service.create).toHaveBeenCalledWith({ title: 'Test Task' });
+      expect(result).toBe(mockTask);
+    });
+  });
+
+  describe('findAll', () => {
+    it('service.findAll를 호출하고 task 목록을 반환한다', async () => {
+      service.findAll.mockResolvedValue([mockTask]);
+
+      const result = await controller.findAll();
+
+      expect(service.findAll).toHaveBeenCalled();
+      expect(result).toEqual([mockTask]);
+    });
+  });
+
+  describe('findOne', () => {
+    it('service.findOne를 id와 함께 호출한다', async () => {
+      service.findOne.mockResolvedValue(mockTask);
+
+      const result = await controller.findOne('task-1');
+
+      expect(service.findOne).toHaveBeenCalledWith('task-1');
+      expect(result).toBe(mockTask);
+    });
+  });
+
+  describe('update', () => {
+    it('service.update를 id와 dto와 함께 호출한다', async () => {
+      const updated = { ...mockTask, title: 'Updated' };
+      service.update.mockResolvedValue(updated);
+
+      const result = await controller.update('task-1', { title: 'Updated' });
+
+      expect(service.update).toHaveBeenCalledWith('task-1', { title: 'Updated' });
+      expect(result).toBe(updated);
+    });
+  });
+
+  describe('execute', () => {
+    it('service.execute를 호출한다', async () => {
+      const running = { ...mockTask, status: 'running' };
+      service.execute.mockResolvedValue(running);
+
+      const result = await controller.execute('task-1', { agentTestCodePreferences: [{ agentId: 1, writeTestCode: true }] });
+
+      expect(service.execute).toHaveBeenCalledWith('task-1', [{ agentId: 1, writeTestCode: true }]);
+      expect(result).toBe(running);
+    });
+  });
+
+  describe('stop', () => {
+    it('service.stop를 호출한다', async () => {
+      const stopped = { ...mockTask, status: 'stopped' };
+      service.stop.mockResolvedValue(stopped);
+
+      const result = await controller.stop('task-1');
+
+      expect(service.stop).toHaveBeenCalledWith('task-1');
+      expect(result).toBe(stopped);
+    });
+  });
+
+  describe('rerun', () => {
+    it('service.rerun을 supplementNote와 함께 호출한다', async () => {
+      service.rerun.mockResolvedValue(mockTask);
+
+      const result = await controller.rerun('task-1', { supplementNote: '보완 작업' });
+
+      expect(service.rerun).toHaveBeenCalledWith('task-1', '보완 작업', undefined);
+      expect(result).toBe(mockTask);
+    });
+
+    it('supplementNote 없이 호출할 수 있다', async () => {
+      service.rerun.mockResolvedValue(mockTask);
+
+      await controller.rerun('task-1', {});
+
+      expect(service.rerun).toHaveBeenCalledWith('task-1', undefined, undefined);
+    });
+  });
+
+  describe('rerunAgent', () => {
+    it('service.rerunAgent를 agentId와 supplementNote로 호출한다', async () => {
+      service.rerunAgent.mockResolvedValue(mockTask);
+
+      const result = await controller.rerunAgent('task-1', '2', { supplementNote: 'agent only', writeTestCode: true });
+
+      expect(service.rerunAgent).toHaveBeenCalledWith('task-1', 2, 'agent only', true);
+      expect(result).toBe(mockTask);
+    });
+  });
+
+  describe('getRuns', () => {
+    it('service.getRuns를 호출하고 실행 이력을 반환한다', async () => {
+      const runs: TaskRunEntity[] = [
+        { id: 1, taskId: 'task-1', version: 1, supplementNote: null, status: 'completed', startedAt: new Date(), completedAt: null, task: mockTask, agentRuns: [] },
+      ];
+      service.getRuns.mockResolvedValue(runs);
+
+      const result = await controller.getRuns('task-1');
+
+      expect(service.getRuns).toHaveBeenCalledWith('task-1');
+      expect(result).toBe(runs);
+    });
+  });
+
+  describe('archive', () => {
+    it('service.archive를 호출한다', async () => {
+      service.archive.mockResolvedValue(undefined);
+
+      await controller.archive('task-1');
+
+      expect(service.archive).toHaveBeenCalledWith('task-1');
+    });
+  });
+
+  describe('mergeAgentAll', () => {
+    it('service.mergeAgentAll을 id와 agentId로 호출한다', async () => {
+      service.mergeAgentAll.mockResolvedValue({ success: true, message: '완료' });
+
+      const result = await controller.mergeAgentAll('task-1', '2');
+
+      expect(service.mergeAgentAll).toHaveBeenCalledWith('task-1', 2);
+      expect(result).toEqual({ success: true, message: '완료' });
+    });
+  });
+
+  describe('mergeAgentFile', () => {
+    it('service.mergeAgentFile을 filePath와 함께 호출한다', async () => {
+      service.mergeAgentFile.mockResolvedValue({ success: true, message: '완료' });
+
+      const result = await controller.mergeAgentFile('task-1', '2', { filePath: 'src/app.ts' });
+
+      expect(service.mergeAgentFile).toHaveBeenCalledWith('task-1', 2, 'src/app.ts');
+      expect(result).toEqual({ success: true, message: '완료' });
+    });
+  });
+
+  describe('remove', () => {
+    it('service.remove를 호출한다', async () => {
+      service.remove.mockResolvedValue(undefined);
+
+      await controller.remove('task-1');
+
+      expect(service.remove).toHaveBeenCalledWith('task-1');
+    });
+  });
+});

package/apps/server/src/modules/tasks/tasks.controller.ts

@@ -0,0 +1,139 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  Patch,
+  Post,
+  UsePipes,
+  ValidationPipe,
+} from '@nestjs/common';
+import { ApiNoContentResponse, ApiOkResponse, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { CreateTaskDto } from './dto/create-task.dto';
+import { ExecuteTaskDto } from './dto/execute-task.dto';
+import { MergeFileDto } from './dto/merge-file.dto';
+import { RerunTaskDto } from './dto/rerun-task.dto';
+import { UpdateTaskDto } from './dto/update-task.dto';
+import { TasksService } from './tasks.service';
+
+@ApiTags('tasks')
+@UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
+@Controller('tasks')
+export class TasksController {
+  constructor(private readonly tasksService: TasksService) {}
+
+  @ApiOperation({ summary: '작업 생성' })
+  @ApiOkResponse({ description: '생성된 작업 정보' })
+  @Post()
+  create(@Body() dto: CreateTaskDto) {
+    return this.tasksService.create(dto);
+  }
+
+  @ApiOperation({ summary: '전체 작업 목록 조회' })
+  @ApiOkResponse({ description: '작업 목록 (에이전트 로그 포함)' })
+  @Get()
+  findAll() {
+    return this.tasksService.findAll();
+  }
+
+  @ApiOperation({ summary: '특정 작업 조회' })
+  @ApiOkResponse({ description: '작업 상세 정보' })
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.tasksService.findOne(id);
+  }
+
+  @ApiOperation({ summary: '작업 수정 (제목·디렉토리·요구사항·에이전트)' })
+  @ApiOkResponse({ description: '수정된 작업 정보' })
+  @Patch(':id')
+  update(@Param('id') id: string, @Body() dto: UpdateTaskDto) {
+    return this.tasksService.update(id, dto);
+  }
+
+  @ApiOperation({
+    summary: '작업 실행',
+    description: '실시간 출력은 WebSocket `/tasks` 네임스페이스의 `agent:output` / `task:status` 이벤트로 수신',
+  })
+  @ApiOkResponse({ description: '실행 시작 확인' })
+  @Post(':id/execute')
+  @HttpCode(HttpStatus.OK)
+  execute(@Param('id') id: string, @Body() dto: ExecuteTaskDto = {}) {
+    return this.tasksService.execute(id, dto.agentTestCodePreferences);
+  }
+
+  @ApiOperation({ summary: '실행 중인 작업 중지' })
+  @ApiOkResponse({ description: '중지 확인' })
+  @Post(':id/stop')
+  @HttpCode(HttpStatus.OK)
+  stop(@Param('id') id: string) {
+    return this.tasksService.stop(id);
+  }
+
+  @ApiOperation({ summary: '작업 재실행', description: '보완 메모를 추가하여 동일 작업을 다시 실행' })
+  @ApiOkResponse({ description: '재실행 시작 확인' })
+  @Post(':id/rerun')
+  @HttpCode(HttpStatus.OK)
+  rerun(@Param('id') id: string, @Body() dto: RerunTaskDto) {
+    return this.tasksService.rerun(id, dto.supplementNote, dto.writeTestCode);
+  }
+
+  @ApiOperation({ summary: '에이전트 단위 작업 재실행', description: '보완 메모를 추가하여 특정 에이전트만 다시 실행' })
+  @ApiOkResponse({ description: '에이전트 재실행 시작 확인' })
+  @Post(':id/agents/:agentId/rerun')
+  @HttpCode(HttpStatus.OK)
+  rerunAgent(
+    @Param('id') id: string,
+    @Param('agentId') agentId: string,
+    @Body() dto: RerunTaskDto,
+  ) {
+    return this.tasksService.rerunAgent(id, Number(agentId), dto.supplementNote, dto.writeTestCode);
+  }
+
+  @ApiOperation({ summary: '실행 버전 이력 조회' })
+  @ApiOkResponse({ description: '버전별 실행 기록 (supplementNote, 상태, 에이전트 결과 포함)' })
+  @Get(':id/runs')
+  getRuns(@Param('id') id: string) {
+    return this.tasksService.getRuns(id);
+  }
+
+  @ApiOperation({ summary: '작업 보관' })
+  @ApiNoContentResponse({ description: '보관 완료 (응답 본문 없음)' })
+  @Post(':id/archive')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  archive(@Param('id') id: string) {
+    return this.tasksService.archive(id);
+  }
+
+  @ApiOperation({ summary: '에이전트 전체 변경사항 병합' })
+  @ApiOkResponse({ description: '병합 결과' })
+  @Post(':id/agents/:agentId/merge')
+  mergeAgentAll(
+    @Param('id') id: string,
+    @Param('agentId') agentId: string,
+  ) {
+    return this.tasksService.mergeAgentAll(id, Number(agentId));
+  }
+
+  @ApiOperation({ summary: '에이전트 단일 파일 병합' })
+  @ApiOkResponse({ description: '병합 결과' })
+  @Post(':id/agents/:agentId/merge-file')
+  mergeAgentFile(
+    @Param('id') id: string,
+    @Param('agentId') agentId: string,
+    @Body() dto: MergeFileDto,
+  ) {
+    return this.tasksService.mergeAgentFile(id, Number(agentId), dto.filePath);
+  }
+
+  @ApiOperation({ summary: '작업 삭제' })
+  @ApiNoContentResponse({ description: '삭제 완료 (응답 본문 없음)' })
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  remove(@Param('id') id: string) {
+    return this.tasksService.remove(id);
+  }
+}

package/apps/server/src/modules/tasks/tasks.module.ts

@@ -0,0 +1,30 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { TaskAgentEntity } from '../../database/entities/task-agent.entity';
+import { TaskAgentRunEntity } from '../../database/entities/task-agent-run.entity';
+import { TaskRequirementEntity } from '../../database/entities/task-requirement.entity';
+import { TaskEntity } from '../../database/entities/task.entity';
+import { TaskRunEntity } from '../../database/entities/task-run.entity';
+import { GeminiModule } from '../agents/gemini/gemini.module';
+import { ConversationModule } from '../conversations/conversation.module';
+import { ChangelogModule } from '../changelog/changelog.module';
+import { HarnessModule } from '../harness/harness.module';
+import { TaskExecutionService } from './task-execution.service';
+import { TaskGateway } from './task.gateway';
+import { TasksController } from './tasks.controller';
+import { TasksService } from './tasks.service';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([TaskEntity, TaskRequirementEntity, TaskAgentEntity, TaskRunEntity, TaskAgentRunEntity]),
+    GeminiModule,
+    ConversationModule,
+    ChangelogModule,
+    HarnessModule,
+  ],
+  controllers: [TasksController],
+  providers: [TasksService, TaskExecutionService, TaskGateway],
+  exports: [TasksService],
+})
+export class TasksModule {}