@jcjeon/integration-cli 0.2.0

package/packages/cli/dist/utils/project-init.js

@@ -0,0 +1,258 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureProjectReady = ensureProjectReady;
+exports.findProjectRoot = findProjectRoot;
+const fs_1 = require("fs");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const agent_tools_1 = require("./agent-tools");
+const PROJECT_MARKER_WORKSPACES = ['apps/*', 'packages/*'];
+const RUNTIME_DIRS = [
+    '.ji',
+    path.join('.ji', 'logs'),
+    path.join('.ji', 'worktrees'),
+    path.join('.ji', 'harness'),
+    path.join('.ji', 'agents'),
+    path.join('.ji', 'agents', 'gemini'),
+    path.join('.ji', 'agents', 'codex'),
+];
+const COPY_EXCLUDES = new Set([
+    '.git',
+    '.claude',
+    '.turbo',
+    'node_modules',
+    '.next',
+    'out',
+    'coverage',
+    '.env',
+    '.env.local',
+]);
+const COPY_EXCLUDED_SUFFIXES = [
+    path.normalize('apps/server/dist'),
+    path.normalize('apps/web/.next'),
+    path.normalize('apps/web/out'),
+    path.normalize('packages/typescript-config/dist'),
+];
+function ensureProjectReady(options, platform) {
+    try {
+        const cwdProjectRoot = findProjectRoot(process.cwd());
+        const targetRoot = resolveTargetRoot(options.targetDir, cwdProjectRoot);
+        if (!cwdProjectRoot || path.resolve(cwdProjectRoot) !== path.resolve(targetRoot)) {
+            const scaffoldOk = scaffoldProject(targetRoot, Boolean(options.force));
+            if (!scaffoldOk)
+                return { ok: false, projectRoot: targetRoot };
+        }
+        else {
+            console.log(chalk_1.default.green(`✓ 프로젝트 감지: ${cwdProjectRoot}`));
+        }
+        ensureRuntimeDirs();
+        if (options.skipInstall) {
+            console.log(chalk_1.default.yellow('프로젝트 의존성 설치를 건너뜁니다.\n'));
+            return { ok: true, projectRoot: targetRoot };
+        }
+        const installOk = ensureDependencies(targetRoot, platform);
+        return { ok: installOk, projectRoot: targetRoot };
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('프로젝트 초기화 중 오류가 발생했습니다.'));
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+        return { ok: false, projectRoot: process.cwd() };
+    }
+}
+function resolveTargetRoot(targetDir, cwdProjectRoot) {
+    if (targetDir) {
+        return path.resolve(process.cwd(), targetDir);
+    }
+    return cwdProjectRoot ?? process.cwd();
+}
+function findProjectRoot(startDir) {
+    let current = path.resolve(startDir);
+    while (true) {
+        if (isProjectRoot(current))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function isProjectRoot(dir) {
+    const packageJsonPath = path.join(dir, 'package.json');
+    if (!(0, fs_1.existsSync)(packageJsonPath))
+        return false;
+    try {
+        const packageJson = require(packageJsonPath);
+        const workspaces = packageJson.workspaces ?? [];
+        return PROJECT_MARKER_WORKSPACES.every((workspace) => workspaces.includes(workspace));
+    }
+    catch {
+        return false;
+    }
+}
+function scaffoldProject(targetRoot, force) {
+    const sourceRoot = getTemplateRoot();
+    if (!isDirectoryUsableForScaffold(targetRoot, force)) {
+        console.error(chalk_1.default.red(`대상 폴더가 비어 있지 않습니다: ${targetRoot}`));
+        console.error(chalk_1.default.gray('  빈 폴더에서 실행하거나 jccli init <folder> 를 사용해 주세요.'));
+        console.error(chalk_1.default.gray('  기존 파일 위에 복사하려면 --force 옵션을 사용할 수 있습니다.'));
+        return false;
+    }
+    (0, fs_1.mkdirSync)(targetRoot, { recursive: true });
+    const spinner = (0, ora_1.default)({
+        text: `프로젝트 파일 복사 중: ${targetRoot}`,
+        color: 'cyan',
+    }).start();
+    try {
+        copyDirectory(sourceRoot, targetRoot, sourceRoot);
+        spinner.succeed('프로젝트 파일 복사 완료');
+        return true;
+    }
+    catch (error) {
+        spinner.fail('프로젝트 파일 복사 실패');
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+        return false;
+    }
+}
+function getTemplateRoot() {
+    return path.resolve(__dirname, '..', '..', '..', '..');
+}
+function isDirectoryUsableForScaffold(targetRoot, force) {
+    if (!(0, fs_1.existsSync)(targetRoot))
+        return true;
+    if (!(0, fs_1.statSync)(targetRoot).isDirectory())
+        return false;
+    if (force)
+        return true;
+    return (0, fs_1.readdirSync)(targetRoot).filter((entry) => entry !== '.DS_Store').length === 0;
+}
+function copyDirectory(sourceDir, targetDir, sourceRoot) {
+    (0, fs_1.mkdirSync)(targetDir, { recursive: true });
+    for (const entry of (0, fs_1.readdirSync)(sourceDir, { withFileTypes: true })) {
+        const sourcePath = path.join(sourceDir, entry.name);
+        const targetPath = path.join(targetDir, entry.name);
+        const relativePath = path.relative(sourceRoot, sourcePath);
+        if (shouldSkipCopy(entry.name, relativePath))
+            continue;
+        if (entry.isDirectory()) {
+            copyDirectory(sourcePath, targetPath, sourceRoot);
+            continue;
+        }
+        if (entry.isFile()) {
+            (0, fs_1.copyFileSync)(sourcePath, targetPath);
+        }
+    }
+}
+function shouldSkipCopy(entryName, relativePath) {
+    if (COPY_EXCLUDES.has(entryName))
+        return true;
+    if (entryName.endsWith('.log'))
+        return true;
+    if (entryName.endsWith('.tsbuildinfo'))
+        return true;
+    if (/^\.env\..*\.local$/.test(entryName))
+        return true;
+    const normalized = path.normalize(relativePath);
+    return COPY_EXCLUDED_SUFFIXES.some((suffix) => normalized === suffix || normalized.startsWith(`${suffix}${path.sep}`));
+}
+function ensureRuntimeDirs() {
+    const home = os.homedir();
+    try {
+        for (const dir of RUNTIME_DIRS) {
+            (0, fs_1.mkdirSync)(path.join(home, dir), { recursive: true });
+        }
+        console.log(chalk_1.default.green(`✓ 런타임 디렉터리 준비: ${path.join(home, '.ji')}`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('런타임 디렉터리를 만들 수 없습니다.'));
+        throw error;
+    }
+}
+function ensureDependencies(projectRoot, platform) {
+    if ((0, fs_1.existsSync)(path.join(projectRoot, 'node_modules'))) {
+        console.log(chalk_1.default.green('✓ 프로젝트 의존성 설치 확인: node_modules 감지\n'));
+        return true;
+    }
+    const spinner = (0, ora_1.default)({
+        text: '프로젝트 의존성 설치 중...',
+        color: 'cyan',
+    }).start();
+    const result = runNpmInstall(projectRoot, platform);
+    if (result.ok) {
+        spinner.succeed('프로젝트 의존성 설치 완료');
+        console.log();
+        return true;
+    }
+    spinner.fail('프로젝트 의존성 설치 실패');
+    if (result.stderr)
+        console.error(chalk_1.default.red(result.stderr));
+    if (result.error)
+        console.error(chalk_1.default.red(result.error));
+    console.error(chalk_1.default.yellow('\n수동 설치 명령:'));
+    console.error(chalk_1.default.gray(`  cd ${projectRoot}`));
+    console.error(chalk_1.default.gray('  npm install\n'));
+    return false;
+}
+function runNpmInstall(projectRoot, platform) {
+    try {
+        const result = (0, child_process_1.spawnSync)((0, agent_tools_1.getNpmCommand)(platform), ['install'], {
+            cwd: projectRoot,
+            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',
+        };
+    }
+}

package/packages/cli/dist/utils/proxy.d.ts

@@ -0,0 +1,8 @@
+import * as http from 'http';
+export interface ProxyServerOptions {
+    port: number;
+    serverPort: number;
+    webPort: number;
+}
+export declare function startProxyServer(options: ProxyServerOptions): Promise<http.Server>;
+export declare function waitForPort(port: number, timeoutMs: number): Promise<boolean>;

package/packages/cli/dist/utils/proxy.js

@@ -0,0 +1,138 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startProxyServer = startProxyServer;
+exports.waitForPort = waitForPort;
+const http = __importStar(require("http"));
+const net = __importStar(require("net"));
+// NestJS 컨트롤러/게이트웨이가 사용하는 경로 prefix. 나머지는 모두 Next.js로 보낸다.
+const BACKEND_PREFIXES = [
+    'agents',
+    'tasks',
+    'fs',
+    'harness',
+    'sessions',
+    'conversations',
+    'docs',
+    'docs-json',
+    'socket.io',
+];
+function isBackendPath(url) {
+    const pathname = url.split('?')[0] ?? '';
+    return BACKEND_PREFIXES.some((prefix) => pathname === `/${prefix}` || pathname.startsWith(`/${prefix}/`));
+}
+function startProxyServer(options) {
+    const { port, serverPort, webPort } = options;
+    const resolveTargetPort = (url) => isBackendPath(url ?? '/') ? serverPort : webPort;
+    const server = http.createServer((req, res) => {
+        try {
+            const targetPort = resolveTargetPort(req.url);
+            const proxyReq = http.request({
+                host: '127.0.0.1',
+                port: targetPort,
+                path: req.url,
+                method: req.method,
+                headers: req.headers,
+            }, (proxyRes) => {
+                res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+                proxyRes.pipe(res);
+            });
+            proxyReq.on('error', () => {
+                try {
+                    if (!res.headersSent) {
+                        res.writeHead(502, { 'content-type': 'text/plain; charset=utf-8' });
+                    }
+                    res.end('업스트림 서버가 아직 준비되지 않았습니다. 잠시 후 새로고침해 주세요.');
+                }
+                catch {
+                    res.destroy();
+                }
+            });
+            req.pipe(proxyReq);
+        }
+        catch {
+            res.destroy();
+        }
+    });
+    // WebSocket(socket.io, Next.js HMR) 업그레이드 요청을 원본 헤더 그대로 터널링한다.
+    server.on('upgrade', (req, socket, head) => {
+        try {
+            const targetPort = resolveTargetPort(req.url);
+            const upstream = net.connect(targetPort, '127.0.0.1', () => {
+                const headerLines = [`${req.method} ${req.url} HTTP/1.1`];
+                for (let i = 0; i < req.rawHeaders.length; i += 2) {
+                    headerLines.push(`${req.rawHeaders[i]}: ${req.rawHeaders[i + 1]}`);
+                }
+                upstream.write(`${headerLines.join('\r\n')}\r\n\r\n`);
+                if (head.length > 0)
+                    upstream.write(head);
+                socket.pipe(upstream).pipe(socket);
+            });
+            upstream.on('error', () => socket.destroy());
+            socket.on('error', () => upstream.destroy());
+        }
+        catch {
+            socket.destroy();
+        }
+    });
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(port, () => {
+            server.removeListener('error', reject);
+            resolve(server);
+        });
+    });
+}
+function waitForPort(port, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    return new Promise((resolve) => {
+        const tryConnect = () => {
+            const socket = net.connect(port, '127.0.0.1');
+            socket.once('connect', () => {
+                socket.destroy();
+                resolve(true);
+            });
+            socket.once('error', () => {
+                socket.destroy();
+                if (Date.now() > deadline) {
+                    resolve(false);
+                    return;
+                }
+                setTimeout(tryConnect, 500);
+            });
+        };
+        tryConnect();
+    });
+}

package/packages/cli/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@ji/cli",
+  "version": "0.2.0",
+  "description": "jccli - Claude Code, Gemini CLI, and Codex web integration CLI",
+  "private": true,
+  "bin": {
+    "jccli": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "ora": "^8.2.0"
+  },
+  "devDependencies": {
+    "@ji/typescript-config": "*",
+    "@types/node": "^24.0.0",
+    "typescript": "^5.7.3"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

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

@@ -0,0 +1,77 @@
+import * as os from 'os';
+
+import chalk from 'chalk';
+
+import {
+  AGENT_TOOLS,
+  findWindowsGitBashPath,
+  getCommandVersion,
+  getPlatform,
+  isCommandAvailable,
+  type AgentTool,
+  type SupportedPlatform,
+} from '../utils/agent-tools';
+
+interface ToolStatus {
+  name: string;
+  packageName: string;
+  version: string | null;
+  installed: boolean;
+}
+
+export function runCheck(): void {
+  const platform = getPlatform();
+  const results = AGENT_TOOLS.map((tool) => getToolStatus(tool, platform));
+
+  console.log(chalk.bold('\n🔍 에이전트 CLI 설치 상태 확인\n'));
+  console.log(chalk.gray(`플랫폼: ${platform} (${os.arch()})\n`));
+
+  for (const result of results) {
+    if (result.installed) {
+      console.log(chalk.green(`  ✓ ${result.name.padEnd(14)} ${result.version ?? ''}`));
+      continue;
+    }
+
+    console.log(chalk.red(`  ✗ ${result.name.padEnd(14)} 미설치`));
+    console.log(chalk.gray(`      설치: npm install -g ${result.packageName}`));
+  }
+
+  printWindowsClaudeNotice(platform);
+  printSummary(results);
+}
+
+function getToolStatus(tool: AgentTool, platform: SupportedPlatform): ToolStatus {
+  const installed = isCommandAvailable(tool.command, platform);
+
+  return {
+    name: tool.name,
+    packageName: tool.packageName,
+    installed,
+    version: installed ? getCommandVersion(tool.command, platform) : null,
+  };
+}
+
+function printWindowsClaudeNotice(platform: SupportedPlatform): void {
+  if (platform !== 'windows') return;
+
+  const gitBashPath = findWindowsGitBashPath();
+  if (gitBashPath) {
+    console.log(chalk.gray(`\nClaude Code Git Bash 감지: ${gitBashPath}`));
+    return;
+  }
+
+  console.log(chalk.yellow('\nClaude Code 실행에는 Git for Windows 또는 WSL이 필요할 수 있습니다.'));
+}
+
+function printSummary(results: ToolStatus[]): void {
+  const missing = results.filter((result) => !result.installed);
+
+  console.log();
+  if (missing.length === 0) {
+    console.log(chalk.bold.green('모든 도구가 설치되어 있습니다.'));
+  } else {
+    console.log(chalk.yellow(`미설치 도구: ${missing.map((result) => result.name).join(', ')}`));
+    console.log(chalk.gray('  jccli init 으로 한 번에 설치할 수 있습니다.'));
+  }
+  console.log();
+}