@jcjeon/integration-cli 0.2.0

package/apps/server/src/database/entities/agent-session.entity.ts

@@ -0,0 +1,29 @@
+import { Column, CreateDateColumn, Entity, PrimaryColumn, UpdateDateColumn } from 'typeorm';
+
+/** Claude CLI 프로세스 세션 추적용 엔티티 (내부 사용) */
+@Entity('agent_sessions')
+export class AgentSessionEntity {
+  @PrimaryColumn({ type: 'text' })
+  id!: string;
+
+  @Column({ type: 'text', nullable: true })
+  claudeSessionId!: string | null;
+
+  @Column({ type: 'text', default: 'idle' })
+  status!: string;
+
+  @Column({ type: 'text' })
+  workingDirectory!: string;
+
+  @Column({ type: 'text', nullable: true })
+  model!: string | null;
+
+  @Column({ type: 'text', nullable: true })
+  reasoning!: string | null;
+
+  @CreateDateColumn()
+  createdAt!: Date;
+
+  @UpdateDateColumn()
+  lastActivity!: Date;
+}

package/apps/server/src/database/entities/conversation.entity.ts

@@ -0,0 +1,41 @@
+import { Column, CreateDateColumn, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+import { AgentModel, ConversationType } from '../../modules/conversations/enums/conversation.enum';
+
+@Entity('conversations')
+export class ConversationEntity {
+  /** 대화 고유 ID (UUID, PK) */
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  /** 세션 FK (sessions.session_id) */
+  @Column({ type: 'text', name: 'session_id' })
+  sessionId!: string;
+
+  /** 프롬프트 ID — user_message / agent_message 1:1 매핑 키 */
+  @Column({ type: 'text', name: 'prompt_id' })
+  promptId!: string;
+
+  /** 태스크 에이전트 ID (task_agents.id) — 태스크 실행 시에만 존재 */
+  @Column({ type: 'integer', name: 'agent_id', nullable: true })
+  agentId!: number | null;
+
+  /** 실행 버전 ID (task_runs.id) — rerun 버전 구분용 */
+  @Column({ type: 'integer', name: 'run_id', nullable: true })
+  runId!: number | null;
+
+  /** 메시지 내용 */
+  @Column({ type: 'text' })
+  content!: string;
+
+  /** 에이전트 모델 (claude | chatgpt | gemini | opencode | grok) */
+  @Column({ type: 'simple-enum', enum: AgentModel, name: 'agent_model' })
+  agentModel!: AgentModel;
+
+  /** 메시지 타입 (user_message | agent_message) */
+  @Column({ type: 'simple-enum', enum: ConversationType })
+  type!: ConversationType;
+
+  @CreateDateColumn({ name: 'created_at' })
+  createdAt!: Date;
+}

package/apps/server/src/database/entities/session.entity.ts

@@ -0,0 +1,16 @@
+import { Column, CreateDateColumn, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity('sessions')
+export class SessionEntity {
+  @PrimaryGeneratedColumn('uuid', { name: 'session_id' })
+  sessionId!: string;
+
+  @Column({ type: 'text' })
+  title!: string;
+
+  @Column({ type: 'text', default: 'claude' })
+  agentType!: string;
+
+  @CreateDateColumn({ name: 'created_at' })
+  createdAt!: Date;
+}

package/apps/server/src/database/entities/task-agent-run.entity.ts

@@ -0,0 +1,40 @@
+import { Column, CreateDateColumn, Entity, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';
+
+import { TaskAgentEntity } from './task-agent.entity';
+import { TaskRunEntity } from './task-run.entity';
+
+@Entity('task_agent_runs')
+export class TaskAgentRunEntity {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column('integer')
+  runId!: number;
+
+  @Column('integer')
+  agentId!: number;
+
+  @Column('text', { default: 'pending' })
+  status!: string;
+
+  @Column('text', { nullable: true })
+  worktreePath!: string | null;
+
+  @Column('text', { nullable: true })
+  startCommitHash!: string | null;
+
+  @Column('real', { nullable: true })
+  durationMs!: number | null;
+
+  @Column('real', { nullable: true })
+  costUsd!: number | null;
+
+  @CreateDateColumn()
+  createdAt!: Date;
+
+  @ManyToOne(() => TaskRunEntity, (r) => r.agentRuns, { onDelete: 'CASCADE' })
+  run!: TaskRunEntity;
+
+  @ManyToOne(() => TaskAgentEntity, { onDelete: 'CASCADE' })
+  agent!: TaskAgentEntity;
+}

package/apps/server/src/database/entities/task-agent.entity.ts

@@ -0,0 +1,42 @@
+import { Column, CreateDateColumn, Entity, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';
+
+import { TaskEntity } from './task.entity';
+
+export type AgentRole = 'frontend' | 'backend' | 'doc' | 'operation' | 'other';
+export type AgentType = 'claude' | 'gemini' | 'codex' | 'opencode';
+
+@Entity('task_agents')
+export class TaskAgentEntity {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column('text')
+  taskId!: string;
+
+  @ManyToOne(() => TaskEntity, (t) => t.agents, { onDelete: 'CASCADE' })
+  task!: TaskEntity;
+
+  @Column('text', { default: 'claude' })
+  agentType!: AgentType;
+
+  @Column('text')
+  role!: AgentRole;
+
+  @Column('text', { nullable: true })
+  customRole!: string | null;
+
+  @Column('text', { nullable: true })
+  claudeSessionId!: string | null;
+
+  @Column('text', { nullable: true })
+  worktreePath!: string | null;
+
+  @Column('text', { nullable: true })
+  startCommitHash!: string | null;
+
+  @Column('text', { default: 'pending' })
+  status!: string;
+
+  @CreateDateColumn()
+  createdAt!: Date;
+}

package/apps/server/src/database/entities/task-requirement.entity.ts

@@ -0,0 +1,27 @@
+import { Column, CreateDateColumn, Entity, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';
+
+import { TaskEntity } from './task.entity';
+
+@Entity('task_requirements')
+export class TaskRequirementEntity {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column('text')
+  taskId!: string;
+
+  @ManyToOne(() => TaskEntity, (t) => t.requirements, { onDelete: 'CASCADE' })
+  task!: TaskEntity;
+
+  @Column('text')
+  content!: string;
+
+  @Column('text', { default: 'pending' })
+  status!: string;
+
+  @Column('integer', { default: 0 })
+  orderIndex!: number;
+
+  @CreateDateColumn()
+  createdAt!: Date;
+}

package/apps/server/src/database/entities/task-run.entity.ts

@@ -0,0 +1,41 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+} from 'typeorm';
+
+import { TaskEntity } from './task.entity';
+import { TaskAgentRunEntity } from './task-agent-run.entity';
+
+@Entity('task_runs')
+export class TaskRunEntity {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column('text')
+  taskId!: string;
+
+  @Column('integer')
+  version!: number;
+
+  @Column('text', { nullable: true })
+  supplementNote!: string | null;
+
+  @Column('text', { default: 'pending' })
+  status!: string;
+
+  @CreateDateColumn()
+  startedAt!: Date;
+
+  @Column({ type: 'datetime', nullable: true })
+  completedAt!: Date | null;
+
+  @ManyToOne(() => TaskEntity, { onDelete: 'CASCADE' })
+  task!: TaskEntity;
+
+  @OneToMany(() => TaskAgentRunEntity, (ar) => ar.run, { cascade: true })
+  agentRuns!: TaskAgentRunEntity[];
+}

package/apps/server/src/database/entities/task.entity.ts

@@ -0,0 +1,44 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  OneToMany,
+  PrimaryColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+
+import { TaskAgentEntity } from './task-agent.entity';
+import { TaskRequirementEntity } from './task-requirement.entity';
+
+@Entity('tasks')
+export class TaskEntity {
+  @PrimaryColumn('text')
+  id!: string;
+
+  @Column('text')
+  title!: string;
+
+  @Column('text', { default: 'pending' })
+  status!: string;
+
+  @Column('text', { nullable: true })
+  workingDir!: string | null;
+
+  @Column('text', { nullable: true })
+  claudeSessionId!: string | null;
+
+  @Column('boolean', { default: false })
+  archived!: boolean;
+
+  @CreateDateColumn()
+  createdAt!: Date;
+
+  @UpdateDateColumn()
+  updatedAt!: Date;
+
+  @OneToMany(() => TaskRequirementEntity, (r) => r.task, { cascade: true })
+  requirements!: TaskRequirementEntity[];
+
+  @OneToMany(() => TaskAgentEntity, (a) => a.task, { cascade: true })
+  agents!: TaskAgentEntity[];
+}

package/apps/server/src/main.ts

@@ -0,0 +1,65 @@
+import * as fs from 'fs';
+
+import { ValidationPipe } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+import { IoAdapter } from '@nestjs/platform-socket.io';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+import { apiReference } from '@scalar/nestjs-api-reference';
+
+import { AppModule } from './app.module';
+import { ensureJiDirs, JI_PATHS } from './common/ji-paths';
+
+async function bootstrap() {
+  ensureJiDirs();
+
+  const app = await NestFactory.create(AppModule, {
+    logger: ['log', 'warn', 'error', 'debug'],
+  });
+
+  // 로그를 ~/.ji/logs/server.log 에 추가 기록
+  const logStream = fs.createWriteStream(JI_PATHS.serverLog, { flags: 'a' });
+  const origWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = (chunk: string | Uint8Array, ...args: unknown[]) => {
+    logStream.write(chunk);
+    return (origWrite as (...a: unknown[]) => boolean)(chunk, ...args);
+  };
+
+  app.useGlobalPipes(new ValidationPipe({ transform: true, whitelist: true }));
+  app.useWebSocketAdapter(new IoAdapter(app));
+  app.enableCors();
+
+  // ─── Swagger / OpenAPI ────────────────────────────────────────────────────
+  const config = new DocumentBuilder()
+    .setTitle('Integration CLI API')
+    .setDescription(
+      'Claude Code · Gemini CLI 등 AI 에이전트를 통합 관리하는 REST API.\n\n' +
+        '실시간 출력은 `/tasks` WebSocket 네임스페이스를 통해 수신합니다.',
+    )
+    .setVersion('1.0')
+    .addTag('agents/claude', 'Claude Code 인증·세션 관리')
+    .addTag('agents/gemini', 'Gemini CLI 인증·세션 관리')
+    .addTag('tasks', '비동기 작업 생성·실행·조회')
+    .addTag('sessions', 'DB 저장 세션 조회')
+    .addTag('conversations', '대화 메시지 저장·조회')
+    .build();
+
+  const document = SwaggerModule.createDocument(app, config);
+
+  // Scalar UI — /docs
+  app.use(
+    '/docs',
+    apiReference({
+      spec: { content: document },
+      theme: 'saturn',
+    }),
+  );
+
+  // Raw OpenAPI JSON — /docs-json
+  SwaggerModule.setup('docs-json', app, document, {
+    jsonDocumentUrl: 'docs-json',
+    swaggerUiEnabled: false,
+  });
+
+  await app.listen(process.env.PORT ?? 3001);
+}
+void bootstrap();

package/apps/server/src/modules/agents/agent-model-settings.spec.ts

@@ -0,0 +1,80 @@
+import { EventEmitter } from 'events';
+import { spawn } from 'child_process';
+
+import { ClaudePtyManager } from './claude/claude-pty.manager';
+import { CodexSessionManager } from './codex/codex-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();
+  return proc;
+}
+
+async function flushPromises() {
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
+describe('agent model settings', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  it('passes Claude model and reasoning to the CLI', 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', 'sonnet', 'high');
+
+    manager.sendMessage(session.id, 'hello');
+    await flushPromises();
+
+    expect(spawnMock).toHaveBeenCalledWith(
+      'claude',
+      expect.arrayContaining(['--model', 'sonnet', '--effort', 'high']),
+      expect.objectContaining({ cwd: '/tmp/project' }),
+    );
+  });
+
+  it('passes Codex model and reasoning to the CLI', 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', 'gpt-5.5', 'xhigh');
+
+    manager.sendMessage(session.id, 'hello');
+    await flushPromises();
+
+    expect(spawnMock).toHaveBeenCalledWith(
+      'codex',
+      expect.arrayContaining(['exec', '-m', 'gpt-5.5', '-c', 'model_reasoning_effort="xhigh"']),
+      expect.objectContaining({ cwd: '/tmp/project' }),
+    );
+  });
+});

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

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+
+import { ClaudeModule } from './claude/claude.module';
+import { CodexModule } from './codex/codex.module';
+import { GeminiModule } from './gemini/gemini.module';
+
+@Module({
+  imports: [ClaudeModule, GeminiModule, CodexModule],
+  exports: [ClaudeModule, GeminiModule, CodexModule],
+})
+export class AgentsModule {}

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

@@ -0,0 +1,83 @@
+import { spawn } from 'child_process';
+import type { ChildProcess } from 'child_process';
+
+import { Injectable, Logger } from '@nestjs/common';
+
+export interface AuthStatus {
+  loggedIn: boolean;
+  authMethod: string;
+  apiProvider: string;
+  email?: string;
+  orgName?: string;
+  subscriptionType?: string;
+}
+
+@Injectable()
+export class ClaudeAuthManager {
+  private readonly logger = new Logger(ClaudeAuthManager.name);
+  private readonly loginProcesses = new Map<string, ChildProcess>();
+
+  async getAuthStatus(): Promise<AuthStatus> {
+    return new Promise((resolve) => {
+      const proc = spawn('claude', ['auth', 'status'], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: process.env,
+      });
+
+      let output = '';
+      proc.stdout.on('data', (d: Buffer) => (output += d.toString()));
+      proc.stderr.on('data', (d: Buffer) => (output += d.toString()));
+
+      proc.on('close', () => {
+        try {
+          resolve(JSON.parse(output.trim()) as AuthStatus);
+        } catch {
+          resolve({ loggedIn: false, authMethod: 'unknown', apiProvider: 'firstParty' });
+        }
+      });
+
+      proc.on('error', () => {
+        resolve({ loggedIn: false, authMethod: 'unknown', apiProvider: 'firstParty' });
+      });
+    });
+  }
+
+  startLogin(
+    clientId: string,
+    onOutput: (text: string) => void,
+    onDone: (success: boolean) => void,
+  ): void {
+    this.cancelLogin(clientId);
+
+    const proc = spawn('claude', ['auth', 'login'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+    });
+
+    this.loginProcesses.set(clientId, proc);
+    this.logger.log(`Started login process 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);
+      this.logger.log(`Login process for ${clientId} exited with code ${code}`);
+      onDone(code === 0);
+    });
+
+    proc.on('error', (err) => {
+      this.loginProcesses.delete(clientId);
+      this.logger.error(`Login process 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);
+    }
+  }
+}