@jcjeon/integration-cli 0.2.0

package/packages/cli/src/utils/project-init.ts

@@ -0,0 +1,252 @@
+import { existsSync, mkdirSync, readdirSync, statSync, copyFileSync } from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { spawnSync } from 'child_process';
+
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { getNpmCommand, type CommandResult, type SupportedPlatform } from './agent-tools';
+
+export interface InitProjectOptions {
+  targetDir?: string;
+  force?: boolean;
+  skipInstall?: boolean;
+}
+
+export interface ProjectReadyResult {
+  ok: boolean;
+  projectRoot: string;
+}
+
+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'),
+];
+
+export function ensureProjectReady(
+  options: InitProjectOptions,
+  platform: SupportedPlatform,
+): ProjectReadyResult {
+  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.green(`✓ 프로젝트 감지: ${cwdProjectRoot}`));
+    }
+
+    ensureRuntimeDirs();
+
+    if (options.skipInstall) {
+      console.log(chalk.yellow('프로젝트 의존성 설치를 건너뜁니다.\n'));
+      return { ok: true, projectRoot: targetRoot };
+    }
+
+    const installOk = ensureDependencies(targetRoot, platform);
+    return { ok: installOk, projectRoot: targetRoot };
+  } catch (error) {
+    console.error(chalk.red('프로젝트 초기화 중 오류가 발생했습니다.'));
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    return { ok: false, projectRoot: process.cwd() };
+  }
+}
+
+function resolveTargetRoot(targetDir: string | undefined, cwdProjectRoot: string | null): string {
+  if (targetDir) {
+    return path.resolve(process.cwd(), targetDir);
+  }
+
+  return cwdProjectRoot ?? process.cwd();
+}
+
+export function findProjectRoot(startDir: string): string | null {
+  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: string): boolean {
+  const packageJsonPath = path.join(dir, 'package.json');
+  if (!existsSync(packageJsonPath)) return false;
+
+  try {
+    const packageJson = require(packageJsonPath) as { workspaces?: string[] };
+    const workspaces = packageJson.workspaces ?? [];
+    return PROJECT_MARKER_WORKSPACES.every((workspace) => workspaces.includes(workspace));
+  } catch {
+    return false;
+  }
+}
+
+function scaffoldProject(targetRoot: string, force: boolean): boolean {
+  const sourceRoot = getTemplateRoot();
+
+  if (!isDirectoryUsableForScaffold(targetRoot, force)) {
+    console.error(chalk.red(`대상 폴더가 비어 있지 않습니다: ${targetRoot}`));
+    console.error(chalk.gray('  빈 폴더에서 실행하거나 jccli init <folder> 를 사용해 주세요.'));
+    console.error(chalk.gray('  기존 파일 위에 복사하려면 --force 옵션을 사용할 수 있습니다.'));
+    return false;
+  }
+
+  mkdirSync(targetRoot, { recursive: true });
+
+  const spinner = ora({
+    text: `프로젝트 파일 복사 중: ${targetRoot}`,
+    color: 'cyan',
+  }).start();
+
+  try {
+    copyDirectory(sourceRoot, targetRoot, sourceRoot);
+    spinner.succeed('프로젝트 파일 복사 완료');
+    return true;
+  } catch (error) {
+    spinner.fail('프로젝트 파일 복사 실패');
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    return false;
+  }
+}
+
+function getTemplateRoot(): string {
+  return path.resolve(__dirname, '..', '..', '..', '..');
+}
+
+function isDirectoryUsableForScaffold(targetRoot: string, force: boolean): boolean {
+  if (!existsSync(targetRoot)) return true;
+  if (!statSync(targetRoot).isDirectory()) return false;
+  if (force) return true;
+
+  return readdirSync(targetRoot).filter((entry) => entry !== '.DS_Store').length === 0;
+}
+
+function copyDirectory(sourceDir: string, targetDir: string, sourceRoot: string): void {
+  mkdirSync(targetDir, { recursive: true });
+
+  for (const entry of 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()) {
+      copyFileSync(sourcePath, targetPath);
+    }
+  }
+}
+
+function shouldSkipCopy(entryName: string, relativePath: string): boolean {
+  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(): void {
+  const home = os.homedir();
+
+  try {
+    for (const dir of RUNTIME_DIRS) {
+      mkdirSync(path.join(home, dir), { recursive: true });
+    }
+    console.log(chalk.green(`✓ 런타임 디렉터리 준비: ${path.join(home, '.ji')}`));
+  } catch (error) {
+    console.error(chalk.red('런타임 디렉터리를 만들 수 없습니다.'));
+    throw error;
+  }
+}
+
+function ensureDependencies(projectRoot: string, platform: SupportedPlatform): boolean {
+  if (existsSync(path.join(projectRoot, 'node_modules'))) {
+    console.log(chalk.green('✓ 프로젝트 의존성 설치 확인: node_modules 감지\n'));
+    return true;
+  }
+
+  const spinner = ora({
+    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.red(result.stderr));
+  if (result.error) console.error(chalk.red(result.error));
+  console.error(chalk.yellow('\n수동 설치 명령:'));
+  console.error(chalk.gray(`  cd ${projectRoot}`));
+  console.error(chalk.gray('  npm install\n'));
+  return false;
+}
+
+function runNpmInstall(projectRoot: string, platform: SupportedPlatform): CommandResult {
+  try {
+    const result = spawnSync(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/src/utils/proxy.ts

@@ -0,0 +1,123 @@
+import * as http from 'http';
+import * as net from 'net';
+
+export interface ProxyServerOptions {
+  port: number;
+  serverPort: number;
+  webPort: number;
+}
+
+// NestJS 컨트롤러/게이트웨이가 사용하는 경로 prefix. 나머지는 모두 Next.js로 보낸다.
+const BACKEND_PREFIXES = [
+  'agents',
+  'tasks',
+  'fs',
+  'harness',
+  'sessions',
+  'conversations',
+  'docs',
+  'docs-json',
+  'socket.io',
+];
+
+function isBackendPath(url: string): boolean {
+  const pathname = url.split('?')[0] ?? '';
+  return BACKEND_PREFIXES.some(
+    (prefix) => pathname === `/${prefix}` || pathname.startsWith(`/${prefix}/`),
+  );
+}
+
+export function startProxyServer(options: ProxyServerOptions): Promise<http.Server> {
+  const { port, serverPort, webPort } = options;
+
+  const resolveTargetPort = (url: string | undefined): number =>
+    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);
+    });
+  });
+}
+
+export function waitForPort(port: number, timeoutMs: number): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+
+  return new Promise((resolve) => {
+    const tryConnect = (): void => {
+      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/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "@ji/typescript-config/base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "target": "ES2022",
+    "declaration": true,
+    "esModuleInterop": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/packages/eslint-config/base.mjs

@@ -0,0 +1,31 @@
+import eslintConfigPrettier from "eslint-config-prettier";
+import eslintPluginPrettier from "eslint-plugin-prettier";
+import importPlugin from "eslint-plugin-import";
+
+/** @type {import('eslint').Linter.Config[]} */
+export const baseConfig = [
+  {
+    plugins: {
+      prettier: eslintPluginPrettier,
+      import: importPlugin,
+    },
+    rules: {
+      "prettier/prettier": "error",
+
+      "import/order": [
+        "error",
+        {
+          groups: ["builtin", "external", "internal", "parent", "sibling", "index"],
+          "newlines-between": "always",
+          alphabetize: { order: "asc", caseInsensitive: true },
+        },
+      ],
+      "import/no-duplicates": "error",
+
+      "prefer-const": "error",
+      "no-var": "error",
+      "no-console": ["warn", { allow: ["warn", "error"] }],
+    },
+  },
+  eslintConfigPrettier,
+];

package/packages/eslint-config/nest.mjs

@@ -0,0 +1,55 @@
+import eslint from "@eslint/js";
+import eslintPluginPrettierRecommended from "eslint-plugin-prettier/recommended";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+import importPlugin from "eslint-plugin-import";
+import eslintConfigPrettier from "eslint-config-prettier";
+
+/** @type {import('typescript-eslint').ConfigArray} */
+export default tseslint.config(
+  {
+    ignores: ["eslint.config.mjs", "dist/**", "node_modules/**"],
+  },
+  eslint.configs.recommended,
+  ...tseslint.configs.recommendedTypeChecked,
+  eslintPluginPrettierRecommended,
+  {
+    plugins: { import: importPlugin },
+    languageOptions: {
+      globals: { ...globals.node, ...globals.jest },
+      sourceType: "commonjs",
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+  },
+  {
+    rules: {
+      "prettier/prettier": ["error", { endOfLine: "auto" }],
+
+      "@typescript-eslint/no-explicit-any": "warn",
+      "@typescript-eslint/no-floating-promises": "error",
+      "@typescript-eslint/no-unsafe-argument": "warn",
+      "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
+      "@typescript-eslint/consistent-type-imports": ["error", { prefer: "type-imports" }],
+      "@typescript-eslint/explicit-function-return-type": "off",
+      "@typescript-eslint/explicit-module-boundary-types": "off",
+
+      "import/order": [
+        "error",
+        {
+          groups: ["builtin", "external", "internal", "parent", "sibling", "index"],
+          "newlines-between": "always",
+          alphabetize: { order: "asc", caseInsensitive: true },
+        },
+      ],
+      "import/no-duplicates": "error",
+
+      "no-console": ["warn", { allow: ["warn", "error", "log"] }],
+      "prefer-const": "error",
+      "no-var": "error",
+    },
+  },
+  eslintConfigPrettier,
+);

package/packages/eslint-config/next.mjs

@@ -0,0 +1,23 @@
+import { defineConfig, globalIgnores } from "eslint/config";
+import nextVitals from "eslint-config-next/core-web-vitals";
+import nextTs from "eslint-config-next/typescript";
+import { baseConfig } from "./base.mjs";
+
+/** @type {import('eslint').Linter.Config[]} */
+export default defineConfig([
+  ...nextVitals,
+  ...nextTs,
+  globalIgnores([".next/**", "out/**", "build/**", "next-env.d.ts", "node_modules/**"]),
+  ...baseConfig,
+  {
+    rules: {
+      "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
+      "@typescript-eslint/no-explicit-any": "warn",
+      "@typescript-eslint/consistent-type-imports": ["error", { prefer: "type-imports" }],
+
+      "react/self-closing-comp": "error",
+      "react/jsx-curly-brace-presence": ["error", { props: "never", children: "never" }],
+      "react/display-name": "off",
+    },
+  },
+]);

package/packages/eslint-config/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@ji/eslint-config",
+  "version": "0.0.1",
+  "private": true,
+  "license": "UNLICENSED",
+  "exports": {
+    "./base": "./base.mjs",
+    "./next": "./next.mjs",
+    "./nest": "./nest.mjs"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.18.0",
+    "@typescript-eslint/eslint-plugin": "^8.59.1",
+    "@typescript-eslint/parser": "^8.59.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "typescript-eslint": "^8.20.0"
+  }
+}

package/packages/typescript-config/base.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictBindCallApply": true,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true
+  }
+}

package/packages/typescript-config/nestjs.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./base.json",
+  "compilerOptions": {
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "resolvePackageJsonExports": true,
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true
+  }
+}

package/packages/typescript-config/nextjs.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./base.json",
+  "compilerOptions": {
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "allowJs": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [{ "name": "next" }],
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true
+  }
+}

package/packages/typescript-config/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@ji/typescript-config",
+  "version": "0.0.1",
+  "private": true,
+  "license": "UNLICENSED",
+  "exports": {
+    "./base.json": "./base.json",
+    "./nextjs.json": "./nextjs.json",
+    "./nestjs.json": "./nestjs.json"
+  }
+}

package/turbo.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://turbo.build/schema.json",
+  "ui": "tui",
+  "tasks": {
+    "build": {
+      "dependsOn": ["^build"],
+      "inputs": ["$TURBO_DEFAULT$", ".env*"],
+      "outputs": [".next/**", "!.next/cache/**", "dist/**"]
+    },
+    "dev": {
+      "cache": false,
+      "persistent": true
+    },
+    "lint": {
+      "dependsOn": ["^build"]
+    },
+    "lint:fix": {
+      "cache": false
+    },
+    "test": {
+      "dependsOn": ["^build"],
+      "outputs": ["coverage/**"]
+    },
+    "clean": {
+      "cache": false
+    }
+  }
+}