@jcjeon/integration-cli 0.2.0

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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,97 @@
+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

@@ -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 { 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

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -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/gemini/gemini-auth.manager.ts

@@ -0,0 +1,157 @@
+import { execFileSync, spawn } from 'child_process';
+import type { ChildProcess } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import { JI_PATHS } from '../../../common/ji-paths';
+import { Injectable, Logger } from '@nestjs/common';
+
+const IS_WIN = process.platform === 'win32';
+
+export type GeminiAuthType = 'api-key' | 'gca';
+
+export interface GeminiAuthStatus {
+  loggedIn: boolean;
+  authMethod: GeminiAuthType | 'unknown';
+  installed: boolean;
+}
+
+interface GeminiSettings {
+  selectedAuthType?: GeminiAuthType | string;
+  [key: string]: unknown;
+}
+
+const SETTINGS_PATH = JI_PATHS.agents.gemini.settings;
+const API_KEY_PATH  = JI_PATHS.agents.gemini.apiKey;
+const GCA_CREDS_PATH = path.join(
+  os.homedir(),
+  '.config',
+  'gcloud',
+  'application_default_credentials.json',
+);
+
+@Injectable()
+export class GeminiAuthManager {
+  private readonly logger = new Logger(GeminiAuthManager.name);
+  private readonly loginProcesses = new Map<string, ChildProcess>();
+
+  // ─── Status ────────────────────────────────────────────────────────────────
+
+  async getAuthStatus(): Promise<GeminiAuthStatus> {
+    if (!this.isInstalled()) {
+      return { loggedIn: false, authMethod: 'unknown', installed: false };
+    }
+
+    const settings = this.readSettings();
+    const authType = settings?.selectedAuthType as GeminiAuthType | undefined;
+
+    if (authType === 'api-key') {
+      const hasKey = !!(this.readStoredApiKey() || process.env.GEMINI_API_KEY);
+      return { loggedIn: hasKey, authMethod: 'api-key', installed: true };
+    }
+
+    if (authType === 'gca') {
+      const hasGca = fs.existsSync(GCA_CREDS_PATH);
+      return { loggedIn: hasGca, authMethod: 'gca', installed: true };
+    }
+
+    return { loggedIn: false, authMethod: 'unknown', installed: true };
+  }
+
+  // ─── API Key ───────────────────────────────────────────────────────────────
+
+  saveApiKey(apiKey: string): void {
+    this.ensureGeminiDir();
+    this.writeSettings({ selectedAuthType: 'api-key' });
+    fs.writeFileSync(API_KEY_PATH, apiKey, { mode: 0o600 });
+    this.logger.log('Saved Gemini API key config');
+  }
+
+  getEnvForGemini(): NodeJS.ProcessEnv {
+    const apiKey = this.readStoredApiKey() ?? process.env.GEMINI_API_KEY;
+    return apiKey ? { ...process.env, GEMINI_API_KEY: apiKey } : process.env;
+  }
+
+  // ─── GCA Login (gcloud auth application-default login) ────────────────────
+
+  startGcaLogin(
+    clientId: string,
+    onOutput: (text: string) => void,
+    onDone: (success: boolean) => void,
+  ): void {
+    this.cancelLogin(clientId);
+
+    const proc = spawn(IS_WIN ? 'gcloud.cmd' : 'gcloud', ['auth', 'application-default', 'login'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+    });
+
+    this.loginProcesses.set(clientId, proc);
+    this.logger.log(`Started gcloud auth for client ${clientId} (pid: ${proc.pid})`);
+
+    proc.stdout.on('data', (chunk: Buffer) => onOutput(chunk.toString()));
+    proc.stderr.on('data', (chunk: Buffer) => onOutput(chunk.toString()));
+
+    proc.on('close', (code) => {
+      this.loginProcesses.delete(clientId);
+      const success = code === 0;
+      if (success) this.writeSettings({ selectedAuthType: 'gca' });
+      this.logger.log(`gcloud auth for ${clientId} exited with code ${code}`);
+      onDone(success);
+    });
+
+    proc.on('error', (err) => {
+      this.loginProcesses.delete(clientId);
+      this.logger.error(`gcloud auth error for ${clientId}: ${err.message}`);
+      onDone(false);
+    });
+  }
+
+  cancelLogin(clientId: string): void {
+    const proc = this.loginProcesses.get(clientId);
+    if (proc) {
+      proc.kill();
+      this.loginProcesses.delete(clientId);
+    }
+  }
+
+  // ─── Private helpers ───────────────────────────────────────────────────────
+
+  private isInstalled(): boolean {
+    try {
+      execFileSync('gemini', ['--version'], { stdio: 'ignore', shell: true });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private ensureGeminiDir(): void {
+    if (!fs.existsSync(JI_PATHS.agents.gemini.dir)) {
+      fs.mkdirSync(JI_PATHS.agents.gemini.dir, { recursive: true });
+    }
+  }
+
+  private readSettings(): GeminiSettings | null {
+    try {
+      return JSON.parse(fs.readFileSync(SETTINGS_PATH, 'utf8')) as GeminiSettings;
+    } catch {
+      return null;
+    }
+  }
+
+  private writeSettings(patch: Partial<GeminiSettings>): void {
+    this.ensureGeminiDir();
+    const current = this.readSettings() ?? {};
+    fs.writeFileSync(SETTINGS_PATH, JSON.stringify({ ...current, ...patch }, null, 2));
+  }
+
+  private readStoredApiKey(): string | null {
+    try {
+      return fs.readFileSync(API_KEY_PATH, 'utf8').trim() || null;
+    } catch {
+      return null;
+    }
+  }
+}

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

@@ -0,0 +1,287 @@
+import { execSync, spawn, type ChildProcess } from 'child_process';
+import { EventEmitter } from 'events';
+import * as fs from 'fs';
+
+const IS_WIN = process.platform === 'win32';
+import * as path from 'path';
+
+import { Injectable, Logger, NotFoundException, OnModuleDestroy, OnModuleInit } 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 { GeminiAuthManager } from './gemini-auth.manager';
+import type { GeminiSession, SessionInfo } from './interfaces/gemini-session.interface';
+import type { ResultEvent, SessionExitEvent, TextDeltaEvent } from './interfaces/stream-event.interface';
+
+@Injectable()
+export class GeminiSessionManager extends EventEmitter implements OnModuleInit, OnModuleDestroy {
+  private readonly logger = new Logger(GeminiSessionManager.name);
+  private readonly sessions = new Map<string, GeminiSession>();
+  private readonly processes = new Map<string, ChildProcess>();
+  private geminiBin = 'gemini';
+
+  constructor(
+    @InjectRepository(AgentSessionEntity)
+    private readonly agentSessionRepo: Repository<AgentSessionEntity>,
+    @InjectRepository(SessionEntity)
+    private readonly sessionRepo: Repository<SessionEntity>,
+    private readonly authManager: GeminiAuthManager,
+  ) {
+    super();
+  }
+
+  onModuleInit(): void {
+    this.geminiBin = this.resolveGemini();
+    this.logger.log(`gemini 경로: ${this.geminiBin}`);
+  }
+
+  // ─── 세션 생명주기 ───────────────────────────────────────────────────
+
+  createSession(workingDirectory = process.cwd()): SessionInfo {
+    const id = uuidv4();
+    const now = new Date();
+    const session: GeminiSession = {
+      id,
+      status: 'idle',
+      workingDirectory,
+      createdAt: now,
+      lastActivity: now,
+      persisted: false,
+    };
+    this.sessions.set(id, session);
+
+    this.logger.log(`Created in-memory Gemini session ${id}`);
+    return this.toSessionInfo(session);
+  }
+
+  terminateSession(sessionId: string): void {
+    const session = this.requireSession(sessionId);
+    session.status = 'terminated';
+    this.killProcess(sessionId);
+    this.sessions.delete(sessionId);
+
+    if (session.persisted) {
+      void this.agentSessionRepo.update(sessionId, { status: 'terminated' });
+    }
+
+    this.logger.log(`Terminated Gemini session ${sessionId}`);
+  }
+
+  // ─── 메시지 전송 ─────────────────────────────────────────────────────
+
+  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(`Gemini 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.spawnGemini(existing, message);
+      });
+      return;
+    }
+
+    void this.agentSessionRepo.update(sessionId, { status: 'processing' });
+    this.spawnGemini(existing, message);
+  }
+
+  private async restoreAndSend(sessionId: string, message: string): Promise<void> {
+    const record = await this.agentSessionRepo.findOne({ where: { id: sessionId } });
+    if (!record) {
+      this.emit('text-delta', { sessionId, text: '⚠ 세션을 찾을 수 없습니다.' });
+      this.emit('result', { sessionId, isError: true });
+      return;
+    }
+    const now = new Date();
+    const session: GeminiSession = {
+      id: sessionId,
+      status: 'processing',
+      workingDirectory: record.workingDirectory,
+      createdAt: record.createdAt,
+      lastActivity: now,
+      persisted: true,
+    };
+    this.sessions.set(sessionId, session);
+    this.logger.log(`Restored Gemini session ${sessionId} (cwd: ${record.workingDirectory})`);
+    void this.agentSessionRepo.update(sessionId, { status: 'processing' });
+    this.spawnGemini(session, message);
+  }
+
+  // ─── 조회 ────────────────────────────────────────────────────────────
+
+  getSessionInfo(sessionId: string): SessionInfo {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new NotFoundException(`Gemini session ${sessionId} not found`);
+    return this.toSessionInfo(session);
+  }
+
+  listSessions(): SessionInfo[] {
+    return [...this.sessions.values()].map((s) => this.toSessionInfo(s));
+  }
+
+  // ─── 정리 ────────────────────────────────────────────────────────────
+
+  onModuleDestroy(): void {
+    for (const sessionId of this.processes.keys()) {
+      this.killProcess(sessionId);
+    }
+    for (const session of this.sessions.values()) {
+      session.status = 'terminated';
+    }
+    this.sessions.clear();
+    this.logger.log('All Gemini sessions cleared');
+  }
+
+  // ─── Private ─────────────────────────────────────────────────────────
+
+  private async persistSession(session: GeminiSession): Promise<void> {
+    const title = path.basename(session.workingDirectory) || session.workingDirectory;
+    await Promise.all([
+      this.agentSessionRepo.save({
+        id: session.id,
+        claudeSessionId: null,
+        status: 'processing',
+        workingDirectory: session.workingDirectory,
+      }),
+      this.sessionRepo.save({ sessionId: session.id, title, agentType: 'gemini' }),
+    ]);
+    session.persisted = true;
+    this.logger.log(`Persisted Gemini session ${session.id} (${title})`);
+  }
+
+  private spawnGemini(session: GeminiSession, message: string): void {
+    const sessionId = session.id;
+
+    this.logger.log(`[${sessionId}] spawning: ${this.geminiBin} -y -p <message>`);
+
+    const proc = spawn(this.geminiBin, ['-y', '-p', message], {
+      cwd: session.workingDirectory,
+      env: this.authManager.getEnvForGemini(),
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    this.processes.set(sessionId, proc);
+
+    // Gemini CLI는 stdout/stderr 모두에 출력 — 두 스트림 합산 캡처
+    // ANSI 이스케이프 시퀀스(색상, 커서 이동 등) 전체 제거
+    const handleChunk = (chunk: Buffer): void => {
+      const raw = chunk.toString();
+      const text = raw
+        .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '')  // CSI 시퀀스
+        .replace(/\x1b\][^\x07]*\x07/g, '')         // OSC 시퀀스
+        .replace(/\x1b[()][AB]/g, '')                // charset 지정
+        .replace(/\r/g, '');
+      if (!text.trim()) return;
+      const event: TextDeltaEvent = { sessionId, text };
+      this.emit('text-delta', event);
+    };
+
+    proc.stdout.on('data', handleChunk);
+    proc.stderr.on('data', handleChunk);
+
+    proc.on('close', (exitCode) => {
+      this.processes.delete(sessionId);
+      const exitEvent: SessionExitEvent = { sessionId, exitCode: exitCode ?? -1 };
+
+      if (session.status === 'terminated' || !this.sessions.has(sessionId)) {
+        this.emit('exit', exitEvent);
+        return;
+      }
+
+      this.logger.log(`[${sessionId}] gemini exited with code ${exitCode}`);
+      session.status = 'idle';
+      void this.agentSessionRepo.update(sessionId, { status: 'idle' });
+
+      const resultEvent: ResultEvent = { sessionId, isError: (exitCode ?? 0) !== 0 };
+      this.emit('result', resultEvent);
+
+      this.emit('exit', exitEvent);
+    });
+
+    proc.on('error', (err) => {
+      this.processes.delete(sessionId);
+      if (session.status === 'terminated' || !this.sessions.has(sessionId)) {
+        return;
+      }
+
+      this.logger.error(`[${sessionId}] spawn error: ${err.message}`);
+      session.status = 'idle';
+      void this.agentSessionRepo.update(sessionId, { status: 'idle' });
+      // 에러도 텍스트로 전달해서 UI에 표시
+      this.emit('text-delta', { sessionId, text: `\n⚠ 실행 오류: ${err.message}\n` } as TextDeltaEvent);
+      this.emit('result', { sessionId, isError: true } as ResultEvent);
+    });
+  }
+
+  private resolveGemini(): string {
+    const whichCmd = IS_WIN ? 'where gemini' : 'which gemini';
+    const candidates = [
+      (): string => execSync(whichCmd, { encoding: 'utf8', timeout: 2000 }).trim().split(/\r?\n/)[0],
+      (): string => {
+        const home = IS_WIN ? (process.env.USERPROFILE ?? '') : (process.env.HOME ?? '');
+        const p = IS_WIN
+          ? `${home}\\AppData\\Roaming\\npm\\gemini.cmd`
+          : `${home}/.nvm/versions/node/${process.version}/bin/gemini`;
+        if (fs.existsSync(p)) return p;
+        throw new Error('not found');
+      },
+      (): string => {
+        const npmBin = execSync('npm bin -g', { encoding: 'utf8', timeout: 2000 }).trim();
+        const p = IS_WIN ? `${npmBin}\\gemini.cmd` : `${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 IS_WIN ? 'gemini.cmd' : 'gemini';
+  }
+
+  private requireSession(sessionId: string): GeminiSession {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new NotFoundException(`Gemini session ${sessionId} not found`);
+    if (session.status === 'terminated') throw new Error(`Gemini session ${sessionId} is terminated`);
+    return session;
+  }
+
+  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 Gemini session ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  private toSessionInfo(session: GeminiSession): SessionInfo {
+    return {
+      id: session.id,
+      status: session.status,
+      workingDirectory: session.workingDirectory,
+      createdAt: session.createdAt,
+      lastActivity: session.lastActivity,
+    };
+  }
+}