@jcjeon/integration-cli 0.2.0

package/apps/server/src/modules/agents/claude/claude.service.ts

@@ -0,0 +1,67 @@
+import { execSync } from 'child_process';
+import * as os from 'os';
+
+import { Injectable } from '@nestjs/common';
+
+import { ClaudeAuthManager } from './claude-auth.manager';
+import { ClaudePtyManager } from './claude-pty.manager';
+import type { ClaudeCreateSessionDto as CreateSessionDto } from './dto/create-session.dto';
+import type { SessionInfo } from './interfaces/claude-session.interface';
+
+export interface ClaudeStatus {
+  version: string;
+  auth: {
+    loggedIn: boolean;
+    authMethod: string;
+    apiProvider: string;
+    email?: string;
+    orgName?: string;
+    subscriptionType?: string;
+  };
+  activeSessions: number;
+  platform: string;
+}
+
+@Injectable()
+export class ClaudeService {
+  constructor(
+    private readonly ptyManager: ClaudePtyManager,
+    private readonly authManager: ClaudeAuthManager,
+  ) {}
+
+  createSession(dto: CreateSessionDto): SessionInfo {
+    return this.ptyManager.createSession(dto.workingDirectory, dto.model, dto.reasoning);
+  }
+
+  terminateSession(sessionId: string): void {
+    this.ptyManager.terminateSession(sessionId);
+  }
+
+  sendMessage(sessionId: string, message: string): void {
+    this.ptyManager.sendMessage(sessionId, message);
+  }
+
+  getSession(sessionId: string): SessionInfo {
+    return this.ptyManager.getSessionInfo(sessionId);
+  }
+
+  listSessions(): SessionInfo[] {
+    return this.ptyManager.listSessions();
+  }
+
+  async getStatus(): Promise<ClaudeStatus> {
+    let version = 'unknown';
+    try {
+      version = execSync('claude --version', { encoding: 'utf8', timeout: 3000 }).trim();
+    } catch {}
+
+    const auth = await this.authManager.getAuthStatus();
+
+    return {
+      version,
+      auth,
+      activeSessions: this.ptyManager.listSessions().length,
+      platform: `${os.platform()} ${os.arch()}`,
+    };
+  }
+}

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

@@ -0,0 +1,24 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsObject, IsOptional, IsString } from 'class-validator';
+
+export class ClaudeCreateSessionDto {
+  @ApiPropertyOptional({ example: '/Users/me/my-project', description: '세션 작업 디렉토리' })
+  @IsOptional()
+  @IsString()
+  workingDirectory?: string;
+
+  @ApiPropertyOptional({ example: 'sonnet', description: 'Claude CLI 모델명 또는 별칭' })
+  @IsOptional()
+  @IsString()
+  model?: string;
+
+  @ApiPropertyOptional({ example: 'high', description: 'Claude reasoning effort' })
+  @IsOptional()
+  @IsString()
+  reasoning?: string;
+
+  @ApiPropertyOptional({ example: { NODE_ENV: 'development' }, description: '추가 환경 변수' })
+  @IsOptional()
+  @IsObject()
+  env?: Record<string, string>;
+}

package/apps/server/src/modules/agents/claude/dto/resize-session.dto.ts

@@ -0,0 +1,13 @@
+import { IsInt, Max, Min } from 'class-validator';
+
+export class ResizeSessionDto {
+  @IsInt()
+  @Min(10)
+  @Max(500)
+  cols!: number;
+
+  @IsInt()
+  @Min(5)
+  @Max(200)
+  rows!: number;
+}

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

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

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

@@ -0,0 +1,26 @@
+export type SessionStatus = 'idle' | 'processing' | 'terminated';
+
+export interface ClaudeSession {
+  id: string;
+  /** Claude CLI가 발급한 session_id — --resume에 사용 */
+  claudeSessionId: string | null;
+  status: SessionStatus;
+  workingDirectory: string;
+  model: string | null;
+  reasoning: string | null;
+  createdAt: Date;
+  lastActivity: Date;
+  /** 첫 메시지 전송 전까지 false — DB에 아직 적재되지 않은 상태 */
+  persisted: boolean;
+}
+
+export interface SessionInfo {
+  id: string;
+  claudeSessionId: string | null;
+  status: SessionStatus;
+  workingDirectory: string;
+  model: string | null;
+  reasoning: string | null;
+  createdAt: Date;
+  lastActivity: Date;
+}

package/apps/server/src/modules/agents/claude/interfaces/pty-event.interface.ts

@@ -0,0 +1,10 @@
+export interface PtyOutputEvent {
+  sessionId: string;
+  data: string;
+  timestamp: Date;
+}
+
+export interface PtyExitEvent {
+  sessionId: string;
+  exitCode: number;
+}

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

@@ -0,0 +1,61 @@
+/** Claude CLI --output-format stream-json 이벤트 타입 */
+
+export interface TextDeltaEvent {
+  sessionId: string;
+  text: string;
+}
+
+export interface ToolUseEvent {
+  sessionId: string;
+  tool: string;
+  input: Record<string, unknown>;
+}
+
+export interface ResultEvent {
+  sessionId: string;
+  result: string;
+  isError: boolean;
+  durationMs: number;
+  costUsd: number;
+}
+
+export interface SessionExitEvent {
+  sessionId: string;
+  exitCode: number;
+}
+
+// ─── Claude CLI NDJSON raw 타입 ──────────────────────────────────────────────
+
+export interface ClaudeInitEvent {
+  type: 'system';
+  subtype: 'init';
+  session_id: string;
+  model: string;
+}
+
+export interface ClaudeAssistantEvent {
+  type: 'assistant';
+  session_id: string;
+  message: {
+    content: Array<
+      | { type: 'text'; text: string }
+      | { type: 'tool_use'; id: string; name: string; input: Record<string, unknown> }
+    >;
+  };
+}
+
+export interface ClaudeResultEvent {
+  type: 'result';
+  subtype: 'success' | 'error';
+  session_id: string;
+  result: string;
+  is_error: boolean;
+  duration_ms: number;
+  total_cost_usd: number;
+}
+
+export type ClaudeStreamEvent =
+  | ClaudeInitEvent
+  | ClaudeAssistantEvent
+  | ClaudeResultEvent
+  | { type: string };

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

@@ -0,0 +1,107 @@
+import { execFileSync } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import { Injectable, Logger } from '@nestjs/common';
+import * as pty from 'node-pty';
+
+const IS_WIN = process.platform === 'win32';
+
+export interface CodexAuthStatus {
+  installed: boolean;
+  loggedIn: boolean;
+}
+
+const KEY_PATH = path.join(os.homedir(), '.ji', 'codex-key');
+const ANSI_STRIP = /\x1b\[[0-9;]*[a-zA-Z]/g;
+
+@Injectable()
+export class CodexAuthManager {
+  private readonly logger = new Logger(CodexAuthManager.name);
+  private readonly loginProcesses = new Map<string, pty.IPty>();
+
+  getAuthStatus(): CodexAuthStatus {
+    const installed = this.isInstalled();
+    if (!installed) return { installed: false, loggedIn: false };
+
+    const loggedIn = this.isLoggedInViaDevice() || !!(this.readStoredApiKey() || process.env.OPENAI_API_KEY);
+    return { installed, loggedIn };
+  }
+
+  saveApiKey(apiKey: string): void {
+    const dir = path.dirname(KEY_PATH);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(KEY_PATH, apiKey, { mode: 0o600 });
+    this.logger.log('Saved Codex API key');
+  }
+
+  startLogin(
+    clientId: string,
+    onOutput: (text: string) => void,
+    onDone: (success: boolean) => void,
+  ): void {
+    this.cancelLogin(clientId);
+
+    const proc = pty.spawn(IS_WIN ? 'codex.cmd' : 'codex', ['login', '--device-auth'], {
+      name: 'xterm-256color',
+      cols: 120,
+      rows: 30,
+      env: process.env as Record<string, string>,
+    });
+
+    this.loginProcesses.set(clientId, proc);
+    this.logger.log(`Started Codex device login for client ${clientId} (pid: ${proc.pid})`);
+
+    proc.onData((data) => onOutput(data.replace(ANSI_STRIP, '')));
+
+    proc.onExit(({ exitCode }) => {
+      this.loginProcesses.delete(clientId);
+      this.logger.log(`Codex login for ${clientId} exited with code ${exitCode}`);
+      onDone(exitCode === 0);
+    });
+  }
+
+  cancelLogin(clientId: string): void {
+    const proc = this.loginProcesses.get(clientId);
+    if (proc) {
+      try { proc.kill(); } catch { /* ignore */ }
+      this.loginProcesses.delete(clientId);
+    }
+  }
+
+  getEnvForCodex(): NodeJS.ProcessEnv {
+    const apiKey = this.readStoredApiKey() ?? process.env.OPENAI_API_KEY;
+    return apiKey ? { ...process.env, OPENAI_API_KEY: apiKey } : process.env;
+  }
+
+  private isInstalled(): boolean {
+    try {
+      execFileSync('codex', ['--version'], { stdio: 'ignore', shell: true });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private isLoggedInViaDevice(): boolean {
+    try {
+      execFileSync('codex', ['login', 'status'], {
+        timeout: 5000,
+        stdio: 'ignore',
+        shell: true,
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private readStoredApiKey(): string | null {
+    try {
+      return fs.readFileSync(KEY_PATH, 'utf8').trim() || null;
+    } catch {
+      return null;
+    }
+  }
+}

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

@@ -0,0 +1,357 @@
+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;
+  }
+}