@jcjeon/integration-cli 0.2.0

package/apps/server/src/modules/agents/gemini/gemini.controller.ts

@@ -0,0 +1,93 @@
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  Post,
+  UsePipes,
+  ValidationPipe,
+} from '@nestjs/common';
+import { ApiNoContentResponse, ApiOkResponse, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { ConfigureAuthDto } from './dto/configure-auth.dto';
+import { CreateSessionDto } from './dto/create-session.dto';
+import { SendInputDto } from './dto/send-input.dto';
+import { GeminiAuthManager } from './gemini-auth.manager';
+import type { GeminiAuthStatus } from './gemini-auth.manager';
+import { GeminiSessionManager } from './gemini-session.manager';
+import type { SessionInfo } from './interfaces/gemini-session.interface';
+
+@ApiTags('agents/gemini')
+@UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
+@Controller('agents/gemini')
+export class GeminiController {
+  constructor(
+    private readonly authManager: GeminiAuthManager,
+    private readonly sessionManager: GeminiSessionManager,
+  ) {}
+
+  @ApiOperation({ summary: 'Gemini CLI 인증 상태 조회' })
+  @ApiOkResponse({ description: '설치 여부, 인증 방식, 이메일 반환' })
+  @Get('auth/status')
+  getAuthStatus(): Promise<GeminiAuthStatus> {
+    return this.authManager.getAuthStatus();
+  }
+
+  @ApiOperation({
+    summary: 'Gemini CLI 인증 설정',
+    description: '`api-key` 방식은 apiKey 필드 필수. `gca` 방식은 WebSocket으로 진행',
+  })
+  @ApiNoContentResponse({ description: '설정 완료 (응답 본문 없음)' })
+  @Post('auth/configure')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  configureAuth(@Body() dto: ConfigureAuthDto): void {
+    if (dto.authType === 'api-key') {
+      if (!dto.apiKey?.trim()) throw new BadRequestException('apiKey is required');
+      this.authManager.saveApiKey(dto.apiKey.trim());
+    }
+  }
+
+  @ApiOperation({ summary: '새 Gemini 세션 생성' })
+  @ApiOkResponse({ description: '생성된 세션 정보' })
+  @Post('sessions')
+  createSession(@Body() dto: CreateSessionDto): SessionInfo {
+    return this.sessionManager.createSession(dto.workingDirectory);
+  }
+
+  @ApiOperation({ summary: '활성 Gemini 세션 목록 조회' })
+  @ApiOkResponse({ description: '세션 목록' })
+  @Get('sessions')
+  listSessions(): SessionInfo[] {
+    return this.sessionManager.listSessions();
+  }
+
+  @ApiOperation({ summary: '특정 Gemini 세션 조회' })
+  @ApiOkResponse({ description: '세션 정보' })
+  @Get('sessions/:id')
+  getSession(@Param('id') id: string): SessionInfo {
+    return this.sessionManager.getSessionInfo(id);
+  }
+
+  @ApiOperation({
+    summary: '세션에 메시지 전송',
+    description: '응답은 WebSocket `/agents/gemini` 네임스페이스의 `session:chunk` / `session:done` 이벤트로 수신',
+  })
+  @ApiNoContentResponse({ description: '전송 완료 (응답 본문 없음)' })
+  @Post('sessions/:id/message')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  sendMessage(@Param('id') id: string, @Body() dto: SendInputDto): void {
+    this.sessionManager.sendMessage(id, dto.input);
+  }
+
+  @ApiOperation({ summary: '세션 종료' })
+  @ApiNoContentResponse({ description: '종료 완료 (응답 본문 없음)' })
+  @Delete('sessions/:id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  terminateSession(@Param('id') id: string): void {
+    this.sessionManager.terminateSession(id);
+  }
+}

package/apps/server/src/modules/agents/gemini/gemini.gateway.ts

@@ -0,0 +1,149 @@
+import { Logger, UsePipes, ValidationPipe } from '@nestjs/common';
+import {
+  ConnectedSocket,
+  MessageBody,
+  OnGatewayConnection,
+  OnGatewayDisconnect,
+  OnGatewayInit,
+  SubscribeMessage,
+  WebSocketGateway,
+  WebSocketServer,
+  WsException,
+} from '@nestjs/websockets';
+import { Server, Socket } from 'socket.io';
+
+import { GeminiAuthManager } from './gemini-auth.manager';
+import { GeminiSessionManager } from './gemini-session.manager';
+import { SendInputDto } from './dto/send-input.dto';
+import type { CreateSessionDto } from './dto/create-session.dto';
+import type { ResultEvent, SessionExitEvent, TextDeltaEvent } from './interfaces/stream-event.interface';
+
+/**
+ * WebSocket 이벤트 프로토콜 (/agents/gemini)
+ *
+ * Client → Server
+ *   session:create    { workingDirectory? }
+ *   session:message   { sessionId, input }
+ *   session:terminate { sessionId }
+ *   auth:gca:start
+ *   auth:login:cancel
+ *
+ * Server → Client
+ *   session:created   { id, status, ... }
+ *   session:text      { sessionId, text }
+ *   session:result    { sessionId, isError }
+ *   session:exit      { sessionId, exitCode }
+ *   error             { message }
+ *   auth:output       { text }
+ *   auth:done         { success }
+ */
+@UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
+@WebSocketGateway({ namespace: '/agents/gemini', cors: { origin: '*' } })
+export class GeminiGateway implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect {
+  @WebSocketServer()
+  private readonly server!: Server;
+
+  private readonly logger = new Logger(GeminiGateway.name);
+
+  constructor(
+    private readonly sessionManager: GeminiSessionManager,
+    private readonly authManager: GeminiAuthManager,
+  ) {}
+
+  // ─── Gateway hooks ───────────────────────────────────────────────────
+
+  afterInit(): void {
+    this.sessionManager.on('text-delta', (event: TextDeltaEvent) => {
+      this.server.to(event.sessionId).emit('session:text', event);
+    });
+
+    this.sessionManager.on('result', (event: ResultEvent) => {
+      this.server.to(event.sessionId).emit('session:result', event);
+    });
+
+    this.sessionManager.on('exit', (event: SessionExitEvent) => {
+      this.server.to(event.sessionId).emit('session:exit', event);
+    });
+
+    this.sessionManager.on('error', (event: { sessionId: string; message: string }) => {
+      this.server.to(event.sessionId).emit('error', { message: event.message });
+    });
+
+    this.logger.log('GeminiGateway initialised — namespace: /agents/gemini');
+  }
+
+  handleConnection(client: Socket): void {
+    this.logger.debug(`Client connected: ${client.id}`);
+  }
+
+  handleDisconnect(client: Socket): void {
+    this.authManager.cancelLogin(client.id);
+    this.logger.debug(`Client disconnected: ${client.id}`);
+  }
+
+  // ─── Session handlers ────────────────────────────────────────────────
+
+  @SubscribeMessage('session:create')
+  handleCreate(
+    @ConnectedSocket() client: Socket,
+    @MessageBody() dto: CreateSessionDto,
+  ): void {
+    try {
+      const session = this.sessionManager.createSession(dto.workingDirectory);
+      void client.join(session.id);
+      client.emit('session:created', session);
+    } catch (err) {
+      this.emitError(client, err);
+    }
+  }
+
+  @SubscribeMessage('session:message')
+  handleMessage(
+    @ConnectedSocket() client: Socket,
+    @MessageBody() body: { sessionId: string } & SendInputDto,
+  ): void {
+    try {
+      void client.join(body.sessionId);
+      this.sessionManager.sendMessage(body.sessionId, body.input);
+    } catch (err) {
+      this.emitError(client, err);
+    }
+  }
+
+  @SubscribeMessage('session:terminate')
+  handleTerminate(
+    @ConnectedSocket() client: Socket,
+    @MessageBody('sessionId') sessionId: string,
+  ): void {
+    try {
+      this.sessionManager.terminateSession(sessionId);
+    } catch (err) {
+      this.emitError(client, err);
+    }
+  }
+
+  // ─── Auth handlers ───────────────────────────────────────────────────
+
+  @SubscribeMessage('auth:gca:start')
+  handleGcaLoginStart(@ConnectedSocket() client: Socket): void {
+    this.authManager.startGcaLogin(
+      client.id,
+      (text) => client.emit('auth:output', { text }),
+      (success) => client.emit('auth:done', { success }),
+    );
+  }
+
+  @SubscribeMessage('auth:login:cancel')
+  handleAuthLoginCancel(@ConnectedSocket() client: Socket): void {
+    this.authManager.cancelLogin(client.id);
+  }
+
+  // ─── Private ─────────────────────────────────────────────────────────
+
+  private emitError(client: Socket, err: unknown): void {
+    const message = err instanceof Error ? err.message : 'Unknown error';
+    this.logger.error(`[${client.id}] ${message}`);
+    client.emit('error', { message });
+    throw new WsException(message);
+  }
+}

package/apps/server/src/modules/agents/gemini/gemini.module.ts

@@ -0,0 +1,17 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { AgentSessionEntity } from '../../../database/entities/agent-session.entity';
+import { SessionEntity } from '../../../database/entities/session.entity';
+import { GeminiAuthManager } from './gemini-auth.manager';
+import { GeminiController } from './gemini.controller';
+import { GeminiGateway } from './gemini.gateway';
+import { GeminiSessionManager } from './gemini-session.manager';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([AgentSessionEntity, SessionEntity])],
+  controllers: [GeminiController],
+  providers: [GeminiAuthManager, GeminiSessionManager, GeminiGateway],
+  exports: [GeminiSessionManager, GeminiAuthManager],
+})
+export class GeminiModule {}

package/apps/server/src/modules/agents/gemini/interfaces/gemini-session.interface.ts

@@ -0,0 +1,18 @@
+export type SessionStatus = 'idle' | 'processing' | 'terminated';
+
+export interface GeminiSession {
+  id: string;
+  status: SessionStatus;
+  workingDirectory: string;
+  createdAt: Date;
+  lastActivity: Date;
+  persisted: boolean;
+}
+
+export interface SessionInfo {
+  id: string;
+  status: SessionStatus;
+  workingDirectory: string;
+  createdAt: Date;
+  lastActivity: Date;
+}

package/apps/server/src/modules/agents/gemini/interfaces/stream-event.interface.ts

@@ -0,0 +1,14 @@
+export interface TextDeltaEvent {
+  sessionId: string;
+  text: string;
+}
+
+export interface ResultEvent {
+  sessionId: string;
+  isError: boolean;
+}
+
+export interface SessionExitEvent {
+  sessionId: string;
+  exitCode: number;
+}

package/apps/server/src/modules/agents/session-termination.spec.ts

@@ -0,0 +1,103 @@
+import { EventEmitter } from 'events';
+import { spawn } from 'child_process';
+
+import { ClaudePtyManager } from './claude/claude-pty.manager';
+import { CodexSessionManager } from './codex/codex-session.manager';
+import { GeminiSessionManager } from './gemini/gemini-session.manager';
+
+jest.mock('child_process', () => ({
+  spawn: jest.fn(),
+  execSync: jest.fn(),
+}));
+
+const spawnMock = spawn as jest.Mock;
+
+function mockRepo() {
+  return {
+    save: jest.fn().mockResolvedValue({}),
+    update: jest.fn().mockResolvedValue({}),
+    findOne: jest.fn(),
+  };
+}
+
+function mockProcess() {
+  const proc = new EventEmitter() as EventEmitter & {
+    stdout: EventEmitter;
+    stderr: EventEmitter;
+    killed: boolean;
+    kill: jest.Mock;
+  };
+  proc.stdout = new EventEmitter();
+  proc.stderr = new EventEmitter();
+  proc.killed = false;
+  proc.kill = jest.fn(() => {
+    proc.killed = true;
+    return true;
+  });
+  return proc;
+}
+
+async function flushPromises() {
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
+describe('agent session termination', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  it('kills a running Claude process and does not reset DB status to idle after close', async () => {
+    const proc = mockProcess();
+    spawnMock.mockReturnValueOnce(proc);
+    const agentRepo = mockRepo();
+    const sessionRepo = mockRepo();
+    const manager = new ClaudePtyManager(agentRepo as never, sessionRepo as never);
+    const session = manager.createSession('/tmp/project');
+
+    manager.sendMessage(session.id, 'hello');
+    await flushPromises();
+    manager.terminateSession(session.id);
+    proc.emit('close', 0);
+
+    expect(proc.kill).toHaveBeenCalledWith('SIGTERM');
+    expect(agentRepo.update).toHaveBeenCalledWith(session.id, { status: 'terminated' });
+    expect(agentRepo.update).not.toHaveBeenCalledWith(session.id, { status: 'idle' });
+  });
+
+  it('kills a running Gemini process and does not reset DB status to idle after close', async () => {
+    const proc = mockProcess();
+    spawnMock.mockReturnValueOnce(proc);
+    const agentRepo = mockRepo();
+    const sessionRepo = mockRepo();
+    const authManager = { getEnvForGemini: jest.fn(() => ({})) };
+    const manager = new GeminiSessionManager(agentRepo as never, sessionRepo as never, authManager as never);
+    const session = manager.createSession('/tmp/project');
+
+    manager.sendMessage(session.id, 'hello');
+    await flushPromises();
+    manager.terminateSession(session.id);
+    proc.emit('close', 0);
+
+    expect(proc.kill).toHaveBeenCalledWith('SIGTERM');
+    expect(agentRepo.update).toHaveBeenCalledWith(session.id, { status: 'terminated' });
+    expect(agentRepo.update).not.toHaveBeenCalledWith(session.id, { status: 'idle' });
+  });
+
+  it('kills a running Codex process and persists terminated status', async () => {
+    const proc = mockProcess();
+    spawnMock.mockReturnValueOnce(proc);
+    const agentRepo = mockRepo();
+    const sessionRepo = mockRepo();
+    const authManager = { getEnvForCodex: jest.fn(() => ({})) };
+    const manager = new CodexSessionManager(agentRepo as never, sessionRepo as never, authManager as never);
+    const session = manager.createSession('/tmp/project');
+
+    manager.sendMessage(session.id, 'hello');
+    await flushPromises();
+    manager.terminateSession(session.id);
+    proc.emit('close', 0);
+
+    expect(proc.kill).toHaveBeenCalledWith('SIGTERM');
+    expect(agentRepo.update).toHaveBeenCalledWith(session.id, { status: 'terminated' });
+    expect(agentRepo.update).not.toHaveBeenCalledWith(session.id, { status: 'idle' });
+  });
+});

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

@@ -0,0 +1,20 @@
+import { Controller, Get, Param } from '@nestjs/common';
+
+import { GitChangelogService } from './changelog.service';
+
+@Controller('tasks')
+export class ChangelogController {
+  constructor(private readonly changelogService: GitChangelogService) {}
+
+  /** GET /tasks/:taskId/changelog */
+  @Get(':taskId/changelog')
+  getChangelog(@Param('taskId') taskId: string) {
+    return this.changelogService.getByTask(taskId);
+  }
+
+  /** GET /tasks/:taskId/runs/:runId/changelog */
+  @Get(':taskId/runs/:runId/changelog')
+  getRunChangelog(@Param('taskId') taskId: string, @Param('runId') runId: string) {
+    return this.changelogService.getByTask(taskId, Number(runId));
+  }
+}

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

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { AgentChangelogEntity } from '../../database/entities/agent-changelog.entity';
+import { ChangelogController } from './changelog.controller';
+import { GitChangelogService } from './changelog.service';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([AgentChangelogEntity])],
+  controllers: [ChangelogController],
+  providers: [GitChangelogService],
+  exports: [GitChangelogService],
+})
+export class ChangelogModule {}