@simplysm/sd-cli 14.0.41 → 14.0.43

package/src/deps/replace-deps/replace-deps.ts

@@ -8,20 +8,42 @@ import type { ReplaceDepEntry } from "./replace-deps-resolve";
 import { resolveAllReplaceDepEntries } from "./replace-deps-resolve";
 
 /**
- * 복사 시 제외할 이름 목록
+ * npm publish 시 files 필드와 무관하게 항상 포함되는 파일 패턴 (대소문자 무시)
  */
-const EXCLUDED_NAMES = new Set(["node_modules", "package.json", ".cache", "tests"]);
+export const NPM_DEFAULT_FILE_PATTERN = /^(readme|license|licence|changelog|history)/i;
 
 /**
- * replaceDeps 복사용 필터 함수
- * node_modules, package.json, .cache, tests를 제외한다.
- *
- * @param itemPath - 복사할 항목의 절대 경로
- * @returns 복사 대상이면 true, 제외 대상이면 false
+ * 소스 패키지의 package.json에서 files 필드를 읽어 반환한다.
+ * files 필드가 없으면 undefined를 반환한다.
+ */
+export async function loadFilesField(sourcePath: string): Promise<string[] | undefined> {
+  const pkgJsonPath = pathx.posix(path.join(sourcePath, "package.json"));
+  const pkgJson = JSON.parse(await fs.promises.readFile(pkgJsonPath, "utf-8"));
+  return pkgJson.files as string[] | undefined;
+}
+
+/**
+ * files 필드 기반 화이트리스트 복사 필터를 생성한다.
+ * 소스 루트 기준 상대경로의 첫 번째 세그먼트로 판단한다.
+ *  - files에 포함 → 허용
+ *  - npm 기본 파일 패턴 매칭 → 허용
+ *  - package.json → 제외
+ *  - 그 외 → 제외
  */
-function replaceDepsCopyFilter(itemPath: string): boolean {
-  const basename = path.basename(itemPath);
-  return !EXCLUDED_NAMES.has(basename);
+export function createCopyFilter(
+  sourcePath: string,
+  allowedNames: Set<string>,
+): (itemPath: string) => boolean {
+  return (itemPath: string) => {
+    const relativePath = path.relative(sourcePath, itemPath);
+    const firstSegment = relativePath.split(path.sep)[0];
+
+    if (firstSegment === "package.json") return false;
+    if (allowedNames.has(firstSegment)) return true;
+    if (NPM_DEFAULT_FILE_PATTERN.test(firstSegment)) return true;
+
+    return false;
+  };
 }
 
 /**
@@ -37,7 +59,7 @@ export interface WatchReplaceDepResult {
  *
  * 1. pnpm-workspace.yaml 파싱 → 워크스페이스 패키지 경로
  * 2. [루트, ...워크스페이스 패키지] node_modules에서 매칭 패키지 탐색
- * 3. 기존 symlink/디렉토리 제거 → 소스 경로 복사 (node_modules, package.json, .cache, tests 제외)
+ * 3. 소스 package.json의 files 필드 + npm 기본 파일만 대상 경로에 복사 (package.json 제외)
  *
  * @param projectRoot - 프로젝트 루트 경로
  * @param replaceDeps - sd.config.ts의 replaceDeps 설정
@@ -52,22 +74,31 @@ export async function setupReplaceDeps(
   logger.start("replace-deps 설정 중...");
 
   const entries = await resolveAllReplaceDepEntries(projectRoot, replaceDeps, logger);
+  const copiedEntries: ReplaceDepEntry[] = [];
 
-  for (const { targetName, resolvedSourcePath, actualTargetPath } of entries) {
+  for (const entry of entries) {
     try {
-      // 소스 파일을 actualTargetPath에 덮어쓰기 복사 (기존 디렉토리 유지, symlink 보존)
-      await fsx.copy(resolvedSourcePath, actualTargetPath, replaceDepsCopyFilter);
+      // 소스 패키지의 files 필드를 읽어 화이트리스트 구성
+      const files = await loadFilesField(entry.resolvedSourcePath);
+      if (files == null) {
+        logger.warn(`[${entry.targetName}] package.json에 files 필드가 없어 건너뜀`);
+        continue;
+      }
+
+      const filter = createCopyFilter(entry.resolvedSourcePath, new Set(files));
+      await fsx.copy(entry.resolvedSourcePath, entry.actualTargetPath, filter);
 
+      copiedEntries.push(entry);
       setupCount += 1;
     } catch (err) {
-      logger.error(`[${targetName}] 복사 실패: ${err instanceof Error ? err.message : err}`);
+      logger.error(`[${entry.targetName}] 복사 실패: ${err instanceof Error ? err.message : err}`);
     }
   }
 
   logger.success(`replace-deps 설정 완료 (${setupCount}개 의존성 교체)`);
 
   // 교체된 패키지의 postinstall 스크립트 실행
-  for (const { targetName, resolvedSourcePath, actualTargetPath } of entries) {
+  for (const { targetName, resolvedSourcePath, actualTargetPath } of copiedEntries) {
     const sourcePkgJsonPath = pathx.posix(path.join(resolvedSourcePath, "package.json"));
     try {
       const pkgJson = JSON.parse(await fs.promises.readFile(sourcePkgJsonPath, "utf-8"));
@@ -91,8 +122,8 @@ export async function setupReplaceDeps(
  *
  * 1. pnpm-workspace.yaml 파싱 → 워크스페이스 패키지 경로
  * 2. [루트, ...워크스페이스 패키지] node_modules에서 매칭 패키지 탐색
- * 3. FsWatcher로 소스 디렉토리 감시 (300ms 딜레이)
- * 4. 변경사항을 대상 경로에 복사 (node_modules, package.json, .cache, tests 제외)
+ * 3. FsWatcher로 files 항목 경로만 감시 (300ms 딜레이)
+ * 4. 변경사항을 대상 경로에 복사
  *
  * @param projectRoot - 프로젝트 루트 경로
  * @param replaceDeps - sd.config.ts의 replaceDeps 설정
@@ -118,66 +149,83 @@ export async function watchReplaceDeps(
     if (watchedSources.has(entry.resolvedSourcePath)) continue;
     watchedSources.add(entry.resolvedSourcePath);
 
-    const excludedPaths = [...EXCLUDED_NAMES].map((name) =>
-      pathx.posix(path.join(entry.resolvedSourcePath, name)),
-    );
-
-    const watcher = await FsWatcher.watch([entry.resolvedSourcePath], {
-      followSymlinks: false,
-      ignored: [...EXCLUDED_NAMES].map((name) => `**/${name}`),
-    });
-    watcher.onChange({ delay: 300 }, async (changeInfos) => {
-      for (const { path: changedPath } of changeInfos) {
-        // 제외 항목 필터: basename 매칭 또는 제외 디렉토리 내 경로
-        if (
-          EXCLUDED_NAMES.has(path.basename(changedPath)) ||
-          excludedPaths.some((ep) => pathx.isChildPath(changedPath, ep))
-        ) {
-          continue;
+    try {
+      // 소스 패키지의 files 필드를 읽어 감시 대상 경로 구성
+      const files = await loadFilesField(entry.resolvedSourcePath);
+      if (files == null) {
+        logger.warn(`[${entry.targetName}] package.json에 files 필드가 없어 감시 건너뜀`);
+        continue;
+      }
+
+      // files 항목 경로 + npm 기본 파일 경로
+      const watchPaths = files.map((f) =>
+        pathx.posix(path.join(entry.resolvedSourcePath, f)),
+      );
+
+      // 소스 루트에서 npm 기본 파일 패턴에 매칭되는 파일 추가
+      try {
+        const rootEntries = await fs.promises.readdir(entry.resolvedSourcePath);
+        for (const name of rootEntries) {
+          if (NPM_DEFAULT_FILE_PATTERN.test(name)) {
+            watchPaths.push(pathx.posix(path.join(entry.resolvedSourcePath, name)));
+          }
         }
+      } catch {
+        // readdir 실패 시 npm 기본 파일 감시 생략
+      }
 
-        // 이 소스 경로를 사용하는 모든 항목에 대해 복사
-        for (const e of entries) {
-          if (e.resolvedSourcePath !== entry.resolvedSourcePath) continue;
+      const watcher = await FsWatcher.watch(watchPaths, {
+        followSymlinks: false,
+      });
+      watcher.onChange({ delay: 300 }, async (changeInfos) => {
+        for (const { path: changedPath } of changeInfos) {
+          // 이 소스 경로를 사용하는 모든 항목에 대해 복사
+          for (const e of entries) {
+            if (e.resolvedSourcePath !== entry.resolvedSourcePath) continue;
 
-          // 소스로부터의 상대 경로 계산
-          const relativePath = pathx.posix(path.relative(e.resolvedSourcePath, changedPath));
-          const destPath = pathx.posix(path.join(e.actualTargetPath, relativePath));
+            // 소스로부터의 상대 경로 계산
+            const relativePath = pathx.posix(path.relative(e.resolvedSourcePath, changedPath));
+            const destPath = pathx.posix(path.join(e.actualTargetPath, relativePath));
 
-          try {
-            // 소스 존재 여부 확인
-            let sourceExists = false;
             try {
-              await fs.promises.access(changedPath);
-              sourceExists = true;
-            } catch {
-              // 소스가 삭제됨
-            }
+              // 소스 존재 여부 확인
+              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 fsx.mkdir(destPath);
+              if (sourceExists) {
+                // 소스가 디렉토리인지 파일인지 확인
+                const stat = await fs.promises.stat(changedPath);
+                if (stat.isDirectory()) {
+                  await fsx.mkdir(destPath);
+                } else {
+                  await fsx.mkdir(pathx.posix(path.dirname(destPath)));
+                  await fsx.copy(changedPath, destPath);
+                }
               } else {
-                await fsx.mkdir(pathx.posix(path.dirname(destPath)));
-                await fsx.copy(changedPath, destPath, replaceDepsCopyFilter);
+                // 소스가 삭제됨 → 대상도 삭제
+                await fsx.rm(destPath);
               }
-            } else {
-              // 소스가 삭제됨 → 대상도 삭제
-              await fsx.rm(destPath);
+            } catch (err) {
+              logger.error(
+                `[${e.targetName}] 복사 실패 (${relativePath}): ${err instanceof Error ? err.message : err}`,
+              );
             }
-          } catch (err) {
-            logger.error(
-              `[${e.targetName}] 복사 실패 (${relativePath}): ${err instanceof Error ? err.message : err}`,
-            );
           }
         }
-      }
-      options?.onChanged?.();
-    });
+        options?.onChanged?.();
+      });
 
-    watchers.push(watcher);
+      watchers.push(watcher);
+    } catch (err) {
+      logger.error(
+        `[${entry.targetName}] 감시 설정 실패: ${err instanceof Error ? err.message : err}`,
+      );
+    }
   }
 
   logger.success("replace-deps 워치 준비 완료");

package/src/electron/electron.ts

@@ -60,7 +60,7 @@ export class Electron {
   //#region Public Methods
 
   async initialize(): Promise<void> {
-    Electron._logger.debug("initialize 시작");
+    Electron._logger.start("initialize 중...");
 
     Electron._logger.debug("package.json 설정 시작");
     await this._setupNpmConf();
@@ -83,11 +83,11 @@ export class Electron {
       await this._exec("pnpm", ["exec", "electron-rebuild"], this._srcPath);
       Electron._logger.debug("electron-rebuild 완료");
     }
-    Electron._logger.debug("initialize 완료");
+    Electron._logger.success("initialize 완료");
   }
 
   async run(url: string): Promise<void> {
-    Electron._logger.debug(`run 시작 (url: ${url})`);
+    Electron._logger.start(`run 중... (url: ${url})`);
 
     await this.initialize();
     await this._copyPublicAssets();
@@ -126,7 +126,7 @@ export class Electron {
           setup: (build) => {
             build.onEnd(async (result) => {
               if (result.errors.length > 0) {
-                Electron._logger.warn("번들링 실패. Electron을 재시작하지 않습니다.");
+                Electron._logger.error("번들링 실패. Electron을 재시작하지 않습니다.");
                 return;
               }
 
@@ -181,11 +181,11 @@ export class Electron {
       process.once("SIGINT", signalHandler);
       process.once("SIGTERM", signalHandler);
     });
-    Electron._logger.debug("run 완료");
+    Electron._logger.success("run 완료");
   }
 
   async build(outPath: string): Promise<void> {
-    Electron._logger.debug("build 시작");
+    Electron._logger.start("build 중...");
 
     await this.initialize();
 
@@ -205,7 +205,7 @@ export class Electron {
     await this._copyBuildOutput(outPath);
     Electron._logger.debug("빌드 산출물 복사 완료");
 
-    Electron._logger.debug("build 완료");
+    Electron._logger.success("build 완료");
   }
 
   //#endregion

package/src/engines/BaseEngine.ts

@@ -163,14 +163,10 @@ export abstract class BaseEngine<
         (data as CommonBuildWorkerEvents["build"]).build,
     });
 
-    // BaseEngine 전용: 경고 로깅 + 린트 결과 보고
+    // BaseEngine 전용: 린트 결과 보고
     this._worker!.on("build", (data) => {
       const event = data;
 
-      if (event.build.warnings != null && event.build.warnings.length > 0) {
-        logger.warn(`${this._pkg.name}: ${event.build.warnings.join(", ")}`);
-      }
-
       if (event.lint != null) {
         const lintResult: BuildResult = {
           name: this._pkg.name,
@@ -184,7 +180,7 @@ export abstract class BaseEngine<
     });
 
     this._callStartWatch(output).catch((err: unknown) => {
-      logger.error(`[${this._pkg.name}] startWatch 실패:`, errNs.message(err));
+      logger.debug(`[${this._pkg.name}] startWatch 실패:`, errNs.message(err));
       this._resultCollector?.add({
         name: this._pkg.name,
         target: this._getTarget(),

package/src/engines/EsbuildClientEngine.ts

@@ -101,20 +101,14 @@ export class EsbuildClientEngine implements BuildEngine {
     });
 
     // 공통 이벤트 처리 (buildStart/build/error)
-    setupWatchEvents(this._worker!, {
+    const { resolveInitialBuild } = setupWatchEvents(this._worker!, {
       name: this._pkg.name,
       target: "client",
       resultCollector: this._resultCollector,
       rebuildManager: this._rebuildManager,
       normalizeBuild: (data) => data as NormalizedBuildInfo,
     });
-    // waitForInitialBuild 미사용 — worker.startWatch() await로 완료 감지
-
-    // EsbuildClientEngine 전용: error 로깅
-    this._worker!.on("error", (data) => {
-      const event = data as { message: string };
-      logger.error(`${this._pkg.name}: ${event.message}`);
-    });
+    resolveInitialBuild(); // EsbuildClientEngine은 worker.startWatch() await로 초기 빌드 완료를 감지하므로 즉시 정리
 
     const port =
       typeof this._pkg.config.server === "number"
@@ -132,15 +126,27 @@ export class EsbuildClientEngine implements BuildEngine {
       browserSupport: this._pkg.config.browserSupport,
     });
 
+    const warningsText = result.warnings != null && result.warnings.length > 0
+      ? result.warnings.join("\n")
+      : undefined;
+
     if (!result.success) {
-      const errorDetail = result.errors?.join("; ") ?? "unknown error";
-      logger.error(`[${this._pkg.name}] 초기 빌드 실패: ${errorDetail}`);
+      const errorDetail = result.errors?.join("\n") ?? "unknown error";
       this._resultCollector?.add({
         name: this._pkg.name,
         target: "client",
         type: "build",
         status: "error",
         message: errorDetail,
+        warnings: warningsText,
+      });
+    } else if (warningsText != null) {
+      this._resultCollector?.add({
+        name: this._pkg.name,
+        target: "client",
+        type: "build",
+        status: "success",
+        warnings: warningsText,
       });
     }
   }

package/src/engines/NgtscEngine.ts

@@ -1,4 +1,4 @@
-import type * as NgtscBuildWorkerModule from "../workers/ngtsc-build.worker";
+import type * as LibraryBuildWorkerModule from "../workers/library-build.worker";
 import type { ResultCollector } from "../runtime/ResultCollector";
 import type { RebuildManager } from "../runtime/rebuild-manager";
 import type { BuildOutput, BuildPackageInfo, EngineResult } from "./types";
@@ -24,19 +24,19 @@ export interface NgtscEngineOptions {
 /**
  * NgtscProgram 기반 Angular 라이브러리 패키지용 빌드 엔진
  *
- * NgtscProgram을 사용하여 AOT 컴파일을 수행하는 ngtsc-build.worker를 래핑한다.
- * package.json에 @angular/core 의존성이 있는 Angular 패키지용.
+ * 통합된 library-build.worker를 사용하며, globalScss: true를 전달하여
+ * Angular AOT 컴파일 + SCSS 빌드를 활성화한다.
  */
 export class NgtscEngine extends BaseEngine<
   BuildPackageInfo,
-  typeof NgtscBuildWorkerModule & CommonBuildWorkerModule
+  typeof LibraryBuildWorkerModule & CommonBuildWorkerModule
 > {
   constructor(options: NgtscEngineOptions) {
     super(options);
   }
 
   protected _getWorkerPath(): string {
-    return import.meta.resolve("../workers/ngtsc-build.worker");
+    return import.meta.resolve("../workers/library-build.worker");
   }
 
   protected _getTarget(): string {
@@ -49,7 +49,7 @@ export class NgtscEngine extends BaseEngine<
       name: this._pkg.name,
       cwd: this._cwd,
       pkgDir: this._pkg.dir,
-      output,
+      output: { ...output, globalScss: true },
     });
 
     return this._normalizeResult(result);
@@ -61,7 +61,7 @@ export class NgtscEngine extends BaseEngine<
       name: this._pkg.name,
       cwd: this._cwd,
       pkgDir: this._pkg.dir,
-      output,
+      output: { ...output, globalScss: true },
       replaceDeps: this._replaceDeps,
     });
   }

package/src/engines/TscEngine.ts

@@ -47,7 +47,6 @@ export class TscEngine extends BaseEngine<
     logger.debug(`[${this._pkg.name}] worker.build 호출`);
     const result = await this._worker!.build({
       name: this._pkg.name,
-      config: this._pkg.config,
       cwd: this._cwd,
       pkgDir: this._pkg.dir,
       output,
@@ -60,7 +59,6 @@ export class TscEngine extends BaseEngine<
     logger.debug(`[${this._pkg.name}] worker.startWatch 호출`);
     await this._worker!.startWatch({
       name: this._pkg.name,
-      config: this._pkg.config,
       cwd: this._cwd,
       pkgDir: this._pkg.dir,
       output,

package/src/engines/types.ts

@@ -39,6 +39,8 @@ export interface BuildOutput {
   env?: TypecheckEnv;
   /** 타입체크 범위에 tests/ 파일을 포함한다. check 커맨드에서만 사용된다. */
   includeTests?: boolean;
+  /** Angular 라이브러리의 글로벌 SCSS 컴파일 여부 */
+  globalScss?: boolean;
 }
 
 /**