@jcjeon/integration-cli 0.2.0

package/packages/cli/src/commands/init.ts

@@ -0,0 +1,209 @@
+import * as os from 'os';
+
+import chalk from 'chalk';
+import ora from 'ora';
+
+import {
+  ensureProjectReady,
+  type InitProjectOptions,
+} from '../utils/project-init';
+import {
+  AGENT_TOOLS,
+  MIN_NODE_MAJOR,
+  findWindowsGitBashPath,
+  getCommandVersion,
+  getNodeMajorVersion,
+  getNpmCommand,
+  getPlatform,
+  installGlobalPackage,
+  isCommandAvailable,
+  type AgentTool,
+  type SupportedPlatform,
+} from '../utils/agent-tools';
+
+export interface RunInitOptions extends InitProjectOptions {
+  skipAgents?: boolean;
+}
+
+export async function runInit(options: RunInitOptions = {}): Promise<void> {
+  const platform = getPlatform();
+  const failures: string[] = [];
+
+  console.log(chalk.bold('\n🚀 jccli init - 프로젝트 초기화\n'));
+  console.log(chalk.gray(`플랫폼: ${platform} (${os.arch()})`));
+  console.log(chalk.gray(`Node.js: ${process.version}\n`));
+
+  if (!validateNodeVersion()) {
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!validateNpm(platform)) {
+    process.exitCode = 1;
+    return;
+  }
+
+  const projectReady = ensureProjectReady(options, platform);
+  if (!projectReady.ok) {
+    process.exitCode = 1;
+    return;
+  }
+
+  if (options.skipAgents) {
+    printProjectOnlySummary(projectReady.projectRoot);
+    return;
+  }
+
+  printWindowsClaudeNotice(platform);
+
+  for (const tool of AGENT_TOOLS) {
+    const ok = ensureToolInstalled(tool, platform);
+    if (!ok) failures.push(tool.name);
+  }
+
+  printSummary(failures, platform, projectReady.projectRoot);
+
+  if (failures.length > 0) {
+    process.exitCode = 1;
+  }
+}
+
+function validateNodeVersion(): boolean {
+  const nodeMajor = getNodeMajorVersion();
+  if (nodeMajor >= MIN_NODE_MAJOR) {
+    console.log(chalk.green(`✓ Node.js ${process.version}`));
+    return true;
+  }
+
+  console.error(
+    chalk.red(`✗ Node.js v${MIN_NODE_MAJOR}+ 이상이 필요합니다. 현재: ${process.version}`),
+  );
+  console.error(chalk.yellow('  https://nodejs.org 에서 최신 Node.js를 설치해 주세요.'));
+  return false;
+}
+
+function validateNpm(platform: SupportedPlatform): boolean {
+  if (!isCommandAvailable('npm', platform)) {
+    console.error(chalk.red('✗ npm이 설치되어 있지 않습니다.'));
+    console.error(chalk.yellow('  Node.js 재설치 또는 npm을 먼저 설치해 주세요.'));
+    return false;
+  }
+
+  const npmVersion = getCommandVersion(getNpmCommand(platform), platform) ?? 'unknown';
+  console.log(chalk.green(`✓ npm v${npmVersion}\n`));
+  return true;
+}
+
+function printWindowsClaudeNotice(platform: SupportedPlatform): void {
+  if (platform !== 'windows') return;
+
+  const gitBashPath = findWindowsGitBashPath();
+  if (gitBashPath) {
+    console.log(chalk.gray(`Claude Code Git Bash 감지: ${gitBashPath}\n`));
+    return;
+  }
+
+  console.log(chalk.yellow('Claude Code는 Windows 네이티브 실행 시 Git for Windows가 필요할 수 있습니다.'));
+  console.log(chalk.gray('  설치 후에도 claude 실행이 실패하면 Git for Windows를 설치하거나'));
+  console.log(chalk.gray('  CLAUDE_CODE_GIT_BASH_PATH 환경 변수를 bash.exe 경로로 설정해 주세요.\n'));
+}
+
+function ensureToolInstalled(
+  tool: AgentTool,
+  platform: SupportedPlatform,
+): boolean {
+  console.log(chalk.bold(`[ ${tool.name} ]`));
+
+  if (isCommandAvailable(tool.command, platform)) {
+    const version = getCommandVersion(tool.command, platform) ?? 'version unknown';
+    console.log(chalk.green(`✓ 이미 설치됨: ${version}\n`));
+    return true;
+  }
+
+  console.log(chalk.yellow(`  미설치 상태입니다. ${tool.packageName} 설치를 시작합니다.`));
+
+  const spinner = ora({
+    text: `${tool.packageName} 전역 설치 중...`,
+    color: 'cyan',
+  }).start();
+  const result = installGlobalPackage(tool.packageName, platform);
+
+  if (!result.ok) {
+    spinner.fail('설치 실패');
+    printInstallError(result.stderr, result.error, tool, platform);
+    return false;
+  }
+
+  spinner.succeed('설치 완료');
+
+  const verifySpinner = ora('설치 확인 중...').start();
+  if (!isCommandAvailable(tool.command, platform)) {
+    verifySpinner.fail(`${tool.command} 명령을 찾을 수 없습니다.`);
+    console.log(chalk.yellow('  새 터미널을 열거나 PATH 설정을 확인해 주세요.\n'));
+    return false;
+  }
+
+  const version = getCommandVersion(tool.command, platform) ?? 'version unknown';
+  verifySpinner.succeed(`${tool.name} 설치 확인: ${version}`);
+  console.log();
+  return true;
+}
+
+function printInstallError(
+  stderr: string,
+  error: string | undefined,
+  tool: AgentTool,
+  platform: SupportedPlatform,
+): void {
+  console.error(chalk.red('\n설치 중 오류가 발생했습니다:'));
+  if (stderr) console.error(chalk.red(stderr));
+  if (error) console.error(chalk.red(error));
+
+  console.error(chalk.yellow('\n수동 설치 명령:'));
+  console.error(chalk.gray(`  npm install -g ${tool.packageName}`));
+
+  if (platform === 'windows' && tool.requiresWindowsGitBash) {
+    console.error(chalk.gray('  Claude Code 실행에는 Git for Windows 또는 WSL이 필요할 수 있습니다.'));
+  }
+
+  if (platform !== 'windows') {
+    console.error(chalk.gray('  권한 오류가 나면 npm global prefix 또는 Node 설치 방식을 확인해 주세요.'));
+  }
+
+  console.log();
+}
+
+function printProjectOnlySummary(projectRoot: string): void {
+  console.log(chalk.bold.green('프로젝트 초기화가 완료되었습니다.\n'));
+  console.log(chalk.cyan('다음 명령으로 실행할 수 있습니다:'));
+  console.log(chalk.gray(`  cd ${projectRoot}`));
+  console.log(chalk.gray('  jccli start   # http://localhost:3020\n'));
+}
+
+function printSummary(
+  failures: string[],
+  platform: SupportedPlatform,
+  projectRoot: string,
+): void {
+  if (failures.length === 0) {
+    console.log(chalk.bold.green('모든 에이전트 CLI 설치 확인이 완료되었습니다.\n'));
+    console.log(chalk.cyan('다음 명령으로 시작할 수 있습니다:'));
+    console.log(chalk.gray(`  cd ${projectRoot}`));
+    console.log(chalk.gray('  jccli start   # http://localhost:3020'));
+    console.log();
+    console.log(chalk.cyan('에이전트 CLI 직접 실행:'));
+    console.log(chalk.gray('  claude   # Claude Code'));
+    console.log(chalk.gray('  gemini   # Gemini CLI'));
+    console.log(chalk.gray('  codex    # OpenAI Codex\n'));
+
+    if (platform !== 'windows') {
+      console.log(chalk.yellow('명령을 찾을 수 없으면 터미널을 다시 열거나 셸 설정을 다시 로드해 주세요.'));
+      console.log(chalk.gray('  source ~/.zshrc  # 또는 ~/.bashrc\n'));
+    }
+    return;
+  }
+
+  console.log(chalk.bold.yellow('일부 에이전트 CLI 설치 또는 확인에 실패했습니다.'));
+  console.log(chalk.yellow(`실패 항목: ${failures.join(', ')}`));
+  console.log(chalk.gray('위 안내에 따라 수동 설치 또는 PATH 설정을 확인해 주세요.\n'));
+}

package/packages/cli/src/commands/start.ts

@@ -0,0 +1,183 @@
+import { existsSync } from 'fs';
+import * as path from 'path';
+import { spawn, type ChildProcess } from 'child_process';
+
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { findProjectRoot } from '../utils/project-init';
+import { getNpmCommand, getPlatform, type SupportedPlatform } from '../utils/agent-tools';
+import { startProxyServer, waitForPort } from '../utils/proxy';
+
+export interface RunStartOptions {
+  port?: string;
+}
+
+const DEFAULT_PORT = 3020;
+const UPSTREAM_READY_TIMEOUT_MS = 180_000;
+
+export async function runStart(options: RunStartOptions = {}): Promise<void> {
+  const platform = getPlatform();
+
+  const port = parsePort(options.port);
+  if (port === null) {
+    console.error(chalk.red(`✗ 잘못된 포트입니다: ${options.port}`));
+    process.exitCode = 1;
+    return;
+  }
+
+  const projectRoot = findProjectRoot(process.cwd());
+  if (!projectRoot) {
+    console.error(chalk.red('✗ jccli 프로젝트를 찾을 수 없습니다.'));
+    console.error(chalk.gray('  먼저 jccli init 으로 프로젝트를 초기화한 뒤, 프로젝트 폴더 안에서 실행해 주세요.'));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!existsSync(path.join(projectRoot, 'node_modules'))) {
+    console.error(chalk.red('✗ 프로젝트 의존성이 설치되어 있지 않습니다.'));
+    console.error(chalk.gray(`  cd ${projectRoot} && jccli init 을 먼저 실행해 주세요.`));
+    process.exitCode = 1;
+    return;
+  }
+
+  const serverPort = port + 1;
+  const webPort = port + 2;
+
+  console.log(chalk.bold('\n🚀 jccli start\n'));
+  console.log(chalk.gray(`프로젝트: ${projectRoot}`));
+  console.log(chalk.gray(`포트: ${port} (내부: server ${serverPort}, web ${webPort})\n`));
+
+  const children: ChildProcess[] = [];
+  let shuttingDown = false;
+
+  const shutdown = (code: number): void => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    for (const child of children) {
+      try {
+        child.kill();
+      } catch {
+        // 이미 종료된 프로세스는 무시
+      }
+    }
+    process.exit(code);
+  };
+
+  process.on('SIGINT', () => shutdown(0));
+  process.on('SIGTERM', () => shutdown(0));
+
+  try {
+    const proxyServer = await startProxyServer({ port, serverPort, webPort });
+    proxyServer.on('error', (error) => {
+      console.error(chalk.red(`프록시 서버 오류: ${error.message}`));
+    });
+  } catch (error) {
+    console.error(chalk.red(`✗ 포트 ${port} 를 사용할 수 없습니다. 이미 사용 중인지 확인해 주세요.`));
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    process.exitCode = 1;
+    return;
+  }
+
+  const serverChild = spawnWorkspace({
+    label: 'server',
+    color: chalk.magenta,
+    npmArgs: ['run', 'dev', '--workspace', '@ji/server'],
+    env: { PORT: String(serverPort) },
+    projectRoot,
+    platform,
+    onExit: (code) => {
+      if (!shuttingDown) {
+        console.error(chalk.red(`\n[server] 프로세스가 종료되었습니다 (code: ${code ?? 'unknown'})`));
+        shutdown(1);
+      }
+    },
+  });
+  children.push(serverChild);
+
+  const webChild = spawnWorkspace({
+    label: 'web',
+    color: chalk.cyan,
+    npmArgs: ['run', 'dev', '--workspace', '@ji/web', '--', '--port', String(webPort)],
+    env: { NEXT_PUBLIC_SERVER_URL: `http://localhost:${port}` },
+    projectRoot,
+    platform,
+    onExit: (code) => {
+      if (!shuttingDown) {
+        console.error(chalk.red(`\n[web] 프로세스가 종료되었습니다 (code: ${code ?? 'unknown'})`));
+        shutdown(1);
+      }
+    },
+  });
+  children.push(webChild);
+
+  const spinner = ora({ text: '서버와 웹 앱을 시작하는 중...', color: 'cyan' }).start();
+
+  const [serverReady, webReady] = await Promise.all([
+    waitForPort(serverPort, UPSTREAM_READY_TIMEOUT_MS),
+    waitForPort(webPort, UPSTREAM_READY_TIMEOUT_MS),
+  ]);
+
+  if (!serverReady || !webReady) {
+    spinner.fail('시작 시간 초과');
+    const failed = [!serverReady && 'server', !webReady && 'web'].filter(Boolean).join(', ');
+    console.error(chalk.red(`✗ 다음 프로세스가 시간 안에 시작되지 않았습니다: ${failed}`));
+    console.error(chalk.gray('  위에 출력된 로그를 확인해 주세요.'));
+    shutdown(1);
+    return;
+  }
+
+  spinner.succeed('모든 프로세스 시작 완료');
+  console.log();
+  console.log(chalk.bold.green(`  ▶ http://localhost:${port}`));
+  console.log();
+  console.log(chalk.gray('  종료하려면 Ctrl+C 를 누르세요.\n'));
+}
+
+interface SpawnWorkspaceOptions {
+  label: string;
+  color: (text: string) => string;
+  npmArgs: string[];
+  env: NodeJS.ProcessEnv;
+  projectRoot: string;
+  platform: SupportedPlatform;
+  onExit: (code: number | null) => void;
+}
+
+function spawnWorkspace(options: SpawnWorkspaceOptions): ChildProcess {
+  const { label, color, npmArgs, env, projectRoot, platform, onExit } = options;
+
+  const child = spawn(getNpmCommand(platform), npmArgs, {
+    cwd: projectRoot,
+    env: { ...process.env, ...env },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    shell: platform === 'windows',
+    windowsHide: true,
+  });
+
+  const prefix = color(`[${label}]`);
+  const forward = (chunk: Buffer): void => {
+    for (const line of chunk.toString().split('\n')) {
+      if (line.trim().length === 0) continue;
+      console.log(`${prefix} ${line}`);
+    }
+  };
+
+  child.stdout?.on('data', forward);
+  child.stderr?.on('data', forward);
+  child.on('exit', onExit);
+  child.on('error', (error) => {
+    console.error(chalk.red(`[${label}] 실행 오류: ${error.message}`));
+    onExit(null);
+  });
+
+  return child;
+}
+
+function parsePort(value: string | undefined): number | null {
+  if (value === undefined) return DEFAULT_PORT;
+
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65533) return null;
+  return parsed;
+}

package/packages/cli/src/index.ts

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+
+import { runInit } from './commands/init';
+import { runCheck } from './commands/check';
+import { runStart } from './commands/start';
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  // 단축 플래그 처리
+  if (args.includes('--init')) {
+    await runInit(parseInitArgs(args));
+    return;
+  }
+  if (args.includes('--check')) {
+    runCheck();
+    return;
+  }
+
+  const program = new Command();
+
+  program
+    .name('jccli')
+    .description('Claude Code, Gemini CLI, and Codex web integration CLI')
+    .version('0.2.0');
+
+  program
+    .command('init [dir]')
+    .description('프로젝트를 복사/초기화하고 Claude Code, Gemini CLI, Codex 설치 상태를 확인합니다')
+    .option('-f, --force', '비어 있지 않은 대상 폴더에도 프로젝트 파일을 복사합니다')
+    .option('--skip-install', '프로젝트 npm install을 건너뜁니다')
+    .option('--skip-agents', '에이전트 CLI 설치 확인을 건너뜁니다')
+    .action(async (dir: string | undefined, options: { force?: boolean; skipInstall?: boolean; skipAgents?: boolean }) => {
+      await runInit({
+        targetDir: dir,
+        force: options.force,
+        skipInstall: options.skipInstall,
+        skipAgents: options.skipAgents,
+      });
+    });
+
+  program
+    .command('start')
+    .description('서버와 웹 앱을 실행하고 단일 포트(기본 3020)에서 서비스합니다')
+    .option('-p, --port <port>', '서비스 포트', '3020')
+    .action(async (options: { port?: string }) => {
+      await runStart({ port: options.port });
+    });
+
+  program
+    .command('check')
+    .description('Claude Code, Gemini CLI, Codex 설치 상태를 확인합니다')
+    .action(() => {
+      runCheck();
+    });
+
+  program.addHelpText(
+    'after',
+    '\nExamples:\n  jccli --init\n  jccli init\n  jccli init my-app\n  jccli init --skip-install\n  jccli start\n  jccli start --port 4000\n  jccli check\n',
+  );
+
+  if (args.length === 0) {
+    program.outputHelp();
+    return;
+  }
+
+  await program.parseAsync(process.argv);
+}
+
+function parseInitArgs(args: string[]): {
+  targetDir?: string;
+  force?: boolean;
+  skipInstall?: boolean;
+  skipAgents?: boolean;
+} {
+  const initIndex = args[0] === 'init' ? 1 : 0;
+  const positional = args.slice(initIndex).find((arg) => !arg.startsWith('-'));
+
+  return {
+    targetDir: positional,
+    force: args.includes('--force') || args.includes('-f'),
+    skipInstall: args.includes('--skip-install'),
+    skipAgents: args.includes('--skip-agents'),
+  };
+}
+
+main().catch((err: unknown) => {
+  console.error(err);
+  process.exit(1);
+});

package/packages/cli/src/utils/agent-tools.ts

@@ -0,0 +1,201 @@
+import { existsSync } from 'fs';
+import * as os from 'os';
+import { spawnSync } from 'child_process';
+
+export type SupportedPlatform = 'mac' | 'windows' | 'linux';
+
+export interface AgentTool {
+  name: string;
+  command: string;
+  packageName: string;
+  requiresWindowsGitBash?: boolean;
+}
+
+export interface CommandLookup {
+  command: string;
+  path: string;
+}
+
+export interface CommandResult {
+  ok: boolean;
+  stdout: string;
+  stderr: string;
+  error?: string;
+}
+
+export const MIN_NODE_MAJOR = 18;
+
+export const AGENT_TOOLS: AgentTool[] = [
+  {
+    name: 'Claude Code',
+    command: 'claude',
+    packageName: '@anthropic-ai/claude-code',
+    requiresWindowsGitBash: true,
+  },
+  {
+    name: 'Gemini CLI',
+    command: 'gemini',
+    packageName: '@google/gemini-cli',
+  },
+  {
+    name: 'Codex',
+    command: 'codex',
+    packageName: '@openai/codex',
+  },
+];
+
+export function getPlatform(): SupportedPlatform {
+  const platform = os.platform();
+  if (platform === 'darwin') return 'mac';
+  if (platform === 'win32') return 'windows';
+  return 'linux';
+}
+
+export function getNodeMajorVersion(): number {
+  return Number.parseInt(process.versions.node.split('.')[0] ?? '0', 10);
+}
+
+export function getNpmCommand(platform: SupportedPlatform): string {
+  return platform === 'windows' ? 'npm.cmd' : 'npm';
+}
+
+export function resolveCommand(
+  command: string,
+  platform: SupportedPlatform = getPlatform(),
+): CommandLookup | null {
+  try {
+    if (platform === 'windows') {
+      const candidates = command.match(/\.(cmd|exe|bat)$/i)
+        ? [command]
+        : [command, `${command}.cmd`, `${command}.exe`];
+
+      for (const candidate of candidates) {
+        const result = spawnSync('where.exe', [candidate], {
+          encoding: 'utf8',
+          windowsHide: true,
+        });
+        const path = result.stdout
+          ?.split(/\r?\n/)
+          .map((line) => line.trim())
+          .find(Boolean);
+
+        if (result.status === 0 && path) {
+          return { command, path };
+        }
+      }
+
+      return null;
+    }
+
+    const result = spawnSync('sh', ['-lc', `command -v ${quoteForPosixShell(command)}`], {
+      encoding: 'utf8',
+    });
+    const path = result.stdout.trim().split(/\r?\n/)[0];
+
+    if (result.status === 0 && path) {
+      return { command, path };
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function isCommandAvailable(
+  command: string,
+  platform: SupportedPlatform = getPlatform(),
+): boolean {
+  return resolveCommand(command, platform) !== null;
+}
+
+export function runCommand(
+  command: string,
+  args: string[],
+  platform: SupportedPlatform = getPlatform(),
+  timeout = 5000,
+): CommandResult {
+  try {
+    const result = spawnSync(command, args, {
+      encoding: 'utf8',
+      shell: platform === 'windows',
+      timeout,
+      windowsHide: true,
+    });
+
+    return {
+      ok: result.status === 0 && !result.error,
+      stdout: result.stdout?.trim() ?? '',
+      stderr: result.stderr?.trim() ?? '',
+      error: result.error?.message,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      stdout: '',
+      stderr: '',
+      error: error instanceof Error ? error.message : 'Unknown command error',
+    };
+  }
+}
+
+export function getCommandVersion(
+  command: string,
+  platform: SupportedPlatform = getPlatform(),
+): string | null {
+  const result = runCommand(command, ['--version'], platform);
+  if (!result.ok) return null;
+
+  return [result.stdout, result.stderr].filter(Boolean).join('\n').trim() || null;
+}
+
+export function installGlobalPackage(
+  packageName: string,
+  platform: SupportedPlatform = getPlatform(),
+): CommandResult {
+  try {
+    const result = spawnSync(getNpmCommand(platform), ['install', '-g', packageName], {
+      stdio: ['inherit', 'pipe', 'pipe'],
+      encoding: 'utf8',
+      shell: platform === 'windows',
+      windowsHide: true,
+    });
+
+    return {
+      ok: result.status === 0 && !result.error,
+      stdout: result.stdout?.trim() ?? '',
+      stderr: result.stderr?.trim() ?? '',
+      error: result.error?.message,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      stdout: '',
+      stderr: '',
+      error: error instanceof Error ? error.message : 'Unknown npm install error',
+    };
+  }
+}
+
+export function findWindowsGitBashPath(): string | null {
+  if (getPlatform() !== 'windows') return null;
+
+  const fromPath = resolveCommand('bash', 'windows');
+  if (fromPath) return fromPath.path;
+
+  const candidates = [
+    process.env.CLAUDE_CODE_GIT_BASH_PATH,
+    'C:\\Program Files\\Git\\bin\\bash.exe',
+    'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
+  ].filter((value): value is string => Boolean(value));
+
+  try {
+    return candidates.find((candidate) => existsSync(candidate)) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function quoteForPosixShell(value: string): string {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}