@simplysm/sd-cli 14.0.30 → 14.0.32

package/src/runtime/engine-watch-events.ts

@@ -0,0 +1,121 @@
+import type { BuildResult, ResultCollector } from "../runtime/ResultCollector";
+import type { RebuildManager } from "./rebuild-manager";
+
+/**
+ * worker.on()으로 이벤트를 구독할 수 있는 최소 인터페이스
+ */
+interface EventSubscribable {
+  on(event: string, handler: (...args: any[]) => void): void;
+}
+
+/**
+ * 정규화된 빌드 정보
+ */
+export interface NormalizedBuildInfo {
+  success: boolean;
+  errors?: string[];
+  warnings?: string[];
+}
+
+/**
+ * setupWatchEvents 옵션
+ */
+export interface SetupWatchEventsOptions {
+  name: string;
+  target: string;
+  resultCollector?: ResultCollector;
+  rebuildManager?: RebuildManager;
+  /** build 이벤트 데이터를 공통 형태로 변환하는 콜백 */
+  normalizeBuild: (data: unknown) => NormalizedBuildInfo;
+}
+
+/**
+ * BaseEngine과 EsbuildClientEngine의 공통 watch 이벤트 처리를 설정한다.
+ *
+ * buildStart → RebuildManager.registerBuild() 호출
+ * build → ResultCollector.add() + resolver 호출
+ * error → ResultCollector.add() + resolver 호출
+ *
+ * @returns waitForInitialBuild - 첫 build/error 이벤트에서 resolve되는 Promise 반환 함수
+ * @returns resolveInitialBuild - 수동으로 초기 빌드를 resolve (startWatch 실패 시 사용)
+ */
+export function setupWatchEvents(
+  worker: EventSubscribable,
+  options: SetupWatchEventsOptions,
+): {
+  waitForInitialBuild: () => Promise<void>;
+  resolveInitialBuild: () => void;
+} {
+  const { name, target, resultCollector, rebuildManager, normalizeBuild } = options;
+  const workerKey = `${name}:build`;
+
+  let resolver: (() => void) | undefined;
+  let isInitialBuild = true;
+  let initialBuildResolve: (() => void) | undefined;
+
+  worker.on("buildStart", () => {
+    if (rebuildManager != null) {
+      resolver = rebuildManager.registerBuild(workerKey, `${name} (${target})`);
+    }
+  });
+
+  worker.on("build", (data: unknown) => {
+    const info = normalizeBuild(data);
+
+    const buildResult: BuildResult = {
+      name,
+      target,
+      type: "build",
+      status: info.success ? "success" : "error",
+      message: info.errors?.join("\n"),
+    };
+    resultCollector?.add(buildResult);
+
+    resolver?.();
+    resolver = undefined;
+
+    if (isInitialBuild) {
+      isInitialBuild = false;
+      initialBuildResolve?.();
+    }
+  });
+
+  worker.on("error", (data: unknown) => {
+    const event = data as { message: string };
+
+    const buildResult: BuildResult = {
+      name,
+      target,
+      type: "build",
+      status: "error",
+      message: event.message,
+    };
+    resultCollector?.add(buildResult);
+
+    resolver?.();
+    resolver = undefined;
+
+    if (isInitialBuild) {
+      isInitialBuild = false;
+      initialBuildResolve?.();
+    }
+  });
+
+  function resolveInitialBuild(): void {
+    if (isInitialBuild) {
+      isInitialBuild = false;
+      initialBuildResolve?.();
+    }
+  }
+
+  function waitForInitialBuild(): Promise<void> {
+    if (!isInitialBuild) {
+      return Promise.resolve();
+    }
+    return new Promise<void>((resolve) => {
+      initialBuildResolve = resolve;
+    });
+  }
+
+  return { waitForInitialBuild, resolveInitialBuild };
+}

package/src/{utils → runtime}/rebuild-manager.ts

@@ -18,6 +18,8 @@ export class RebuildManager extends EventEmitter<RebuildManagerEvents> {
     this._logger = logger;
   }
 
+  private _batchTimer: ReturnType<typeof setTimeout> | undefined;
+
   registerBuild(key: string, title: string): () => void {
     this._logger.debug(`빌드 등록: ${key} (${title})`);
     let resolver!: () => void;
@@ -28,7 +30,12 @@ export class RebuildManager extends EventEmitter<RebuildManagerEvents> {
     this._pendingBuilds.set(key, { title, promise, resolver });
 
     if (!this._isRunning) {
-      void Promise.resolve().then(() => void this._runBatch());
+      // 워커 스레드들의 buildStart가 도착할 시간을 확보하기 위해 짧은 대기
+      if (this._batchTimer != null) clearTimeout(this._batchTimer);
+      this._batchTimer = setTimeout(() => {
+        this._batchTimer = undefined;
+        void this._runBatch();
+      }, 100);
     }
 
     return resolver;

package/src/runtime/worker-events.ts

@@ -0,0 +1,25 @@
+/** 워커 빌드 완료 이벤트 데이터 */
+export interface BuildEventData {
+  success: boolean;
+  errors?: string[];
+  warnings?: string[];
+}
+
+/** 워커 에러 이벤트 데이터 */
+export interface ErrorEventData {
+  message: string;
+}
+
+/** 워커 서버 준비 완료 이벤트 데이터 */
+export interface ServerReadyEventData {
+  port: number;
+}
+
+/** Server 빌드 완료 이벤트 데이터 */
+export interface ServerBuildEventData {
+  success: boolean;
+  mainJsPath: string;
+  errors?: string[];
+  warnings?: string[];
+}
+

package/src/sd-cli-entry.ts

@@ -80,23 +80,25 @@ export function createCliParser(argv: string[]): Argv {
       setupConsola({ cli: true });
     })
     .command(
-      "check [targets..]",
+      "check",
       "Run Typecheck, Lint, Test in parallel",
       (cmd) =>
         cmd
           .version(false)
           .hide("help")
-          .positional("targets", {
-            type: "string",
-            array: true,
-            describe: "Packages to check (e.g., core-common, storage)",
-            default: [],
-          })
           .options({
+            target: {
+              type: "string",
+              array: true,
+              alias: "t",
+              describe: "Packages to check (e.g., --target core-common --target storage)",
+              default: [] as string[],
+            },
             type: {
               type: "string",
-              describe: "Check types to run (comma-separated: typecheck,lint,test)",
-              default: "typecheck,lint,test",
+              array: true,
+              describe: "Check types to run (e.g., --type typecheck --type lint)",
+              default: ["typecheck", "lint", "test"] as string[],
             },
             fix: {
               type: "boolean",
@@ -106,10 +108,10 @@ export function createCliParser(argv: string[]): Argv {
           }),
       async (args) => {
         await runCheck({
-          targets: args.targets,
+          targets: args.target,
           types: (() => {
             const validTypes = ["typecheck", "lint", "test"] as const;
-            const types = args.type.split(",").map((t) => t.trim());
+            const types = args.type.flatMap((t) => t.split(",").map((s) => s.trim()));
             const invalidTypes = types.filter((t) => !validTypes.includes(t as CheckType));
             if (invalidTypes.length > 0) {
               throw new Error(
@@ -123,75 +125,81 @@ export function createCliParser(argv: string[]): Argv {
       },
     )
     .command(
-      "watch [targets..]",
+      "watch",
       "Build packages in watch mode",
       (cmd) =>
         cmd
           .version(false)
           .hide("help")
-          .positional("targets", {
-            type: "string",
-            array: true,
-            describe: "Packages to watch (e.g., core-common, storage)",
-            default: [],
-          })
           .options({
+            target: {
+              type: "string",
+              array: true,
+              alias: "t",
+              describe: "Packages to watch (e.g., --target core-common --target storage)",
+              default: [] as string[],
+            },
             opt: {
               type: "string",
               array: true,
+
               alias: "o",
-              description: "Options to pass to sd.config.ts (e.g., -o key=value)",
+              description: "Options to pass to sd.config.ts (e.g., -o a -o b)",
               default: [] as string[],
             },
           }),
       async (args) => {
         await runWatch({
-          targets: args.targets,
+          targets: args.target,
           options: args.opt,
         });
       },
     )
     .command(
-      "dev [targets..]",
+      "dev",
       "Run Server packages in dev mode",
       (cmd) =>
         cmd
           .version(false)
           .hide("help")
-          .positional("targets", {
-            type: "string",
-            array: true,
-            describe: "Packages to run (e.g., service-server)",
-            default: [],
-          })
           .options({
+            target: {
+              type: "string",
+              array: true,
+
+              alias: "t",
+              describe: "Packages to run (e.g., --target service-server)",
+              default: [] as string[],
+            },
             opt: {
               type: "string",
               array: true,
+
               alias: "o",
-              description: "Options to pass to sd.config.ts (e.g., -o key=value)",
+              description: "Options to pass to sd.config.ts (e.g., -o a -o b)",
               default: [] as string[],
             },
           }),
       async (args) => {
         await runDev({
-          targets: args.targets,
+          targets: args.target,
           options: args.opt,
         });
       },
     )
     .command(
-      "device [target]",
+      "device",
       "Run native app on device/desktop",
       (cmd) =>
         cmd
           .version(false)
           .hide("help")
-          .positional("target", {
-            type: "string",
-            describe: "Client package to run (e.g., my-client-app)",
-          })
           .options({
+            target: {
+              type: "string",
+              alias: "t",
+              describe: "Client package to run (e.g., --target my-client-app)",
+            },
             url: {
               type: "string",
               description: "Dev server URL (auto-detected from sd.config.ts if omitted)",
@@ -199,8 +207,9 @@ export function createCliParser(argv: string[]): Argv {
             opt: {
               type: "string",
               array: true,
+
               alias: "o",
-              description: "Options to pass to sd.config.ts (e.g., -o key=value)",
+              description: "Options to pass to sd.config.ts (e.g., -o a -o b)",
               default: [] as string[],
             },
           }),
@@ -214,48 +223,53 @@ export function createCliParser(argv: string[]): Argv {
       },
     )
     .command(
-      "build [targets..]",
+      "build",
       "Run production build",
       (cmd) =>
         cmd
           .version(false)
           .hide("help")
-          .positional("targets", {
-            type: "string",
-            array: true,
-            describe: "Packages to build (e.g., core-common, storage)",
-            default: [],
-          })
           .options({
+            target: {
+              type: "string",
+              array: true,
+
+              alias: "t",
+              describe: "Packages to build (e.g., --target core-common --target storage)",
+              default: [] as string[],
+            },
             opt: {
               type: "string",
               array: true,
+
               alias: "o",
-              description: "Options to pass to sd.config.ts (e.g., -o key=value)",
+              description: "Options to pass to sd.config.ts (e.g., -o a -o b)",
               default: [] as string[],
             },
           }),
       async (args) => {
         await runBuild({
-          targets: args.targets,
+          targets: args.target,
           options: args.opt,
         });
       },
     )
     .command(
-      "publish [targets..]",
+      "publish",
       "Publish packages",
       (cmd) =>
         cmd
           .version(false)
           .hide("help")
-          .positional("targets", {
-            type: "string",
-            array: true,
-            describe: "Packages to publish (e.g., core-common, storage)",
-            default: [],
-          })
           .options({
+            "target": {
+              type: "string",
+              array: true,
+
+              alias: "t",
+              describe: "Packages to publish (e.g., --target core-common --target storage)",
+              default: [] as string[],
+            },
             "build": {
               type: "boolean",
               describe: "Run build (skip with --no-build)",
@@ -269,14 +283,15 @@ export function createCliParser(argv: string[]): Argv {
             "opt": {
               type: "string",
               array: true,
+
               alias: "o",
-              description: "Options to pass to sd.config.ts (e.g., -o key=value)",
+              description: "Options to pass to sd.config.ts (e.g., -o a -o b)",
               default: [] as string[],
             },
           }),
       async (args) => {
         await runPublish({
-          targets: args.targets,
+          targets: args.target,
           noBuild: !args.build,
           dryRun: args.dryRun,
           options: args.opt,
@@ -295,7 +310,7 @@ export function createCliParser(argv: string[]): Argv {
               type: "string",
               array: true,
               alias: "o",
-              description: "Options to pass to sd.config.ts (e.g., -o key=value)",
+              description: "Options to pass to sd.config.ts (e.g., -o a -o b)",
               default: [] as string[],
             },
           }),

package/src/sd-cli.ts

@@ -30,7 +30,7 @@ if (isDev) {
   // Phase 1: replaceDeps (인라인 — 설치된 버전으로 복사)
   try {
     const { loadSdConfig } = await import("./utils/sd-config.js");
-    const { setupReplaceDeps } = await import("./utils/replace-deps.js");
+    const { setupReplaceDeps } = await import("./deps/replace-deps/replace-deps.js");
     const sdConfig = await loadSdConfig({ cwd: process.cwd(), dev: false, opt: [] });
     if (process.argv[2] !== "replace-deps" && sdConfig.replaceDeps != null) {
       await setupReplaceDeps(process.cwd(), sdConfig.replaceDeps);

package/src/sd-config.types.ts

@@ -191,19 +191,11 @@ export interface SdPwaManifestConfig {
   icons?: Array<{ src: string; sizes: string; type?: string }>;
 }
 
-/**
- * PWA workbox 설정
- */
-export interface SdPwaWorkboxConfig {
-  globPatterns?: string[];
-}
-
 /**
  * PWA 설정
  */
 export interface SdPwaConfig {
   manifest?: SdPwaManifestConfig;
-  workbox?: SdPwaWorkboxConfig;
 }
 
 //#endregion
@@ -214,24 +206,22 @@ export interface SdPwaConfig {
 export interface SdBrowserSupportConfig {
   /** browserslist 쿼리 (예: "last 2 Chrome versions" 또는 ["ie 11", "last 2 versions"]) */
   browserslist?: string | string[];
-  /** PostCSS 플러그인 설정 */
-  postCss?: { plugins: unknown[] };
+  /** PostCSS 플러그인 설정 ([name, options] 튜플 배열) */
+  postCss?: { plugins: [string, (object | string)?][] };
   /** 레거시 모듈 지원 (코드 분할 비활성화 + import.meta 치환) */
   legacyModule?: boolean;
 }
 
 /**
- * 클라이언트 패키지 설정 (Vite 개발 서버)
+ * 클라이언트 패키지 설정 (esbuild 기반 빌드)
  */
 export interface SdClientPackageConfig {
   /** 빌드 타겟 */
   target: "client";
-  /** 클라이언트 프레임워크 선택. 미지정 시 "angular" */
-  framework?: "angular" | "solid";
   /**
    * 서버 설정
-   * - string: 연결할 서버 패키지명 (예: "solid-demo-server")
-   * - number: Vite 포트 직접 지정 (하위 호환)
+   * - string: 연결할 서버 패키지명 (예: "demo-server")
+   * - number: 포트 직접 지정 (하위 호환)
    */
   server: string | number;
   /** 빌드 시 치환할 환경 변수 (process.env를 객체로 치환) */
@@ -244,7 +234,7 @@ export interface SdClientPackageConfig {
   electron?: SdElectronConfig;
   /** 런타임 설정 (빌드 시 dist/.config.json으로 기록) */
   configs?: Record<string, unknown>;
-  /** Vite optimizeDeps에서 제외하고 Capacitor/Electron package.json에 추가할 패키지 */
+  /** Capacitor/Electron package.json에 추가할 패키지 */
   exclude?: string[];
   /** 브라우저 지원 설정 (browserslist, PostCSS, legacyModule) */
   browserSupport?: SdBrowserSupportConfig;

package/src/{utils → typecheck}/typecheck-non-package.ts

@@ -2,7 +2,7 @@ import path from "path";
 import ts from "typescript";
 import { consola } from "consola";
 import { pathx } from "@simplysm/core-node";
-import { parseTsconfig } from "./tsconfig";
+import { parseTsconfig } from "../utils/tsconfig";
 import { serializeDiagnostic, type SerializedDiagnostic } from "./typecheck-serialization";
 
 const logger = consola.withTag("sd:cli:typecheck-non-pkg");

package/src/utils/diagnostic-utils.ts

@@ -14,6 +14,21 @@ export function isWorkspaceDiagnostic(diagnostic: ts.Diagnostic, cwd: string): b
   return normalized.startsWith(normalizedCwd + "/") && !normalized.includes("/node_modules/");
 }
 
+/**
+ * ts.Diagnostic 배열을 중복 제거 후 컬러 컨텍스트 포맷으로 변환한다.
+ * 빈 배열이면 빈 문자열을 반환한다.
+ */
+export function formatDiagnosticsOutput(diagnostics: ts.Diagnostic[], cwd: string): string {
+  if (diagnostics.length === 0) return "";
+  const formatHost: ts.FormatDiagnosticsHost = {
+    getCanonicalFileName: (f) => f,
+    getCurrentDirectory: () => cwd,
+    getNewLine: () => ts.sys.newLine,
+  };
+  const uniqueDiagnostics = ts.sortAndDeduplicateDiagnostics(diagnostics);
+  return ts.formatDiagnosticsWithColorAndContext(uniqueDiagnostics, formatHost);
+}
+
 /**
  * 진단 에러를 "파일:줄:열: TS코드: 메시지" 형식으로 포맷한다.
  * 파일 정보가 없는 경우 "TS코드: 메시지" 형식으로 반환한다.

package/src/utils/orchestrator-utils.ts

@@ -4,23 +4,19 @@ import { validateTargets } from "./package-utils";
 
 /**
  * Orchestrator 공통 초기화: config 로드 + 타겟 검증.
- * BuildOrchestrator.initialize()와 DevWatchOrchestrator.initialize()에서 호출한다.
- *
- * @param params.packagesForValidation 검증 대상 패키지를 오버라이드. DevWatchOrchestrator는
- *   tests/ 패키지를 merge한 결과에 대해 검증해야 하므로 이 파라미터를 사용한다.
+ * BuildOrchestrator.initialize()에서 호출한다.
  */
 export async function loadAndValidateConfig(params: {
   cwd: string;
   dev: boolean;
   options: string[];
   targets: string[];
-  packagesForValidation?: Record<string, unknown>;
 }): Promise<SdConfig> {
   const config = await loadSdConfig({
     cwd: params.cwd,
     dev: params.dev,
     opt: params.options,
   });
-  validateTargets(params.targets, params.packagesForValidation ?? config.packages);
+  validateTargets(params.targets, config.packages);
   return config;
 }

package/src/utils/output-utils.ts

@@ -1,5 +1,5 @@
 import { consola } from "consola";
-import type { BuildResult } from "../infra/ResultCollector";
+import type { BuildResult } from "../runtime/ResultCollector";
 
 /**
  * 빌드 경고/에러 메시지를 포맷팅한다.