@simplysm/sd-cli 13.0.7 → 13.0.10

package/src/sd-cli.ts

@@ -1,330 +1,99 @@
 #!/usr/bin/env node
 
-// side-effect: Map/Array 프로토타입 확장 (getOrCreate 등)
-import "@simplysm/core-common";
-import yargs, { type Argv } from "yargs";
-import { hideBin } from "yargs/helpers";
-import { runLint } from "./commands/lint";
-import { runTypecheck } from "./commands/typecheck";
-import { runWatch } from "./commands/watch";
-import { runDev } from "./commands/dev";
-import { runBuild } from "./commands/build";
-import { runPublish } from "./commands/publish";
-import { runReplaceDeps } from "./commands/replace-deps";
-import { runDevice } from "./commands/device";
+/**
+ * CLI Launcher
+ *
+ * .ts 실행 (개발): CPU affinity 적용 후 sd-cli-entry 직접 import
+ * .js 실행 (배포): replaceDeps 실행 후 새 프로세스로 sd-cli-entry spawn
+ */
+
+import { exec, spawn } from "child_process";
+import os from "os";
 import path from "path";
-import fs from "fs";
 import { fileURLToPath } from "url";
-import { EventEmitter } from "node:events";
-import { consola, LogLevels } from "consola";
 
-Error.stackTraceLimit = Infinity;
-EventEmitter.defaultMaxListeners = 100;
+const cliEntryUrl = import.meta.resolve("./sd-cli-entry");
+const cliEntryFilePath = fileURLToPath(cliEntryUrl);
+
+if (path.extname(cliEntryFilePath) === ".ts") {
+  // 개발 모드 (.ts): affinity 적용 후 직접 실행
+  // import만으로는 메인 모듈 감지가 실패하므로 (process.argv[1] ≠ sd-cli-entry)
+  // createCliParser를 명시적으로 호출한다.
+  configureAffinityAndPriority(process.pid);
+  const { createCliParser } = await import(cliEntryUrl);
+  await createCliParser(process.argv.slice(2)).parse();
+} else {
+  // 배포 모드 (.js): 2단계 실행
+
+  // Phase 1: replaceDeps (inline — 설치된 버전으로 복사)
+  try {
+    const { loadSdConfig } = await import("./utils/sd-config.js");
+    const { setupReplaceDeps } = await import("./utils/replace-deps.js");
+    const sdConfig = await loadSdConfig({ cwd: process.cwd(), dev: false, opt: [] });
+    if (sdConfig.replaceDeps != null) {
+      await setupReplaceDeps(process.cwd(), sdConfig.replaceDeps);
+    }
+  } catch {
+    // sd.config.ts 없거나 replaceDeps 미설정 시 스킵
+  }
+
+  // Phase 2: 새 프로세스로 실제 CLI 실행 (모듈 캐시 초기화)
+  const child = spawn(
+    "node",
+    ["--max-old-space-size=8192", "--max-semi-space-size=16", cliEntryFilePath, ...process.argv.slice(2)],
+    { stdio: "inherit" },
+  );
+  child.on("spawn", () => {
+    if (child.pid != null) configureAffinityAndPriority(child.pid);
+  });
+  child.on("exit", (code) => {
+    process.exitCode = code ?? 0;
+  });
+}
 
 /**
- * CLI 파서를 생성한다.
- * @internal 테스트용으로 export
+ * CPU affinity mask 계산 (앞쪽 코어 제외)
+ *
+ * CPU 4개당 1개를 제외하고, 나머지 코어의 비트를 ON으로 설정한다.
+ * 예: 8코어 → 2개 제외 → 0xFC (코어 2~7)
  */
-export function createCliParser(argv: string[]): Argv {
-  return yargs(argv)
-    .help("help", "도움말")
-    .alias("help", "h")
-    .option("debug", {
-      type: "boolean",
-      describe: "debug 로그 출력",
-      default: false,
-      global: true,
-    })
-    .middleware((args) => {
-      if (args.debug) consola.level = LogLevels.debug;
-    })
-    .command(
-      "lint [targets..]",
-      "ESLint + Stylelint를 실행한다.",
-      (cmd) =>
-        cmd
-          .version(false)
-          .hide("help")
-          .positional("targets", {
-            type: "string",
-            array: true,
-            describe: "린트할 경로 (예: packages/core-common, tests/orm)",
-            default: [],
-          })
-          .options({
-            fix: {
-              type: "boolean",
-              describe: "자동 수정",
-              default: false,
-            },
-            timing: {
-              type: "boolean",
-              describe: "규칙별 실행 시간 출력",
-              default: false,
-            },
-          }),
-      async (args) => {
-        await runLint({
-          targets: args.targets,
-          fix: args.fix,
-          timing: args.timing,
-        });
-      },
-    )
-    .command(
-      "typecheck [targets..]",
-      "TypeScript 타입체크를 실행한다.",
-      (cmd) =>
-        cmd
-          .version(false)
-          .hide("help")
-          .positional("targets", {
-            type: "string",
-            array: true,
-            describe: "타입체크할 경로 (예: packages/core-common, tests/orm)",
-            default: [],
-          })
-          .options({
-            options: {
-              type: "string",
-              array: true,
-              alias: "o",
-              description: "sd.config.ts에 전달할 옵션 (예: -o key=value)",
-              default: [] as string[],
-            },
-          }),
-      async (args) => {
-        await runTypecheck({
-          targets: args.targets,
-          options: args.options,
-        });
-      },
-    )
-    .command(
-      "watch [targets..]",
-      "패키지를 watch 모드로 빌드한다.",
-      (cmd) =>
-        cmd
-          .version(false)
-          .hide("help")
-          .positional("targets", {
-            type: "string",
-            array: true,
-            describe: "watch할 패키지 (예: solid, solid-demo)",
-            default: [],
-          })
-          .options({
-            options: {
-              type: "string",
-              array: true,
-              alias: "o",
-              description: "sd.config.ts에 전달할 옵션 (예: -o key=value)",
-              default: [] as string[],
-            },
-          }),
-      async (args) => {
-        await runWatch({
-          targets: args.targets,
-          options: args.options,
-        });
-      },
-    )
-    .command(
-      "dev [targets..]",
-      "Client와 Server 패키지를 개발 모드로 실행한다.",
-      (cmd) =>
-        cmd
-          .version(false)
-          .hide("help")
-          .positional("targets", {
-            type: "string",
-            array: true,
-            describe: "실행할 패키지 (예: solid-demo)",
-            default: [],
-          })
-          .options({
-            options: {
-              type: "string",
-              array: true,
-              alias: "o",
-              description: "sd.config.ts에 전달할 옵션 (예: -o key=value)",
-              default: [] as string[],
-            },
-          }),
-      async (args) => {
-        await runDev({
-          targets: args.targets,
-          options: args.options,
-        });
-      },
-    )
-    .command(
-      "build [targets..]",
-      "프로덕션 빌드를 실행한다.",
-      (cmd) =>
-        cmd
-          .version(false)
-          .hide("help")
-          .positional("targets", {
-            type: "string",
-            array: true,
-            describe: "빌드할 패키지 (예: solid, core-common)",
-            default: [],
-          })
-          .options({
-            options: {
-              type: "string",
-              array: true,
-              alias: "o",
-              description: "sd.config.ts에 전달할 옵션 (예: -o key=value)",
-              default: [] as string[],
-            },
-          }),
-      async (args) => {
-        await runBuild({
-          targets: args.targets,
-          options: args.options,
-        });
-      },
-    )
-    .command(
-      "device",
-      "Android 디바이스에서 앱을 실행한다.",
-      (cmd) =>
-        cmd
-          .version(false)
-          .hide("help")
-          .options({
-            package: {
-              type: "string",
-              alias: "p",
-              describe: "패키지 이름",
-              demandOption: true,
-            },
-            url: {
-              type: "string",
-              alias: "u",
-              describe: "개발 서버 URL (미지정 시 sd.config.ts의 server 설정 사용)",
-            },
-            options: {
-              type: "string",
-              array: true,
-              alias: "o",
-              description: "sd.config.ts에 전달할 옵션 (예: -o key=value)",
-              default: [] as string[],
-            },
-          }),
-      async (args) => {
-        await runDevice({
-          package: args.package,
-          url: args.url,
-          options: args.options,
-        });
-      },
-    )
-    .command(
-      "init",
-      "새 프로젝트를 초기화한다.",
-      (cmd) => cmd.version(false).hide("help"),
-      async () => {
-        const { runInit } = await import("./commands/init.js");
-        await runInit({});
-      },
-    )
-    .command("add", "프로젝트에 패키지를 추가한다.", (cmd) =>
-      cmd
-        .version(false)
-        .hide("help")
-        .command(
-          "client",
-          "클라이언트 패키지를 추가한다.",
-          (subCmd) => subCmd.version(false).hide("help"),
-          async () => {
-            const { runAddClient } = await import("./commands/add-client.js");
-            await runAddClient({});
-          },
-        )
-        .command(
-          "server",
-          "서버 패키지를 추가한다.",
-          (subCmd) => subCmd.version(false).hide("help"),
-          async () => {
-            const { runAddServer } = await import("./commands/add-server.js");
-            await runAddServer({});
-          },
-        )
-        .demandCommand(1, "패키지 타입을 지정해주세요. (client, server)"),
-    )
-    .command(
-      "publish [targets..]",
-      "패키지를 배포한다.",
-      (cmd) =>
-        cmd
-          .version(false)
-          .hide("help")
-          .positional("targets", {
-            type: "string",
-            array: true,
-            describe: "배포할 패키지 (예: solid, core-common)",
-            default: [],
-          })
-          .options({
-            "build": {
-              type: "boolean",
-              describe: "빌드 실행 (--no-build로 스킵)",
-              default: true,
-            },
-            "dry-run": {
-              type: "boolean",
-              describe: "실제 배포 없이 시뮬레이션",
-              default: false,
-            },
-            "options": {
-              type: "string",
-              array: true,
-              alias: "o",
-              description: "sd.config.ts에 전달할 옵션 (예: -o key=value)",
-              default: [] as string[],
-            },
-          }),
-      async (args) => {
-        await runPublish({
-          targets: args.targets,
-          noBuild: !args.build,
-          dryRun: args.dryRun,
-          options: args.options,
-        });
-      },
-    )
-    .command(
-      "replace-deps",
-      "sd.config.ts의 replaceDeps 설정에 따라 node_modules 패키지를 로컬 소스로 symlink 교체한다.",
-      (cmd) =>
-        cmd
-          .version(false)
-          .hide("help")
-          .options({
-            options: {
-              type: "string",
-              array: true,
-              alias: "o",
-              description: "sd.config.ts에 전달할 옵션 (예: -o key=value)",
-              default: [] as string[],
-            },
-          }),
-      async (args) => {
-        await runReplaceDeps({
-          options: args.options,
-        });
-      },
-    )
-    .demandCommand(1, "명령어를 지정해주세요.")
-    .strict();
+function calculateAffinityMask(cpuCount: number): string {
+  const exclude = cpuCount <= 1 ? 0 : Math.ceil(cpuCount / 4);
+  let mask = 0n;
+  for (let i = exclude; i < cpuCount; i++) {
+    mask |= 1n << BigInt(i);
+  }
+  return "0x" + mask.toString(16).toUpperCase();
 }
 
-// CLI로 직접 실행될 때만 파싱 수행
-// ESM에서 메인 모듈 판별: import.meta.url과 process.argv[1]을 정규화하여 비교
-const cliEntryPath = process.argv.at(1);
-if (cliEntryPath != null && fileURLToPath(import.meta.url) === fs.realpathSync(path.resolve(cliEntryPath))) {
-  await createCliParser(hideBin(process.argv)).parse();
+/**
+ * Cross-platform CPU affinity + priority 설정
+ *
+ * - Windows: PowerShell ProcessorAffinity + PriorityClass
+ * - Linux/WSL: taskset + renice
+ *
+ * 실패해도 경고만 출력하고 CLI 동작에는 영향 없음.
+ */
+function configureAffinityAndPriority(pid: number): void {
+  const cpuCount = os.cpus().length;
+  const mask = calculateAffinityMask(cpuCount);
+
+  let command: string;
+  if (process.platform === "win32") {
+    const commands = [
+      `$p = Get-Process -Id ${pid}`,
+      `$p.ProcessorAffinity = ${mask}`,
+      `$p.PriorityClass = 'BelowNormal'`,
+    ].join("; ");
+    command = `powershell -Command "${commands}"`;
+  } else {
+    command = `taskset -p ${mask} ${pid} && renice +10 -p ${pid}`;
+  }
+
+  exec(command, (err) => {
+    if (err) {
+      // eslint-disable-next-line no-console
+      console.warn("CPU affinity/priority 설정 실패:", err.message);
+    }
+  });
 }

package/src/utils/replace-deps.ts

@@ -2,6 +2,7 @@ import fs from "fs";
 import path from "path";
 import { glob } from "glob";
 import { consola } from "consola";
+import { fsCopy, fsMkdir, fsRm, FsWatcher } from "@simplysm/core-node";
 
 /**
  * replaceDeps 설정의 glob 패턴과 대상 패키지 목록을 매칭하여
@@ -83,11 +84,47 @@ export function parseWorkspaceGlobs(content: string): string[] {
 }
 
 /**
- * replaceDeps 설정에 따라 node_modules 내 패키지를 소스 디렉토리로 symlink 교체한다.
+ * 복사 시 제외할 항목 이름들
+ */
+const EXCLUDED_NAMES = new Set(["node_modules", "package.json", ".cache", "tests"]);
+
+/**
+ * replaceDeps 복사 시 사용할 필터 함수
+ * node_modules, package.json, .cache, tests를 제외한다.
+ *
+ * @param itemPath - 복사할 항목의 절대 경로
+ * @returns 복사 대상이면 true, 제외하면 false
+ */
+function replaceDepsCopyFilter(itemPath: string): boolean {
+  const basename = path.basename(itemPath);
+  return !EXCLUDED_NAMES.has(basename);
+}
+
+/**
+ * replaceDeps 복사 교체 항목
+ */
+export interface ReplaceDepEntry {
+  targetName: string;
+  sourcePath: string;
+  targetPath: string;
+  resolvedSourcePath: string;
+  actualTargetPath: string;
+}
+
+/**
+ * watchReplaceDeps 반환 타입
+ */
+export interface WatchReplaceDepResult {
+  entries: ReplaceDepEntry[];
+  dispose: () => void;
+}
+
+/**
+ * replaceDeps 설정에 따라 node_modules 내 패키지를 소스 디렉토리로 복사 교체한다.
  *
  * 1. pnpm-workspace.yaml 파싱 → workspace 패키지 경로 목록
  * 2. [루트, ...workspace 패키지]의 node_modules에서 매칭되는 패키지 찾기
- * 3. 기존 symlink/디렉토리 제거 → 소스 경로로 symlink 생성
+ * 3. 기존 symlink/디렉토리 제거 → 소스 경로를 복사 (node_modules, package.json, .cache, tests 제외)
  *
  * @param projectRoot - 프로젝트 루트 경로
  * @param replaceDeps - sd.config.ts의 replaceDeps 설정
@@ -133,7 +170,7 @@ export async function setupReplaceDeps(projectRoot: string, replaceDeps: Record<
     // 패턴 매칭 및 경로 해석
     const entries = resolveReplaceDepEntries(replaceDeps, targetNames);
 
-    // 3. Symlink 교체
+    // 3. 복사 교체
     for (const { targetName, sourcePath } of entries) {
       const targetPath = path.join(nodeModulesDir, targetName);
       const resolvedSourcePath = path.resolve(projectRoot, sourcePath);
@@ -147,17 +184,184 @@ export async function setupReplaceDeps(projectRoot: string, replaceDeps: Record<
       }
 
       try {
-        // 기존 symlink/디렉토리 제거
-        await fs.promises.rm(targetPath, { recursive: true, force: true });
+        // targetPath가 symlink면 realpath로 해석하여 실제 .pnpm 스토어 경로 얻기
+        let actualTargetPath = targetPath;
+        try {
+          const stat = await fs.promises.lstat(targetPath);
+          if (stat.isSymbolicLink()) {
+            actualTargetPath = await fs.promises.realpath(targetPath);
+          }
+        } catch {
+          // targetPath가 존재하지 않으면 그대로 사용
+        }
 
-        // 상대 경로로 symlink 생성
-        const relativePath = path.relative(path.dirname(targetPath), resolvedSourcePath);
-        await fs.promises.symlink(relativePath, targetPath, "dir");
+        // actualTargetPath의 기존 내용 제거 후 소스 복사 (symlink는 유지)
+        await fs.promises.rm(actualTargetPath, { recursive: true, force: true });
+        await fsCopy(resolvedSourcePath, actualTargetPath, replaceDepsCopyFilter);
 
         logger.info(`${targetName} → ${sourcePath}`);
       } catch (err) {
-        logger.error(`symlink 교체 실패 (${targetName}): ${err instanceof Error ? err.message : err}`);
+        logger.error(`복사 교체 실패 (${targetName}): ${err instanceof Error ? err.message : err}`);
       }
     }
   }
 }
+
+/**
+ * replaceDeps 설정에 따라 소스 디렉토리를 watch하여 변경 시 대상 경로로 복사한다.
+ *
+ * 1. pnpm-workspace.yaml 파싱 → workspace 패키지 경로 목록
+ * 2. [루트, ...workspace 패키지]의 node_modules에서 매칭되는 패키지 찾기
+ * 3. 소스 디렉토리를 FsWatcher로 watch (300ms delay)
+ * 4. 변경 시 대상 경로로 복사 (node_modules, package.json, .cache, tests 제외)
+ *
+ * @param projectRoot - 프로젝트 루트 경로
+ * @param replaceDeps - sd.config.ts의 replaceDeps 설정
+ * @returns entries와 dispose 함수
+ */
+export async function watchReplaceDeps(
+  projectRoot: string,
+  replaceDeps: Record<string, string>,
+): Promise<WatchReplaceDepResult> {
+  const logger = consola.withTag("sd:cli:replace-deps:watch");
+  const entries: ReplaceDepEntry[] = [];
+
+  // 1. Workspace 패키지 경로 목록 수집
+  const searchRoots = [projectRoot];
+
+  const workspaceYamlPath = path.join(projectRoot, "pnpm-workspace.yaml");
+  try {
+    const yamlContent = await fs.promises.readFile(workspaceYamlPath, "utf-8");
+    const workspaceGlobs = parseWorkspaceGlobs(yamlContent);
+
+    for (const pattern of workspaceGlobs) {
+      const dirs = await glob(pattern, { cwd: projectRoot, absolute: true });
+      searchRoots.push(...dirs);
+    }
+  } catch {
+    // pnpm-workspace.yaml가 없으면 루트만 처리
+  }
+
+  // 2. 각 searchRoot의 node_modules에서 매칭되는 패키지 찾기
+  for (const searchRoot of searchRoots) {
+    const nodeModulesDir = path.join(searchRoot, "node_modules");
+
+    try {
+      await fs.promises.access(nodeModulesDir);
+    } catch {
+      continue; // node_modules 없으면 스킵
+    }
+
+    // replaceDeps의 각 glob 패턴으로 node_modules 내 디렉토리 탐색
+    const targetNames: string[] = [];
+    for (const pattern of Object.keys(replaceDeps)) {
+      const matches = await glob(pattern, { cwd: nodeModulesDir });
+      targetNames.push(...matches);
+    }
+
+    if (targetNames.length === 0) continue;
+
+    // 패턴 매칭 및 경로 해석
+    const matchedEntries = resolveReplaceDepEntries(replaceDeps, targetNames);
+
+    // 3. entry 정보 수집 (symlink 해석 포함)
+    for (const { targetName, sourcePath } of matchedEntries) {
+      const targetPath = path.join(nodeModulesDir, targetName);
+      const resolvedSourcePath = path.resolve(projectRoot, sourcePath);
+
+      // 소스 경로 존재 확인
+      try {
+        await fs.promises.access(resolvedSourcePath);
+      } catch {
+        logger.warn(`소스 경로가 존재하지 않아 스킵합니다: ${resolvedSourcePath}`);
+        continue;
+      }
+
+      // targetPath가 symlink면 realpath로 해석하여 실제 .pnpm 스토어 경로 얻기
+      let actualTargetPath = targetPath;
+      try {
+        const stat = await fs.promises.lstat(targetPath);
+        if (stat.isSymbolicLink()) {
+          actualTargetPath = await fs.promises.realpath(targetPath);
+        }
+      } catch {
+        // targetPath가 존재하지 않으면 그대로 사용
+      }
+
+      entries.push({
+        targetName,
+        sourcePath,
+        targetPath,
+        resolvedSourcePath,
+        actualTargetPath,
+      });
+    }
+  }
+
+  // 4. 소스 디렉토리 watch 설정
+  const watchers: FsWatcher[] = [];
+  const watchedSources = new Set<string>();
+
+  for (const entry of entries) {
+    if (watchedSources.has(entry.resolvedSourcePath)) continue;
+    watchedSources.add(entry.resolvedSourcePath);
+
+    const watcher = await FsWatcher.watch([entry.resolvedSourcePath], { followSymlinks: false });
+    watcher.onChange({ delay: 300 }, async (changeInfos) => {
+      for (const { path: changedPath } of changeInfos) {
+        // 제외 항목 필터링
+        const basename = path.basename(changedPath);
+        if (EXCLUDED_NAMES.has(basename)) continue;
+
+        // 이 소스 경로를 사용하는 모든 entry에 대해 복사
+        for (const e of entries) {
+          if (e.resolvedSourcePath !== entry.resolvedSourcePath) continue;
+
+          // 소스 경로 기준 상대 경로 계산
+          const relativePath = path.relative(e.resolvedSourcePath, changedPath);
+          const destPath = path.join(e.actualTargetPath, relativePath);
+
+          try {
+            // 소스가 존재하는지 확인
+            let sourceExists = false;
+            try {
+              await fs.promises.access(changedPath);
+              sourceExists = true;
+            } catch {
+              // 소스가 삭제됨
+            }
+
+            if (sourceExists) {
+              // 소스가 디렉토리인지 파일인지 확인
+              const stat = await fs.promises.stat(changedPath);
+              if (stat.isDirectory()) {
+                await fsMkdir(destPath);
+              } else {
+                await fsMkdir(path.dirname(destPath));
+                await fsCopy(changedPath, destPath, replaceDepsCopyFilter);
+              }
+              logger.info(`복사: ${relativePath} → ${e.targetName}`);
+            } else {
+              // 소스가 삭제됨 → 대상도 삭제
+              await fsRm(destPath);
+              logger.info(`삭제: ${relativePath} (${e.targetName})`);
+            }
+          } catch (err) {
+            logger.error(`복사 실패 (${e.targetName}/${relativePath}): ${err instanceof Error ? err.message : err}`);
+          }
+        }
+      }
+    });
+
+    watchers.push(watcher);
+  }
+
+  return {
+    entries,
+    dispose: () => {
+      for (const watcher of watchers) {
+        void watcher.close();
+      }
+    },
+  };
+}

package/templates/add-client/__CLIENT__/package.json.hbs

@@ -4,7 +4,7 @@
   "type": "module",
   "private": true,
   "dependencies": {
-    "@simplysm/solid": "~13.0.7",
+    "@simplysm/solid": "~13.0.10",
 {{#if router}}
     "@solidjs/router": "^0.15.4",
 {{/if}}

package/templates/add-server/__SERVER__/package.json.hbs

@@ -4,7 +4,7 @@
   "type": "module",
   "private": true,
   "dependencies": {
-    "@simplysm/core-common": "~13.0.7",
-    "@simplysm/service-server": "~13.0.7"
+    "@simplysm/core-common": "~13.0.10",
+    "@simplysm/service-server": "~13.0.10"
   }
 }