@jcjeon/integration-cli 0.2.0 → 0.2.1

package/apps/server/src/modules/agents/codex/codex-session.manager.ts

@@ -1,357 +0,0 @@
-import { spawn, type ChildProcess } from 'child_process';
-import { EventEmitter } from 'events';
-
-const IS_WIN = process.platform === 'win32';
-
-import { Injectable, Logger, NotFoundException, OnModuleDestroy } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
-import { v4 as uuidv4 } from 'uuid';
-
-import { AgentSessionEntity } from '../../../database/entities/agent-session.entity';
-import { SessionEntity } from '../../../database/entities/session.entity';
-import { CodexAuthManager } from './codex-auth.manager';
-
-export interface CodexSessionInfo {
-  id: string;
-  status: 'idle' | 'processing' | 'terminated';
-  workingDirectory: string;
-  model: string | null;
-  reasoning: string | null;
-  createdAt: Date;
-  lastActivity: Date;
-}
-
-interface CodexSession extends CodexSessionInfo {
-  persisted: boolean;
-}
-
-const ANSI_STRIP = /\x1b\[[0-9;?]*[a-zA-Z]|\x1b\][^\x07]*\x07/g;
-const CODEX_REASONING_LEVELS = new Set(['low', 'medium', 'high', 'xhigh']);
-
-function normalizeModel(value?: string | null): string | null {
-  const trimmed = value?.trim();
-  if (!trimmed || trimmed === 'default') return null;
-  return trimmed;
-}
-
-function normalizeReasoning(value?: string | null): string | null {
-  const trimmed = value?.trim();
-  if (!trimmed || trimmed === 'default') return null;
-  return CODEX_REASONING_LEVELS.has(trimmed) ? trimmed : null;
-}
-
-/**
- * codex exec 출력 형식:
- *   Reading additional input from stdin...
- *   OpenAI Codex vX.Y.Z
- *   --------
- *   workdir: ... / model: ... / ...
- *   --------
- *   user
- *   <user prompt echo>
- *   codex
- *   <actual response lines>
- *   tokens used
- *   <token count>
- *   <response duplicate>
- *
- * "codex" 섹션 내용만 emit하고, 나머지는 모두 버린다.
- */
-type ParseState = 'header' | 'user_echo' | 'response' | 'done';
-
-class CodexOutputParser {
-  private state: ParseState = 'header';
-  private lineBuffer = '';
-
-  /** 청크를 받아 emit할 텍스트만 반환한다 (없으면 빈 문자열). */
-  feed(raw: string): string {
-    const text = raw.replace(ANSI_STRIP, '').replace(/\r/g, '');
-    this.lineBuffer += text;
-
-    const lines = this.lineBuffer.split('\n');
-    this.lineBuffer = lines.pop() ?? '';
-
-    let out = '';
-    for (const line of lines) {
-      out += this.handleLine(line);
-    }
-    return out;
-  }
-
-  /** 프로세스 종료 시 버퍼 플러시 */
-  flush(): string {
-    if (!this.lineBuffer) return '';
-    const out = this.handleLine(this.lineBuffer);
-    this.lineBuffer = '';
-    return out;
-  }
-
-  private handleLine(line: string): string {
-    if (this.state === 'done') return '';
-
-    // 헤더 구간: 두 번째 '--------' 까지 모두 버림
-    if (this.state === 'header') {
-      if (line === '--------') this.state = 'user_echo';
-      return '';
-    }
-
-    // 섹션 헤더 감지
-    if (line === 'user') { this.state = 'user_echo'; return ''; }
-    if (line === 'codex') { this.state = 'response'; return ''; }
-    if (line === 'tokens used') { this.state = 'done'; return ''; }
-
-    // user echo 줄 → 스킵하고 다음 섹션 헤더 대기
-    if (this.state === 'user_echo') return '';
-
-    // response 구간 → 그대로 출력
-    if (this.state === 'response') return line + '\n';
-
-    return '';
-  }
-}
-
-@Injectable()
-export class CodexSessionManager extends EventEmitter implements OnModuleDestroy {
-  private readonly logger = new Logger(CodexSessionManager.name);
-  private readonly sessions = new Map<string, CodexSession>();
-  private readonly processes = new Map<string, ChildProcess>();
-
-  constructor(
-    @InjectRepository(AgentSessionEntity)
-    private readonly agentSessionRepo: Repository<AgentSessionEntity>,
-    @InjectRepository(SessionEntity)
-    private readonly sessionRepo: Repository<SessionEntity>,
-    private readonly authManager: CodexAuthManager,
-  ) {
-    super();
-  }
-
-  createSession(workingDirectory = process.cwd(), model?: string, reasoning?: string): CodexSessionInfo {
-    const id = uuidv4();
-    const now = new Date();
-    const session: CodexSession = {
-      id,
-      status: 'idle',
-      workingDirectory,
-      model: normalizeModel(model),
-      reasoning: normalizeReasoning(reasoning),
-      createdAt: now,
-      lastActivity: now,
-      persisted: false,
-    };
-    this.sessions.set(id, session);
-    this.logger.log(`Created Codex session ${id} (cwd: ${workingDirectory})`);
-    return this.toInfo(session);
-  }
-
-  getSession(id: string): CodexSessionInfo {
-    const session = this.sessions.get(id);
-    if (!session) throw new NotFoundException(`Session ${id} not found`);
-    return this.toInfo(session);
-  }
-
-  listSessions(): CodexSessionInfo[] {
-    return [...this.sessions.values()].map((s) => this.toInfo(s));
-  }
-
-  terminateSession(id: string): void {
-    const session = this.sessions.get(id);
-    if (!session) throw new NotFoundException(`Session ${id} not found`);
-    session.status = 'terminated';
-    this.killProcess(id);
-    this.sessions.delete(id);
-    if (session.persisted) {
-      void this.agentSessionRepo.update(id, { status: 'terminated' });
-    }
-    this.logger.log(`Terminated Codex session ${id}`);
-  }
-
-  sendMessage(sessionId: string, message: string): void {
-    const existing = this.sessions.get(sessionId);
-    if (!existing) {
-      void this.restoreAndSend(sessionId, message);
-      return;
-    }
-    if (existing.status === 'processing') throw new Error(`Session ${sessionId} is already processing`);
-
-    existing.status = 'processing';
-    existing.lastActivity = new Date();
-
-    if (!existing.persisted) {
-      void this.persistSession(existing).then(() => {
-        if (existing.status === 'terminated' || !this.sessions.has(sessionId)) {
-          void this.agentSessionRepo.update(sessionId, { status: 'terminated' });
-          return;
-        }
-        this.spawnCodex(existing, message);
-      });
-      return;
-    }
-
-    void this.agentSessionRepo.update(sessionId, { status: 'processing' });
-    this.spawnCodex(existing, message);
-  }
-
-  private async restoreAndSend(
-    sessionId: string,
-    message: string,
-    model?: string,
-    reasoning?: string,
-  ): Promise<void> {
-    const record = await this.agentSessionRepo.findOne({ where: { id: sessionId } });
-    if (!record) {
-      const newSession = this.createSession(undefined, model, reasoning);
-      this.logger.log(`Session ${sessionId} not found — spawned new session ${newSession.id}`);
-      this.emit('session:replaced', { oldSessionId: sessionId, newSessionId: newSession.id });
-      this.sendMessage(newSession.id, message);
-      return;
-    }
-    const now = new Date();
-    const session: CodexSession = {
-      id: sessionId,
-      status: 'processing',
-      workingDirectory: record.workingDirectory,
-      model: normalizeModel(record.model),
-      reasoning: normalizeReasoning(record.reasoning),
-      createdAt: record.createdAt,
-      lastActivity: now,
-      persisted: true,
-    };
-    this.updateModelSettings(session, model, reasoning);
-    this.sessions.set(sessionId, session);
-    this.logger.log(`Restored Codex session ${sessionId} (cwd: ${record.workingDirectory})`);
-    void this.agentSessionRepo.update(sessionId, { status: 'processing' });
-    this.spawnCodex(session, message);
-  }
-
-  private async persistSession(session: CodexSession): Promise<void> {
-    const title = session.workingDirectory.replace(/[/\\]+$/, '').split(/[/\\]/).filter(Boolean).at(-1) ?? 'Codex';
-    await Promise.all([
-      this.agentSessionRepo.save({
-        id: session.id,
-        claudeSessionId: null,
-        status: 'processing',
-        workingDirectory: session.workingDirectory,
-        model: session.model,
-        reasoning: session.reasoning,
-      }),
-      this.sessionRepo.save({ sessionId: session.id, title, agentType: 'codex' }),
-    ]);
-    session.persisted = true;
-    this.logger.log(`Persisted Codex session ${session.id} (${title})`);
-  }
-
-  private updateModelSettings(session: CodexSession, model?: string, reasoning?: string): void {
-    if (model !== undefined) session.model = normalizeModel(model);
-    if (reasoning !== undefined) session.reasoning = normalizeReasoning(reasoning);
-    if (session.persisted && (model !== undefined || reasoning !== undefined)) {
-      void this.agentSessionRepo.update(session.id, {
-        model: session.model,
-        reasoning: session.reasoning,
-      });
-    }
-  }
-
-  sendMessageWithSettings(sessionId: string, message: string, model?: string, reasoning?: string): void {
-    const existing = this.sessions.get(sessionId);
-    if (existing) {
-      this.updateModelSettings(existing, model, reasoning);
-      this.sendMessage(sessionId, message);
-      return;
-    }
-    void this.restoreAndSend(sessionId, message, model, reasoning);
-  }
-
-  private spawnCodex(session: CodexSession, message: string): void {
-    const sessionId = session.id;
-    const parser = new CodexOutputParser();
-
-    const codexArgs = ['exec', '-c', 'approval_policy=never', '-c', 'sandbox_mode=danger-full-access'];
-    if (session.model) {
-      codexArgs.push('-m', session.model);
-    }
-    if (session.reasoning) {
-      codexArgs.push('-c', `model_reasoning_effort="${session.reasoning}"`);
-    }
-    codexArgs.push(message);
-    const [cmd, spawnArgs] = IS_WIN
-      ? ['cmd.exe', ['/c', 'codex', ...codexArgs]]
-      : ['codex', codexArgs];
-
-    const proc = spawn(cmd, spawnArgs, {
-      cwd: session.workingDirectory,
-      env: this.authManager.getEnvForCodex(),
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    this.processes.set(sessionId, proc);
-
-    let output = '';
-
-    const handleChunk = (chunk: Buffer) => {
-      const filtered = parser.feed(chunk.toString());
-      if (!filtered) return;
-      output += filtered;
-      this.emit('session:text', { sessionId, text: filtered });
-    };
-
-    proc.stdout.on('data', handleChunk);
-    proc.stderr.on('data', handleChunk);
-
-    proc.on('close', (exitCode) => {
-      this.processes.delete(sessionId);
-      const exitPayload = { sessionId, exitCode: exitCode ?? -1 };
-
-      if (session.status === 'terminated' || !this.sessions.has(sessionId)) {
-        this.emit('session:exit', exitPayload);
-        return;
-      }
-
-      const tail = parser.flush();
-      if (tail) { output += tail; this.emit('session:text', { sessionId, text: tail }); }
-
-      session.status = 'idle';
-      void this.agentSessionRepo.update(sessionId, { status: 'idle' });
-      const isError = (exitCode ?? 0) !== 0;
-      this.emit('session:result', { sessionId, result: output.trim(), isError, durationMs: 0, costUsd: 0 });
-      this.emit('session:exit', exitPayload);
-      this.logger.log(`Codex session ${sessionId} finished (exit: ${exitCode})`);
-    });
-
-    proc.on('error', (err) => {
-      this.processes.delete(sessionId);
-      if (session.status === 'terminated' || !this.sessions.has(sessionId)) {
-        return;
-      }
-
-      session.status = 'idle';
-      void this.agentSessionRepo.update(sessionId, { status: 'idle' });
-      this.logger.error(`Codex session ${sessionId} spawn error: ${err.message}`);
-      this.emit('error', { sessionId, message: err.message });
-    });
-  }
-
-  onModuleDestroy(): void {
-    for (const sessionId of this.processes.keys()) {
-      this.killProcess(sessionId);
-    }
-    this.sessions.clear();
-  }
-
-  private killProcess(sessionId: string): void {
-    const proc = this.processes.get(sessionId);
-    if (!proc) return;
-
-    this.processes.delete(sessionId);
-    try {
-      if (!proc.killed) proc.kill('SIGTERM');
-    } catch (err) {
-      this.logger.warn(`Failed to kill Codex session ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-
-  private toInfo(session: CodexSession): CodexSessionInfo {
-    const { persisted: _p, ...info } = session;
-    return info;
-  }
-}

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

@@ -1,64 +0,0 @@
-import {
-  Body,
-  Controller,
-  Delete,
-  Get,
-  HttpCode,
-  HttpStatus,
-  Param,
-  Post,
-  UsePipes,
-  ValidationPipe,
-} from '@nestjs/common';
-
-import { CodexAuthManager } from './codex-auth.manager';
-import { CodexSessionManager } from './codex-session.manager';
-import type { CodexSessionInfo } from './codex-session.manager';
-import { ConfigureCodexAuthDto } from './dto/configure-auth.dto';
-
-@UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-@Controller('agents/codex')
-export class CodexController {
-  constructor(
-    private readonly authManager: CodexAuthManager,
-    private readonly sessionManager: CodexSessionManager,
-  ) {}
-
-  /** GET /agents/codex/auth/status */
-  @Get('auth/status')
-  getAuthStatus() {
-    return this.authManager.getAuthStatus();
-  }
-
-  /** POST /agents/codex/auth/configure */
-  @Post('auth/configure')
-  @HttpCode(HttpStatus.NO_CONTENT)
-  configureAuth(@Body() dto: ConfigureCodexAuthDto): void {
-    this.authManager.saveApiKey(dto.apiKey.trim());
-  }
-
-  /** POST /agents/codex/sessions */
-  @Post('sessions')
-  createSession(@Body() body: { workingDirectory?: string; model?: string; reasoning?: string }): CodexSessionInfo {
-    return this.sessionManager.createSession(body.workingDirectory, body.model, body.reasoning);
-  }
-
-  /** GET /agents/codex/sessions */
-  @Get('sessions')
-  listSessions(): CodexSessionInfo[] {
-    return this.sessionManager.listSessions();
-  }
-
-  /** GET /agents/codex/sessions/:id */
-  @Get('sessions/:id')
-  getSession(@Param('id') id: string): CodexSessionInfo {
-    return this.sessionManager.getSession(id);
-  }
-
-  /** DELETE /agents/codex/sessions/:id */
-  @Delete('sessions/:id')
-  @HttpCode(HttpStatus.NO_CONTENT)
-  terminateSession(@Param('id') id: string): void {
-    this.sessionManager.terminateSession(id);
-  }
-}

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

@@ -1,97 +0,0 @@
-import { Logger } from '@nestjs/common';
-import {
-  ConnectedSocket,
-  MessageBody,
-  OnGatewayDisconnect,
-  OnGatewayInit,
-  SubscribeMessage,
-  WebSocketGateway,
-  WebSocketServer,
-} from '@nestjs/websockets';
-import { Server, Socket } from 'socket.io';
-
-import { CodexAuthManager } from './codex-auth.manager';
-import { CodexSessionManager } from './codex-session.manager';
-
-@WebSocketGateway({ namespace: '/agents/codex', cors: { origin: '*' } })
-export class CodexGateway implements OnGatewayInit, OnGatewayDisconnect {
-  @WebSocketServer()
-  private readonly server!: Server;
-
-  private readonly logger = new Logger(CodexGateway.name);
-
-  constructor(
-    private readonly authManager: CodexAuthManager,
-    private readonly sessionManager: CodexSessionManager,
-  ) {}
-
-  afterInit(): void {
-    this.sessionManager.on('session:text', (ev) => this.server.to(ev.sessionId).emit('session:text', ev));
-    this.sessionManager.on('session:result', (ev) => this.server.to(ev.sessionId).emit('session:result', ev));
-    this.sessionManager.on('session:exit', (ev) => this.server.to(ev.sessionId).emit('session:exit', ev));
-    this.sessionManager.on('error', (ev) => this.server.to(ev.sessionId).emit('error', { message: ev.message }));
-    this.sessionManager.on('session:replaced', async (ev: { oldSessionId: string; newSessionId: string }) => {
-      const sockets = await this.server.in(ev.oldSessionId).fetchSockets();
-      await Promise.all(sockets.map((s) => s.join(ev.newSessionId)));
-      this.server.to(ev.newSessionId).emit('session:replaced', { oldSessionId: ev.oldSessionId, newSessionId: ev.newSessionId });
-    });
-    this.logger.log('CodexGateway initialised — namespace: /agents/codex');
-  }
-
-  handleDisconnect(client: Socket): void {
-    this.authManager.cancelLogin(client.id);
-  }
-
-  // ─── Auth ─────────────────────────────────────────────────────────────────
-
-  @SubscribeMessage('auth:login:start')
-  handleAuthLoginStart(@ConnectedSocket() client: Socket): void {
-    this.authManager.startLogin(
-      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);
-  }
-
-  // ─── Session ──────────────────────────────────────────────────────────────
-
-  @SubscribeMessage('session:message')
-  handleSessionMessage(
-    @ConnectedSocket() client: Socket,
-    @MessageBody() body: { sessionId: string; input: string; model?: string; reasoning?: string },
-  ): void {
-    try {
-      void client.join(body.sessionId);
-      this.sessionManager.sendMessageWithSettings(body.sessionId, body.input, body.model, body.reasoning);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Unknown error';
-      client.emit('error', { message });
-    }
-  }
-
-  @SubscribeMessage('session:join')
-  handleSessionJoin(
-    @ConnectedSocket() client: Socket,
-    @MessageBody() body: { sessionId: string },
-  ): void {
-    void client.join(body.sessionId);
-  }
-
-  @SubscribeMessage('session:terminate')
-  handleSessionTerminate(
-    @ConnectedSocket() client: Socket,
-    @MessageBody() body: { sessionId: string },
-  ): void {
-    try {
-      this.sessionManager.terminateSession(body.sessionId);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Unknown error';
-      client.emit('error', { message });
-    }
-  }
-}

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

@@ -1,17 +0,0 @@
-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 { CodexAuthManager } from './codex-auth.manager';
-import { CodexController } from './codex.controller';
-import { CodexGateway } from './codex.gateway';
-import { CodexSessionManager } from './codex-session.manager';
-
-@Module({
-  imports: [TypeOrmModule.forFeature([AgentSessionEntity, SessionEntity])],
-  controllers: [CodexController],
-  providers: [CodexAuthManager, CodexSessionManager, CodexGateway],
-  exports: [CodexAuthManager, CodexSessionManager],
-})
-export class CodexModule {}

package/apps/server/src/modules/agents/codex/dto/configure-auth.dto.ts

@@ -1,7 +0,0 @@
-import { IsNotEmpty, IsString } from 'class-validator';
-
-export class ConfigureCodexAuthDto {
-  @IsString()
-  @IsNotEmpty()
-  apiKey!: string;
-}

package/apps/server/src/modules/agents/gemini/dto/configure-auth.dto.ts

@@ -1,15 +0,0 @@
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import { IsIn, IsOptional, IsString } from 'class-validator';
-
-import type { GeminiAuthType } from '../gemini-auth.manager';
-
-export class ConfigureAuthDto {
-  @ApiProperty({ enum: ['api-key', 'gca'], example: 'api-key', description: '인증 방식' })
-  @IsIn(['api-key', 'gca'])
-  authType!: GeminiAuthType;
-
-  @ApiPropertyOptional({ example: 'AIza...', description: 'API Key (authType=api-key 시 필수)' })
-  @IsOptional()
-  @IsString()
-  apiKey?: string;
-}

package/apps/server/src/modules/agents/gemini/dto/create-session.dto.ts

@@ -1,9 +0,0 @@
-import { ApiPropertyOptional } from '@nestjs/swagger';
-import { IsOptional, IsString } from 'class-validator';
-
-export class CreateSessionDto {
-  @ApiPropertyOptional({ example: '/Users/me/my-project', description: '세션 작업 디렉토리' })
-  @IsOptional()
-  @IsString()
-  workingDirectory?: string;
-}

package/apps/server/src/modules/agents/gemini/dto/send-input.dto.ts

@@ -1,9 +0,0 @@
-import { ApiProperty } from '@nestjs/swagger';
-import { IsString, MinLength } from 'class-validator';
-
-export class SendInputDto {
-  @ApiProperty({ example: '현재 코드를 분석해줘', description: '에이전트에게 전달할 메시지' })
-  @IsString()
-  @MinLength(1)
-  input!: string;
-}