@simplysm/sd-cli 14.0.19 → 14.0.22

package/src/commands/typecheck.ts

@@ -1,294 +1,9 @@
-import ts from "typescript";
-import { err as errNs } from "@simplysm/core-common";
-import { pathx } from "@simplysm/core-node";
-import { consola } from "consola";
-import { loadSdConfig } from "../utils/sd-config";
-import { deserializeDiagnostic } from "../utils/typecheck-serialization";
-import { createBuildEngine } from "../engines/index";
-import { typecheckNonPackageFiles } from "../utils/typecheck-non-package";
-import { runWithConcurrency, getMaxConcurrency } from "../utils/concurrency";
-import { discoverWorkspacePackages, mergeTestsPackagesIntoConfig } from "../utils/package-utils";
-import type { EngineResult } from "../engines/types";
-import type { TypecheckEnv } from "../utils/tsconfig";
-import { toTypecheckEnvs } from "../utils/tsconfig";
-
-//#region Types
-
 /**
- * TypeScript 타입체크 옵션
+ * TypecheckOrchestrator에 위임하는 CLI 래퍼.
+ * 타입과 executeTypecheck를 re-export하여 기존 호출자와의 호환성을 유지한다.
  */
-export interface TypecheckOptions {
-  /** 타입체크 대상 경로 필터 (예: `packages/core-common`, `tests/orm`). 빈 배열이면 전체 대상. */
-  targets: string[];
-  /** sd.config.ts에 전달할 추가 옵션 */
-  options: string[];
-  /** true이면 엔진에 lint: true를 전달하고 lint 결과를 수집한다 */
-  lint?: boolean;
-}
-
-/**
- * TypeScript 타입체크 실행 결과
- */
-export interface TypecheckResult {
-  success: boolean;
-  errorCount: number;
-  warningCount: number;
-  formattedOutput: string;
-  /** lint 결과 (TypecheckOptions.lint가 true일 때 존재) */
-  lint?: {
-    success: boolean;
-    errorCount: number;
-    warningCount: number;
-    formattedOutput: string;
-  };
-  /** 건너뛴 scripts 패키지 경로 (별도 lint용) */
-  scriptsPackagePaths?: string[];
-}
-
-//#endregion
-
-//#region Utilities
-
-const TARGET_PATH_PATTERN = /^(?:packages|tests)\/([^/]+)/;
-
-/**
- * 대상 경로에서 패키지명을 추출한다.
- * "packages/core-common" → "core-common"
- * "tests/orm" → "orm"
- */
-function extractTargetPackageNames(targets: string[]): Set<string> {
-  const names = new Set<string>();
-  for (const target of targets) {
-    const match = target.match(TARGET_PATH_PATTERN);
-    if (match) names.add(match[1]);
-  }
-  return names;
-}
-
-//#endregion
-
-//#region Main
-
-/**
- * BuildEngine을 사용하여 TypeScript 타입체크를 실행한다.
- *
- * sd.config.ts의 각 패키지에 대해:
- * - 라이브러리/서버 패키지 → BuildEngine.run({js:false, dts:false})
- * - client 패키지 → browser target으로 변환하여 포함
- * - scripts 패키지 → 타입체크 제외 (별도 lint만 수행)
- * 비패키지 파일 → typecheckNonPackageFiles 유틸리티
- *
- * @param options - 타입체크 실행 옵션
- * @returns 타입체크 결과 (성공 여부, 에러/경고 수, 포매팅된 출력 문자열)
- */
-export async function executeTypecheck(options: TypecheckOptions): Promise<TypecheckResult> {
-  const { targets } = options;
-  const cwd = process.cwd();
-  const logger = consola.withTag("sd:cli:typecheck");
-
-  const phaseLabel = options.lint === true ? "타입체크/린트" : "타입체크";
-
-  logger.debug(`${phaseLabel} 시작`, { targets, lint: options.lint });
-
-  const formatHost: ts.FormatDiagnosticsHost = {
-    getCanonicalFileName: (f) => f,
-    getCurrentDirectory: () => cwd,
-    getNewLine: () => ts.sys.newLine,
-  };
-
-  // sd.config.ts 로드
-  const sdConfig = await loadSdConfig({ cwd, dev: false, opt: options.options });
-  logger.debug("sd.config.ts 로드 완료");
-
-  // 워크스페이스 패키지 탐색 및 tests/를 설정에 병합
-  const workspacePackages = discoverWorkspacePackages(cwd);
-  const { merged, pathMap } = mergeTestsPackagesIntoConfig(sdConfig.packages, workspacePackages);
-
-  // 경로 기반 대상에서 패키지명 결정
-  const targetNames = extractTargetPackageNames(targets);
-
-  // scripts 패키지 경로 수집 (별도 lint용)
-  const scriptsPackagePaths: string[] = [];
-
-  // 타���체크할 패키지 수집 (scripts 제외), env별로 확장
-  const typecheckTasks: Array<{ name: string; dir: string; config: any; env: TypecheckEnv }> = [];
-  for (const [name, config] of Object.entries(merged)) {
-    if (config == null) continue;
-    if (config.target === "scripts") {
-      if (targets.length === 0 || targetNames.has(name)) {
-        const relPath = pathMap.get(name) ?? `packages/${name}`;
-        scriptsPackagePaths.push(relPath);
-      }
-      continue;
-    }
-    if (targets.length > 0 && !targetNames.has(name)) continue;
-
-    const relPath = pathMap.get(name) ?? `packages/${name}`;
-    // 클라이언트 패키지의 경우 browser 타겟을 사용하여 createBuildEngine이 ViteEngine 대신 NgtscEngine으로 라우팅되도록 함
-    const typecheckConfig = config.target === "client" ? { target: "browser" as const } : config;
-    const envs = toTypecheckEnvs(config.target);
-    for (const env of envs) {
-      typecheckTasks.push({
-        name,
-        dir: pathx.posixResolve(cwd, relPath),
-        config: typecheckConfig,
-        env,
-      });
-    }
-  }
-
-  // 비패키지 타입체크: 대상이 지정되지 않은 경우에만 (= 전체 검사)
-  const includeNonPackage = targets.length === 0;
-
-  if (typecheckTasks.length === 0 && !includeNonPackage) {
-    logger.info(`${phaseLabel} 대상 없음`);
-    return {
-      success: true,
-      errorCount: 0,
-      warningCount: 0,
-      formattedOutput: `✔ ${phaseLabel} 대상 없음.\n`,
-      scriptsPackagePaths: scriptsPackagePaths.length > 0 ? scriptsPackagePaths : undefined,
-    };
-  }
-
-  // 동시성 제한이 있는 BuildEngine 작업 생성
-  const allDiagnostics: ts.Diagnostic[] = [];
-  let totalErrorCount = 0;
-  let totalWarningCount = 0;
-  const fileCache = new Map<string, string>();
-
-  // Lint 결과 집계
-  let lintErrorCount = 0;
-  let lintWarningCount = 0;
-  let lintSuccess = true;
-  const lintOutputs: string[] = [];
-
-  if (typecheckTasks.length > 0) {
-    const tasks = typecheckTasks.map((task) => async (): Promise<EngineResult> => {
-      const label = `${task.name}:${task.env}`;
-      const engine = createBuildEngine(
-        { name: task.name, dir: task.dir, config: task.config },
-        { cwd },
-      );
-      try {
-        logger.debug(`[${label}] 타입체크 시작됨`);
-        const result = await engine.run({
-          js: false,
-          dts: false,
-          env: task.env,
-          includeTests: true,
-          ...(options.lint === true ? { lint: true } : {}),
-        });
-        logger.debug(`[${label}] 타입체크 ${result.build.success ? "완료" : "실패"}`);
-        return result;
-      } catch (err) {
-        const message = errNs.message(err);
-        const stack = err instanceof Error ? err.stack : undefined;
-        logger.error(`[${label}] 엔진 작업 실패: ${message}`);
-        if (stack != null) {
-          logger.debug(`[${label}] 스택 트레이스:\n${stack}`);
-        }
-        return {
-          build: {
-            success: false,
-            errors: [`[${label}] ${message}`],
-            warnings: [],
-            diagnostics: [],
-          },
-        };
-      } finally {
-        await engine.stop();
-      }
-    });
-
-    const concurrency = getMaxConcurrency();
-    logger.start(`${phaseLabel} 실행 중... (${tasks.length}개 작업, 동시성: ${concurrency})`);
-    const results = await runWithConcurrency(tasks, concurrency);
-    logger.success(`${phaseLabel} 실행 완료`);
-
-    // 엔진 결과 집계 (모든 task는 catch로 인해 항상 fulfilled)
-    for (const settled of results) {
-      if (settled.status !== "fulfilled") continue;
-      const engineResult = settled.value;
-      const buildDiags = engineResult.build.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
-      allDiagnostics.push(...buildDiags);
-      // 역직렬화된 진단 정보에서 에러/경고 수 집계
-      // 숫자 카테고리 값 사용 (ts.DiagnosticCategory: Error=1, Warning=0)
-      totalErrorCount += buildDiags.filter((d) => d.category === 1).length;
-      totalWarningCount += buildDiags.filter((d) => d.category === 0).length;
-      if (!engineResult.build.success && buildDiags.length === 0) {
-        for (const errMsg of engineResult.build.errors) {
-          allDiagnostics.push({
-            category: 1,
-            code: 0,
-            messageText: errMsg,
-            file: undefined,
-            start: undefined,
-            length: undefined,
-          });
-        }
-        totalErrorCount += engineResult.build.errors.length || 1;
-      }
-
-      // Lint 결과 수집
-      if (engineResult.lint != null) {
-        lintErrorCount += engineResult.lint.errorCount;
-        lintWarningCount += engineResult.lint.warningCount;
-        if (!engineResult.lint.success) lintSuccess = false;
-        if (engineResult.lint.formattedOutput !== "") {
-          lintOutputs.push(engineResult.lint.formattedOutput);
-        }
-      }
-    }
-  }
-
-  // 비패키지 타입체크
-  if (includeNonPackage) {
-    logger.debug("비패키지 타입체크 실행 중");
-    const nonPkgResult = typecheckNonPackageFiles(cwd);
-    totalErrorCount += nonPkgResult.errorCount;
-    totalWarningCount += nonPkgResult.warningCount;
-    const nonPkgDiags = nonPkgResult.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
-    allDiagnostics.push(...nonPkgDiags);
-  }
-
-  // 요약 로그
-  const resultMeta: Record<string, number> = { errorCount: totalErrorCount, warningCount: totalWarningCount };
-  if (options.lint === true) {
-    resultMeta["lintErrorCount"] = lintErrorCount;
-    resultMeta["lintWarningCount"] = lintWarningCount;
-  }
-  if (totalErrorCount > 0) {
-    logger.error(`${phaseLabel} 에러 발생`, resultMeta);
-  } else {
-    logger.info(`${phaseLabel} 완료`, resultMeta);
-  }
-
-  // 진단 출력 포매팅
-  let formattedOutput = "";
-  if (allDiagnostics.length > 0) {
-    const uniqueDiagnostics = ts.sortAndDeduplicateDiagnostics(allDiagnostics);
-    formattedOutput = ts.formatDiagnosticsWithColorAndContext(uniqueDiagnostics, formatHost);
-  }
-
-  // lint가 요청된 경우 lint 결과 생성
-  const lintResult = options.lint === true
-    ? {
-        success: lintSuccess,
-        errorCount: lintErrorCount,
-        warningCount: lintWarningCount,
-        formattedOutput: lintOutputs.join("\n"),
-      }
-    : undefined;
-
-  return {
-    success: totalErrorCount === 0,
-    errorCount: totalErrorCount,
-    warningCount: totalWarningCount,
-    formattedOutput,
-    lint: lintResult,
-    scriptsPackagePaths: scriptsPackagePaths.length > 0 ? scriptsPackagePaths : undefined,
-  };
-}
-
-//#endregion
+export {
+  executeTypecheck,
+  type TypecheckOptions,
+  type TypecheckResult,
+} from "../orchestrators/TypecheckOrchestrator";

package/src/electron/electron.ts

@@ -348,12 +348,12 @@ export class Electron {
     try {
       fs.writeFileSync(testTarget, "test");
       fs.symlinkSync(testTarget, testLink, "file");
-      const isSymlink = fs.lstatSync(testLink).isSymbolicLink();
-      fs.unlinkSync(testLink);
-      fs.unlinkSync(testTarget);
-      return isSymlink;
+      return fs.lstatSync(testLink).isSymbolicLink();
     } catch {
       return false;
+    } finally {
+      try { fs.unlinkSync(testLink); } catch { /* 파일 없으면 무시 */ }
+      try { fs.unlinkSync(testTarget); } catch { /* 파일 없으면 무시 */ }
     }
   }
 

package/src/engines/ViteEngine.ts

@@ -110,7 +110,7 @@ export class ViteEngine implements BuildEngine {
 
     // 리빌드 이벤트 처리 (HMR)
     let resolver: (() => void) | undefined;
-    const workerKey = `vite:${this._pkg.name}`;
+    const workerKey = `${this._pkg.name}:build`;
 
     this._worker!.on("buildStart", () => {
       if (this._rebuildManager != null) {

package/src/engines/types.ts

@@ -80,4 +80,7 @@ export interface BuildEngine {
    * 엔진을 중지하고 리소스(Worker, esbuild context 등)를 정리한다
    */
   stop(): Promise<void>;
+
+  /** 개발 서버 포트 (ViteEngine의 워치 모드에서 serverReady 이벤트로 설정됨) */
+  readonly port?: number;
 }

package/src/infra/ResultCollector.ts

@@ -37,9 +37,9 @@ export class ResultCollector {
   }
 
   /**
-   * 내부 Map을 반환한다 (외부 접근용)
+   * 내부 Map을 반환한다 (외부 접근용, 읽기 전용)
    */
-  toMap(): Map<string, BuildResult> {
+  toMap(): ReadonlyMap<string, BuildResult> {
     return this._results;
   }
 }

package/src/orchestrators/DevWatchOrchestrator.ts

@@ -74,6 +74,7 @@ export class DevWatchOrchestrator {
 
   // 워처
   private _copySrcWatchers: FsWatcher[] = [];
+  private _distDeleteWatchers: FsWatcher[] = [];
   private readonly _watchHookWatchers: FsWatcher[] = [];
   private readonly _watchHookChildren = new Map<string, ChildProcess>();
   private _replaceDepWatcher: WatchReplaceDepResult | undefined;
@@ -236,11 +237,25 @@ export class DevWatchOrchestrator {
   }
 
   async shutdown(): Promise<void> {
+    // replaceDepWatcher는 항상 정리 (initialize 부분 실패 대응 — DESIGN-002)
+    this._replaceDepWatcher?.dispose();
+    this._replaceDepWatcher = undefined;
+
     if (!this._hasPackages) {
       return;
     }
     this._logger.debug("shutdown 시작");
 
+    // pending 타이머 정리 (DESIGN-001)
+    if (this._printServersTimer != null) {
+      clearTimeout(this._printServersTimer);
+      this._printServersTimer = undefined;
+    }
+    if (this._serverRestartTimer != null) {
+      clearTimeout(this._serverRestartTimer);
+      this._serverRestartTimer = undefined;
+    }
+
     process.stdout.write("⏳ 종료 중...\n");
 
     const shutdownTasks: Array<Promise<void>> = [];
@@ -252,6 +267,7 @@ export class DevWatchOrchestrator {
 
     // 워처 종료 (watch 모드)
     shutdownTasks.push(...this._copySrcWatchers.map((w) => w.close()));
+    shutdownTasks.push(...this._distDeleteWatchers.map((w) => w.close()));
     shutdownTasks.push(...this._watchHookWatchers.map((w) => w.close()));
 
     // hook 자식 프로세스 종료
@@ -267,8 +283,8 @@ export class DevWatchOrchestrator {
 
     await Promise.all(shutdownTasks);
     this._copySrcWatchers = [];
+    this._distDeleteWatchers = [];
     this._watchHookWatchers.length = 0;
-    this._replaceDepWatcher?.dispose();
 
     process.stdout.write("✔ 종료 완료\n");
   }
@@ -278,17 +294,18 @@ export class DevWatchOrchestrator {
   private async _startWatchMode(): Promise<void> {
     this._logger.debug("watch 모드 시작");
 
-    // [DEBUG] angular/dist 삭제 감지용 임시 워처
-    {
-      const debugDistDir = pathx.posixResolve(this._cwd, "packages", "angular", "dist");
-      const debugWatcher = await FsWatcher.watch([debugDistDir]);
-      debugWatcher.onChange({ delay: 100 }, (changes) => {
+    // 라이브러리 패키지 dist 삭제 감지 워처
+    for (const pkg of this._libraryPackages) {
+      const distDir = pathx.posixResolve(pkg.dir, "dist");
+      const watcher = await FsWatcher.watch([distDir]);
+      watcher.onChange({ delay: 100 }, (changes) => {
         for (const c of changes) {
           if (c.event === "unlink" || c.event === "unlinkDir") {
-            this._logger.error(`[DEBUG:angular-dist] ${c.event}: ${c.path}\n${new Error().stack}`);
+            this._logger.error(`[dist-delete:${pkg.name}] ${c.event}: ${c.path}\n${new Error().stack}`);
           }
         }
       });
+      this._distDeleteWatchers.push(watcher);
     }
 
     // Start copySrc watchers for library packages
@@ -390,12 +407,14 @@ export class DevWatchOrchestrator {
       }
     });
 
+    // 서버에 연결된 클라이언트 Set 구성 (O(1) 조회용 — PERF-001)
+    const serverConnectedClients = new Set(
+      [...this._serverClientsMap.values()].flat(),
+    );
+
     // 독립 클라이언트 결과를 ResultCollector에 등록
     for (const { name } of this._clientPackages) {
-      const isServerConnected = [...this._serverClientsMap.values()].some(
-        (clients) => clients.includes(name),
-      );
-      if (!isServerConnected) {
+      if (!serverConnectedClients.has(name)) {
         const port = this._getClientPort(name);
         if (port != null) {
           this._resultCollector.add({
@@ -433,12 +452,9 @@ export class DevWatchOrchestrator {
 
     // 독립 클라이언트만 존재하고 서버가 없는 경우 URL 출력 예약
     if (this._serverPackages.length === 0) {
-      const hasIndependentClients = this._clientPackages.some(({ name }) => {
-        const isServerConnected = [...this._serverClientsMap.values()].some(
-          (clients) => clients.includes(name),
-        );
-        return !isServerConnected && this._getClientPort(name) != null;
-      });
+      const hasIndependentClients = this._clientPackages.some(({ name }) =>
+        !serverConnectedClients.has(name) && this._getClientPort(name) != null,
+      );
       if (hasIndependentClients) {
         this._schedulePrintServers();
       }
@@ -500,10 +516,9 @@ export class DevWatchOrchestrator {
     }, 300);
   }
 
-  /** 클라이언트 엔진에서 포트 가져오기 (ViteEngine.port에 대한 duck-typing) */
+  /** 클라이언트 엔진에서 포트 가져오기 */
   private _getClientPort(name: string): number | undefined {
-    const engine = this._clientEngines.get(name) as { port?: number } | undefined;
-    return engine?.port;
+    return this._clientEngines.get(name)?.port;
   }
 
   /** 서버에 연결된 클라이언트들의 포트 수집 */