@simplysm/sd-cli 7.0.24 → 7.0.38

package/src/builder/SdCliServerBuilder.ts

@@ -8,17 +8,17 @@ import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
 import { ErrorInfo } from "ts-loader/dist/interfaces";
 import os from "os";
 import { ESLint } from "eslint";
-import webpackMerge from "webpack-merge";
 import TerserPlugin from "terser-webpack-plugin";
-import { StringUtil } from "@simplysm/sd-core-common";
-import { SdCliNpmConfigUtil } from "../utils/SdCliNpmConfigUtil";
+import { ObjectUtil, StringUtil } from "@simplysm/sd-core-common";
 import ESLintWebpackPlugin from "eslint-webpack-plugin";
 import CopyWebpackPlugin from "copy-webpack-plugin";
+import { LicenseWebpackPlugin } from "license-webpack-plugin";
 import LintResult = ESLint.LintResult;
 
 export class SdCliServerBuilder extends EventEmitter {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
 
+  private readonly _tsconfigFilePath: string;
   private readonly _parsedTsconfig: ts.ParsedCommandLine;
   private readonly _npmConfigMap = new Map<string, INpmConfig>();
 
@@ -28,8 +28,8 @@ export class SdCliServerBuilder extends EventEmitter {
     super();
 
     // tsconfig
-    const tsconfigFilePath = path.resolve(this._rootPath, "tsconfig-build.json");
-    const tsconfig = FsUtil.readJson(tsconfigFilePath);
+    this._tsconfigFilePath = path.resolve(this._rootPath, "tsconfig-build.json");
+    const tsconfig = FsUtil.readJson(this._tsconfigFilePath);
     this._parsedTsconfig = ts.parseJsonConfigFileContent(tsconfig, ts.sys, this._rootPath);
   }
 
@@ -40,18 +40,46 @@ export class SdCliServerBuilder extends EventEmitter {
   }
 
   public async watchAsync(): Promise<void> {
+    // DIST 비우기
+    await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
+
+    // 빌드 준비
+    const extModuleNames = this._getExternalModuleNames();
+    const webpackConfig = this._getWebpackConfig(true, extModuleNames);
+    const compiler = webpack(webpackConfig);
+    await new Promise<void>((resolve, reject) => {
+      compiler.hooks.watchRun.tapAsync(this.constructor.name, (args, callback) => {
+        this.emit("change");
+        this._logger.debug("Webpack 빌드 수행...");
+        callback();
+      });
+
+      compiler.watch({}, async (err, stats) => {
+        if (err != null || stats == null) {
+          reject(err);
+          return;
+        }
+
+        // .config.json 파일 쓰기
+        await this._writeDistConfigFileAsync();
+
+        // 결과 반환
+        this._logger.debug("Webpack 빌드 완료");
+        const results = SdCliBuildResultUtil.convertFromWebpackStats(stats);
+        this.emit("complete", results);
+        resolve();
+      });
+    });
   }
 
   public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
     // DIST 비우기
     await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
-    // 빌드 준비
-    const extModuleNames = this._findExternalModules(false).map((item) => item.name);
-
     // 빌드
     this._logger.debug("Webpack 빌드 수행...");
-    const webpackConfig = this._getWebpackBuildConfig(extModuleNames);
+    const extModuleNames = this._getExternalModuleNames();
+    const webpackConfig = this._getWebpackConfig(false, extModuleNames);
     const compiler = webpack(webpackConfig);
     const buildResults = await new Promise<ISdCliPackageBuildResult[]>((resolve, reject) => {
       compiler.run((err, stats) => {
@@ -60,18 +88,127 @@ export class SdCliServerBuilder extends EventEmitter {
           return;
         }
 
-        // 결과 리턴
+        // 결과 반환
         const results = SdCliBuildResultUtil.convertFromWebpackStats(stats);
         resolve(results);
       });
     });
-    this._logger.debug("Webpack 빌드 완료");
 
+    // .config.json 파일 쓰기
+    await this._writeDistConfigFileAsync();
+
+    // pm2.json 파일 쓰기
+    await this._writeDistPm2ConfigFileAsync();
+
+    // iis 파일 쓰기
+    await this._writeDistIisConfigFileAsync();
+
+    // 배포용 package.json 파일 생성
+    await this._writeDistNpmConfigFileAsync(extModuleNames);
+
+    // 마무리
+    this._logger.debug("Webpack 빌드 완료");
     return buildResults;
   }
 
-  private get _webpackCommonConfig(): webpack.Configuration {
+  private async _writeDistConfigFileAsync(): Promise<void> {
+    const configDistPath = path.resolve(this._parsedTsconfig.options.outDir!, ".config.json");
+    await FsUtil.writeFileAsync(configDistPath, JSON.stringify(this._config.configs ?? {}, undefined, 2));
+  }
+
+  private async _writeDistPm2ConfigFileAsync(): Promise<void> {
+    if (this._config.pm2 === undefined || this._config.pm2 === false) return;
+
+    const npmConfig = this._getNpmConfig(this._rootPath)!;
+    const pm2DistPath = path.resolve(this._parsedTsconfig.options.outDir!, "pm2.json");
+    await FsUtil.writeFileAsync(
+      pm2DistPath,
+      JSON.stringify(
+        ObjectUtil.merge(
+          {
+            "name": npmConfig.name.replace(/@/g, "").replace(/\//g, "-"),
+            "script": path.basename(path.resolve(this._parsedTsconfig.options.outDir!, "main.mjs")),
+            "watch": true,
+            "watch_delay": 2000,
+            "ignore_watch": [
+              "node_modules",
+              "www"
+            ].distinct(),
+            "interpreter": "node@" + process.versions.node,
+            "env": {
+              NODE_ENV: "production",
+              SD_VERSION: npmConfig.version,
+              TZ: "Asia/Seoul",
+              ...this._config.env ? this._config.env : {}
+            }
+          },
+          (typeof this._config.pm2 !== "boolean") ? this._config.pm2 : {},
+          {
+            arrayProcess: "concat"
+          }),
+        undefined,
+        2
+      )
+    );
+  }
+
+  private async _writeDistIisConfigFileAsync(): Promise<void> {
+    if (this._config.iis === undefined || this._config.iis === false) return;
+
+    const iisDistPath = path.resolve(this._parsedTsconfig.options.outDir!, "web.config");
+    const serverExeFilePath = (this._config.iis !== true && "serverExeFilePath" in this._config.iis)
+      ? (this._config.iis.serverExeFilePath ?? "C:\\Program Files\\nodejs\\node.exe")
+      : "C:\\Program Files\\nodejs\\node.exe";
+    await FsUtil.writeFileAsync(iisDistPath, `
+<configuration>
+  <system.webServer>
+    <webSocket enabled="false" />
+    <handlers>
+      <add name="iisnode" path="main.js" verb="*" modules="iisnode" />
+    </handlers>
+    <iisnode nodeProcessCommandLine="${serverExeFilePath}"
+             watchedFiles="web.config;*.js"
+             loggingEnabled="true"
+             devErrorsEnabled="true" />
+    <rewrite>
+      <rules>
+        <rule name="main">
+          <action type="Rewrite" url="main.mjs" />
+        </rule>
+      </rules>
+    </rewrite>
+    <httpErrors errorMode="Detailed" />
+  </system.webServer>
+</configuration>`.trim());
+  }
+
+  private async _writeDistNpmConfigFileAsync(deps: string[]): Promise<void> {
+    const distNpmConfig = ObjectUtil.clone(this._getNpmConfig(this._rootPath))!;
+    distNpmConfig.dependencies = {};
+    for (const dep of deps) {
+      distNpmConfig.dependencies[dep] = "*";
+    }
+    delete distNpmConfig.optionalDependencies;
+    delete distNpmConfig.devDependencies;
+    delete distNpmConfig.peerDependencies;
+
+    if (this._config.pm2 !== undefined) {
+      distNpmConfig.scripts = { "start": "pm2 start pm2.json" };
+    }
+
+    await FsUtil.writeFileAsync(
+      path.resolve(this._parsedTsconfig.options.outDir!, "package.json"),
+      JSON.stringify(distNpmConfig, undefined, 2)
+    );
+  }
+
+  private _getWebpackConfig(watch: boolean, extModuleNames: string[]): webpack.Configuration {
+    const internalModuleCachePaths = watch
+      ? FsUtil.findAllParentChildDirPaths("node_modules/!(@simplysm)", this._rootPath, this._workspaceRootPath)
+      : undefined;
+
     return {
+      mode: watch ? "development" : "production",
       devtool: false,
       target: ["node", "es2020"],
       profile: false,
@@ -90,22 +227,82 @@ export class SdCliServerBuilder extends EventEmitter {
       output: {
         clean: true,
         path: this._parsedTsconfig.options.outDir,
-        filename: "[name].js",
-        chunkFilename: "[name].js",
-        assetModuleFilename: "resources/[name][ext][query]"
+        filename: "[name].mjs",
+        chunkFilename: "[name].mjs",
+        assetModuleFilename: "res/[name][ext][query]",
+        libraryTarget: "module"
+      },
+      experiments: {
+        outputModule: true
       },
       performance: { hints: false },
-      node: false,
+      node: {
+        __dirname: true
+      },
       stats: "errors-warnings",
+      externals: extModuleNames,
+      ...watch ? {
+        cache: { type: "memory", maxGenerations: 1 },
+        snapshot: {
+          immutablePaths: internalModuleCachePaths,
+          managedPaths: internalModuleCachePaths
+        }
+      } : {
+        cache: false
+      },
+      optimization: {
+        ...watch ? {} : {
+          minimize: true,
+          minimizer: [
+            new TerserPlugin({
+              extractComments: false,
+              terserOptions: {
+                compress: true,
+                ecma: 2020,
+                sourceMap: false,
+                keep_classnames: true,
+                keep_fnames: true,
+                ie8: false,
+                safari10: false,
+                module: true,
+                format: {
+                  comments: false
+                }
+              }
+            })
+          ]
+        },
+        moduleIds: "deterministic",
+        chunkIds: watch ? "named" : "deterministic",
+        emitOnErrors: watch
+      },
       module: {
         strictExportPresence: true,
         rules: [
+          {
+            test: /\.m?js/,
+            resolve: {
+              fullySpecified: false
+            }
+          },
+          ...watch ? [
+            {
+              test: /\.m?js$/,
+              enforce: "pre" as const,
+              loader: "source-map-loader",
+              options: {
+                filterSourceMappingUrl: (mapUri: string, resourcePath: string) => {
+                  return !resourcePath.includes("node_modules") || (/@simplysm[\\/]sd/).test(resourcePath);
+                }
+              }
+            }
+          ] : [],
           {
             test: /\.ts$/,
             exclude: /node_modules/,
             loader: "ts-loader",
             options: {
-              compilerOptions: this._parsedTsconfig.options,
+              configFile: this._tsconfigFilePath,
               errorFormatter: (msg: ErrorInfo) => {
                 return SdCliBuildResultUtil.getMessage({
                   filePath: msg.file,
@@ -125,6 +322,14 @@ export class SdCliServerBuilder extends EventEmitter {
         ]
       },
       plugins: [
+        ...watch ? [] : [
+          new LicenseWebpackPlugin({
+            stats: { warnings: false, errors: false },
+            perChunkOutput: false,
+            outputFilename: "3rd_party_licenses.txt",
+            skipChildCompilers: true
+          }) as any
+        ],
         new CopyWebpackPlugin({
           patterns: ["assets/"].map((item) => ({
             context: this._rootPath,
@@ -150,6 +355,8 @@ export class SdCliServerBuilder extends EventEmitter {
         }),
         new ESLintWebpackPlugin({
           context: this._rootPath,
+          eslintPath: path.resolve(this._workspaceRootPath, "node_modules", "eslint"),
+          exclude: ["node_modules"],
           extensions: ["ts", "js", "mjs", "cjs"],
           fix: false,
           threads: false,
@@ -172,110 +379,72 @@ export class SdCliServerBuilder extends EventEmitter {
             }
             return resultMessages.join(os.EOL);
           }
-        }),
+        })/*,
         new webpack.ProgressPlugin({
           handler: (per: number, msg: string, ...args: string[]) => {
             const phaseText = msg ? ` - phase: ${msg}` : "";
             const argsText = args.length > 0 ? ` - args: [${args.join(", ")}]` : "";
             this._logger.debug(`Webpack 빌드 수행중...(${Math.round(per * 100)}%)${phaseText}${argsText}`);
           }
-        })
+        })*/
       ]
     };
   }
 
-  private _getWebpackWatchConfig(extModuleNames: string[]): webpack.Configuration {
-    const internalModuleCachePaths = FsUtil.findAllParentChildDirPaths("node_modules/!(@simplysm)", this._rootPath, this._workspaceRootPath);
-
-    return webpackMerge(this._webpackCommonConfig, {
-      mode: "development",
-      output: {
-        libraryTarget: "umd"
-      },
-      module: {
-        rules: [
-          {
-            test: /\.m?js$/,
-            enforce: "pre",
-            loader: "source-map-loader",
-            options: {
-              filterSourceMappingUrl: (mapUri: string, resourcePath: string) => {
-                return !resourcePath.includes("node_modules") || (/@simplysm[\\/]sd/).test(resourcePath);
-              }
-            }
-          }
-        ]
-      },
-      cache: { type: "memory", maxGenerations: 1 },
-      snapshot: {
-        immutablePaths: internalModuleCachePaths,
-        managedPaths: internalModuleCachePaths
-      },
-      optimization: {
-        moduleIds: "deterministic",
-        chunkIds: "named",
-        emitOnErrors: true
-      },
-      externals: extModuleNames
-    });
-  }
-
-  private _getWebpackBuildConfig(extModuleNames: string[]): webpack.Configuration {
-    return webpackMerge(this._webpackCommonConfig, {
-      mode: "production",
-      output: {
-        libraryTarget: "module"
-      },
-      cache: false,
-      optimization: {
-        minimizer: [
-          new TerserPlugin({
-            terserOptions: {
-              ecma: 2020,
-              sourceMap: false,
-              keep_classnames: true,
-              keep_fnames: true,
-              ie8: false,
-              safari10: false,
-              module: true
-            }
-          })
-        ],
-        moduleIds: "deterministic",
-        chunkIds: "deterministic",
-        emitOnErrors: false
-      },
-      externals: extModuleNames
-    });
-  }
-
-  private _findExternalModules(all: boolean): { name: string; path: string }[] {
+  private _getExternalModuleNames(): string[] {
     const loadedModuleNames: string[] = [];
-    const externalModules: { name: string; path: string }[] = [];
+    const resultSet = new Set<string>();
 
     const fn = (currPath: string): void => {
       const npmConfig = this._getNpmConfig(currPath);
       if (!npmConfig) return;
 
+      const moduleNames = [
+        ...Object.keys(npmConfig.dependencies ?? {}),
+        ...Object.keys(npmConfig.peerDependencies ?? {}).filter((item) => !npmConfig.peerDependenciesMeta?.[item].optional)
+      ];
+      const optModuleNames = [
+        ...Object.keys(npmConfig.optionalDependencies ?? {}),
+        ...Object.keys(npmConfig.peerDependencies ?? {}).filter((item) => npmConfig.peerDependenciesMeta?.[item].optional)
+      ].distinct();
 
-      for (const moduleName of SdCliNpmConfigUtil.getAllDependencies(npmConfig)) {
+      for (const moduleName of moduleNames) {
         if (loadedModuleNames.includes(moduleName)) continue;
         loadedModuleNames.push(moduleName);
 
         const modulePath = FsUtil.findAllParentChildDirPaths("node_modules/" + moduleName, currPath, this._workspaceRootPath).first();
-        if (StringUtil.isNullOrEmpty(modulePath)) continue;
+        if (StringUtil.isNullOrEmpty(modulePath)) {
+          continue;
+        }
 
-        if (all || FsUtil.exists(path.resolve(modulePath, "binding.gyp"))) {
-          externalModules.push({ path: modulePath, name: moduleName });
+        if (FsUtil.exists(path.resolve(modulePath, "binding.gyp"))) {
+          resultSet.add(moduleName);
         }
 
         fn(modulePath);
       }
+
+      for (const optModuleName of optModuleNames) {
+        if (loadedModuleNames.includes(optModuleName)) continue;
+        loadedModuleNames.push(optModuleName);
+
+        const optModulePath = FsUtil.findAllParentChildDirPaths("node_modules/" + optModuleName, currPath, this._workspaceRootPath).first();
+        if (StringUtil.isNullOrEmpty(optModulePath)) {
+          resultSet.add(optModuleName);
+          continue;
+        }
+
+        if (FsUtil.exists(path.resolve(optModulePath, "binding.gyp"))) {
+          resultSet.add(optModuleName);
+        }
+
+        fn(optModulePath);
+      }
     };
 
     fn(this._rootPath);
 
-    return externalModules.distinct();
+    return Array.from(resultSet.values());
   }
 
   private _getNpmConfig(pkgPath: string): INpmConfig | undefined {

package/src/builder/SdCliTsLibBuilder.ts

@@ -1,4 +1,4 @@
-import { ISdCliPackageBuildResult } from "../commons";
+import { INpmConfig, ISdCliPackageBuildResult } from "../commons";
 import { EventEmitter } from "events";
 import ts from "typescript";
 import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
@@ -11,6 +11,7 @@ import { SdCliPackageLinter } from "../build-tool/SdCliPackageLinter";
 import { SdCliCacheCompilerHost } from "../build-tool/SdCliCacheCompilerHost";
 import { SdCliNgCacheCompilerHost } from "../build-tool/SdCliNgCacheCompilerHost";
 import { NgCompiler } from "@angular/compiler-cli/src/ngtsc/core";
+import { SdCliNpmConfigUtil } from "../utils/SdCliNpmConfigUtil";
 
 export class SdCliTsLibBuilder extends EventEmitter {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
@@ -26,10 +27,26 @@ export class SdCliTsLibBuilder extends EventEmitter {
   private _ngProgram?: NgtscProgram;
   private _builder?: ts.EmitAndSemanticDiagnosticsBuilderProgram;
 
-  public constructor(private readonly _rootPath,
-                     private readonly _isAngular: boolean) {
+  private readonly _tsconfigFilePath: string;
+  private readonly _parsedTsconfig: ts.ParsedCommandLine;
+  private readonly _npmConfig: INpmConfig;
+
+  private readonly _isAngular: boolean;
+
+  public constructor(private readonly _rootPath) {
     super();
     this._linter = new SdCliPackageLinter(this._rootPath);
+
+    // tsconfig
+    this._tsconfigFilePath = path.resolve(this._rootPath, "tsconfig-build.json");
+    const tsconfig = FsUtil.readJson(this._tsconfigFilePath);
+    this._parsedTsconfig = ts.parseJsonConfigFileContent(tsconfig, ts.sys, this._rootPath);
+
+    // package.json
+    this._npmConfig = FsUtil.readJson(path.resolve(this._rootPath, "package.json"));
+
+    // else
+    this._isAngular = SdCliNpmConfigUtil.getDependencies(this._npmConfig).defaults.includes("@angular/core");
   }
 
   public override on(event: "change", listener: () => void): this;
@@ -41,18 +58,15 @@ export class SdCliTsLibBuilder extends EventEmitter {
   public async watchAsync(): Promise<void> {
     this.emit("change");
 
-    // TSCONFIG 읽기
-    const parsedTsconfig = await this._getParsedTsconfigAsync();
-
     // DIST 비우기
-    await FsUtil.removeAsync(parsedTsconfig.options.outDir!);
+    await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
     // 프로그램 리로드
-    const buildPack = this._createSdBuildPack(parsedTsconfig);
+    const buildPack = this._createSdBuildPack(this._parsedTsconfig);
 
     const relatedPaths = await this.getAllRelatedPathsAsync();
     const watcher = SdFsWatcher.watch(relatedPaths);
-    watcher.onChange(async (changeInfos) => {
+    watcher.onChange({}, async (changeInfos) => {
       const changeFilePaths = changeInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
       if (changeFilePaths.length === 0) return;
 
@@ -65,7 +79,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
       }
 
       // 빌드
-      const watchBuildPack = this._createSdBuildPack(parsedTsconfig);
+      const watchBuildPack = this._createSdBuildPack(this._parsedTsconfig);
 
       // 린트
       const watchBuildResults = await this._runBuilderAsync(watchBuildPack.builder, watchBuildPack.ngCompiler);
@@ -90,14 +104,11 @@ export class SdCliTsLibBuilder extends EventEmitter {
   }
 
   public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
-    // TSCONFIG 읽기
-    const parsedTsconfig = await this._getParsedTsconfigAsync();
-
     // DIST 비우기
-    await FsUtil.removeAsync(parsedTsconfig.options.outDir!);
+    await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
     // 프로그램 리로드
-    const buildPack = this._createSdBuildPack(parsedTsconfig);
+    const buildPack = this._createSdBuildPack(this._parsedTsconfig);
 
     // 빌드
     const buildResults = await this._runBuilderAsync(buildPack.builder, buildPack.ngCompiler);
@@ -312,12 +323,6 @@ export class SdCliTsLibBuilder extends EventEmitter {
       return compilerHost;
     }
   }
-
-  private async _getParsedTsconfigAsync(): Promise<ts.ParsedCommandLine> {
-    const tsconfigFilePath = path.resolve(this._rootPath, "tsconfig-build.json");
-    const tsconfig = await FsUtil.readJsonAsync(tsconfigFilePath);
-    return ts.parseJsonConfigFileContent(tsconfig, ts.sys, this._rootPath);
-  }
 }
 
 interface IFileCache {

package/src/commons.ts

@@ -15,6 +15,7 @@ export interface INpmConfig {
   optionalDependencies?: Record<string, string>;
   devDependencies?: Record<string, string>;
   peerDependencies?: Record<string, string>;
+  peerDependenciesMeta?: Record<string, { optional?: boolean }>;
 }
 
 export interface ITsconfig {
@@ -39,7 +40,7 @@ export interface ISdCliConfig {
   localUpdates?: Record<string, string>;
 }
 
-export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliServerPackageConfig;
+export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliServerPackageConfig | ISdCliClientPackageConfig;
 
 export interface ISdCliLibPackageConfig {
   type: "library";
@@ -49,4 +50,12 @@ export interface ISdCliLibPackageConfig {
 export interface ISdCliServerPackageConfig {
   type: "server";
   env?: Record<string, string>;
+  configs?: Record<string, any>;
+  pm2?: Record<string, any> | boolean;
+  iis?: { serverExeFilePath?: string } | boolean;
+}
+
+export interface ISdCliClientPackageConfig {
+  type: "client";
+  server: string;
 }

package/src/entry-points/SdCliLocalUpdate.ts

@@ -40,19 +40,25 @@ export class SdCliLocalUpdate {
     const watchPaths = (await updatePathInfos.mapManyAsync(async (item) => await this._getWatchPathsAsync(item.source))).distinct();
 
     const watcher = SdFsWatcher.watch(watchPaths);
-    watcher.onChange(async (changeInfos) => {
+    watcher.onChange({ delay: 1000 }, async (changeInfos) => {
       const changeFilePaths = changeInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
       if (changeFilePaths.length === 0) return;
 
       this._logger.log("로컬 라이브러리 변경감지...");
       for (const changedFilePath of changeFilePaths) {
-        const currentUpdatePathInfos = updatePathInfos.filter((item) => PathUtil.isChildPath(changedFilePath, item.source));
-        const targetFilePaths = currentUpdatePathInfos.map((item) => path.resolve(item.target, path.relative(item.source, changedFilePath)));
-        if (FsUtil.exists(changedFilePath)) {
-          this._logger.debug(`변경파일감지(복사): ${changedFilePath}`);
-          for (const targetFilePath of targetFilePaths) {
-            await FsUtil.copyAsync(changedFilePath, targetFilePath);
-          }
+        if (!FsUtil.exists(changedFilePath)) continue;
+
+        for (const updatePathInfo of updatePathInfos) {
+          if (!PathUtil.isChildPath(changedFilePath, updatePathInfo.source)) continue;
+
+          const sourceRelPath = path.relative(updatePathInfo.source, changedFilePath);
+          if (sourceRelPath.includes("node_modules")) continue;
+          if (sourceRelPath.includes("package.json")) continue;
+
+          const targetFilePath = path.resolve(updatePathInfo.target, sourceRelPath);
+
+          this._logger.debug(`변경파일감지(복사): ${changedFilePath} => ${targetFilePath}`);
+          await FsUtil.copyAsync(changedFilePath, targetFilePath);
         }
       }
 

package/src/entry-points/SdCliNpm.ts

@@ -8,11 +8,15 @@ export class SdCliNpm {
   }
 
   public async updateAsync(): Promise<void> {
-    this._logger.debug("업데이트할 패키지 확인...");
-    await SdProcess.execAsync("npm outdated", { cwd: this._rootPath });
+    try {
+      this._logger.debug("업데이트할 패키지 확인...");
+      await SdProcess.spawnAsync("npm outdated", { cwd: this._rootPath });
+    }
+    catch (err) {
+    }
 
     this._logger.debug("업데이트 시작...");
-    await SdProcess.execAsync("npm update", { cwd: this._rootPath });
+    await SdProcess.spawnAsync("npm update", { cwd: this._rootPath });
 
     this._logger.debug("sd-cli 준비...");
     await new SdCliPrepare().prepareAsync();

package/src/entry-points/SdCliPrepare.ts

@@ -1,4 +1,5 @@
 import { FsUtil, Logger } from "@simplysm/sd-core-node";
+import { fileURLToPath } from "url";
 
 export class SdCliPrepare {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
@@ -11,7 +12,7 @@ export class SdCliPrepare {
 
   private async _modifyTypescriptCodeForTypeCheckPerformanceWarning(): Promise<boolean> {
     const fileUrl = await import.meta.resolve!("typescript");
-    const filePath = fileUrl.replace(/^file:\/\/\//, "");
+    const filePath = fileURLToPath(fileUrl);
     const fileContent = await FsUtil.readFileAsync(filePath);
     const modifiedFileContent = fileContent.replace(`
         function checkSourceElement(node) {