@jcjeon/integration-cli 0.2.0 → 0.2.1

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

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

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

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

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

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