@simplysm/sd-cli 12.13.20 → 12.13.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/sd-cli",
-  "version": "12.13.20",
+  "version": "12.13.23",
   "description": "심플리즘 패키지 - CLI",
   "author": "김석래",
   "repository": {
@@ -12,26 +12,26 @@
   "bin": "./dist/sd-cli.js",
   "type": "module",
   "dependencies": {
-    "@angular/build": "^20.2.1",
-    "@angular/compiler": "^20.2.3",
-    "@angular/compiler-cli": "^20.2.3",
-    "@anthropic-ai/sdk": "^0.60.0",
+    "@angular/build": "^20.2.2",
+    "@angular/compiler": "^20.2.4",
+    "@angular/compiler-cli": "^20.2.4",
+    "@anthropic-ai/sdk": "^0.61.0",
     "@electron/rebuild": "^4.0.1",
-    "@simplysm/sd-core-common": "12.13.20",
-    "@simplysm/sd-core-node": "12.13.20",
-    "@simplysm/sd-service-server": "12.13.20",
-    "@simplysm/sd-storage": "12.13.20",
+    "@simplysm/sd-core-common": "12.13.23",
+    "@simplysm/sd-core-node": "12.13.23",
+    "@simplysm/sd-service-server": "12.13.23",
+    "@simplysm/sd-storage": "12.13.23",
     "browserslist": "^4.25.4",
     "cordova": "^12.0.0",
-    "electron": "^37.4.0",
+    "electron": "^38.0.0",
     "electron-builder": "26.0.12",
     "esbuild": "0.25.9",
     "esbuild-sass-plugin": "^3.3.1",
-    "eslint": "^9.34.0",
+    "eslint": "^9.35.0",
     "glob": "^11.0.3",
     "node-stdlib-browser": "^1.3.1",
     "rxjs": "^7.8.2",
-    "sass": "^1.91.0",
+    "sass-embedded": "^1.92.1",
     "semver": "^7.7.2",
     "specifier-resolution-node": "^1.1.4",
     "ts-morph": "^26.0.0",

package/src/entry/{sd-cli-cordova.ts → SdCliCordova.ts}

@@ -1,8 +1,8 @@
 import * as path from "path";
 import { FsUtils, PathUtils, SdLogger, SdProcess } from "@simplysm/sd-core-node";
-import { INpmConfig } from "../types/common-configs.types";
-import { ISdClientBuilderCordovaConfig } from "../types/config.types";
+import { ISdClientBuilderCordovaConfig } from "../types/config/ISdProjectConfig";
 import { SdZip, XmlConvert } from "@simplysm/sd-core-common";
+import { INpmConfig } from "../types/common-config/INpmConfig";
 
 export class SdCliCordova {
   // 상수 정의

package/src/entry/{sd-cli-electron.ts → SdCliElectron.ts}

@@ -2,10 +2,10 @@ import { FsUtils, SdLogger, SdProcess } from "@simplysm/sd-core-node";
 import fs from "fs";
 import os from "os";
 import path from "path";
-import { INpmConfig } from "../types/common-configs.types";
-import { ISdClientBuilderElectronConfig } from "../types/config.types";
-import { loadProjConfAsync } from "./utils/loadProjConfAsync";
+import { ISdClientBuilderElectronConfig } from "../types/config/ISdProjectConfig";
+import { loadProjConfAsync } from "../utils/loadProjConfAsync";
 import electronBuilder from "electron-builder";
+import { INpmConfig } from "../types/common-config/INpmConfig";
 
 export class SdCliElectron {
   static #logger = SdLogger.get(["simplysm", "sd-cli", "SdCliElectron"]);

package/src/entry/{sd-cli-local-update.ts → SdCliLocalUpdate.ts}

@@ -1,6 +1,6 @@
 import { FsUtils, PathUtils, SdFsWatcher, SdLogger } from "@simplysm/sd-core-node";
 import path from "path";
-import { loadProjConfAsync } from "./utils/loadProjConfAsync";
+import { loadProjConfAsync } from "../utils/loadProjConfAsync";
 
 export class SdCliLocalUpdate {
   static async runAsync(opt: { config: string; options?: string[] }): Promise<void> {
@@ -11,7 +11,7 @@ export class SdCliLocalUpdate {
     if (!projConf.localUpdates) return;
 
     const updatePathInfos = this.#getUpdatePathInfos(projConf.localUpdates);
-    logger.debug("로컬 업데이트 구성", updatePathInfos);
+    logger.debug("로컬 업데이트 구성");
 
     logger.log("로컬 라이브러리 업데이트 시작...");
     for (const updatePathInfo of updatePathInfos) {
@@ -36,11 +36,13 @@ export class SdCliLocalUpdate {
     if (!projConf.localUpdates) return;
 
     const updatePathInfos = this.#getUpdatePathInfos(projConf.localUpdates);
-    logger.debug("로컬 업데이트 구성", updatePathInfos);
+    logger.debug("로컬 업데이트 구성");
 
     const watcher = SdFsWatcher.watch(updatePathInfos.map((item) => item.source));
     watcher.onChange({ delay: 1000 }, (changedInfos) => {
-      const changedFileInfos = changedInfos.filter((item) => ["add", "change", "unlink"].includes(item.event));
+      const changedFileInfos = changedInfos.filter((item) =>
+        ["add", "change", "unlink"].includes(item.event),
+      );
       if (changedFileInfos.length === 0) return;
 
       logger.log("로컬 라이브러리 변경감지...");

package/src/entry/{sd-cli-project.ts → SdCliProject.ts}

@@ -3,20 +3,19 @@ import { FsUtils, PathUtils, SdLogger, SdProcess } from "@simplysm/sd-core-node"
 import semver from "semver";
 import { NeverEntryError, StringUtils, Wait } from "@simplysm/sd-core-common";
 import { SdStorage } from "@simplysm/sd-storage";
-import { SdCliLocalUpdate } from "./sd-cli-local-update";
-import { SdMultiBuildRunner } from "../pkg-builders/sd-multi.build-runner";
-import { SdCliConvertMessageUtils } from "../utils/sd-cli-convert-message.utils";
-import { TSdPackageConfig } from "../types/config.types";
-import { INpmConfig } from "../types/common-configs.types";
-import { ISdBuildMessage } from "../types/build.types";
-import { loadProjConfAsync } from "./utils/loadProjConfAsync";
+import { SdCliLocalUpdate } from "./SdCliLocalUpdate";
+import { SdCliConvertMessageUtils } from "../utils/SdCliConvertMessageUtils";
+import { TSdPackageConfig } from "../types/config/ISdProjectConfig";
+import { ISdBuildMessage } from "../types/build/ISdBuildMessage";
+import { loadProjConfAsync } from "../utils/loadProjConfAsync";
+import { SdProjectBuildRunner } from "../pkg-builders/SdProjectBuildRunner";
+import { INpmConfig } from "../types/common-config/INpmConfig";
 
 export class SdCliProject {
   static async watchAsync(opt: {
     config: string;
     options?: string[];
     packages?: string[];
-    inspects?: string[];
     emitOnly?: boolean;
     noEmit?: boolean;
   }): Promise<void> {
@@ -33,14 +32,17 @@ export class SdCliProject {
     }
 
     logger.debug("프로젝트 package.json 가져오기...");
-    const projNpmConf = FsUtils.readJson(path.resolve(process.cwd(), "package.json")) as INpmConfig;
+    const projNpmConf = (await FsUtils.readJsonAsync(
+      path.resolve(process.cwd(), "package.json"),
+    )) as INpmConfig;
 
     logger.debug("패키지 목록 구성...");
     if (!projNpmConf.workspaces) {
       throw new Error("프로젝트 package.json에 workspaces가 설정되어있지 않습니다.");
     }
-    const allPkgPaths = projNpmConf.workspaces
-      .mapMany((item) => FsUtils.glob(item))
+    const allPkgPaths = (
+      await projNpmConf.workspaces.mapManyAsync(async (item) => await FsUtils.globAsync(item))
+    )
       .filter((item) => !item.includes("."))
       .map((item) => PathUtils.norm(item));
     let pkgPaths = allPkgPaths.filter((pkgPath) => path.basename(pkgPath) in projConf.packages);
@@ -56,29 +58,17 @@ export class SdCliProject {
       throw new Error("패키지를 찾을 수 없습니다. (" + notExistsPkgs.join(", ") + ")");
     }
 
-    logger.debug("빌드 프로세스 시작...");
-    const multiBuildRunner = new SdMultiBuildRunner()
-      .on("change", () => {
+    await SdProjectBuildRunner.watchAsync({
+      pkgPaths,
+      projConf,
+      emitOnly: opt.emitOnly ?? false,
+      noEmit: opt.noEmit ?? false,
+      onChange: () => {
         logger.debug("빌드를 시작합니다...");
-      })
-      .on("complete", (messages) => {
+      },
+      onComplete: (messages) => {
         this.#logging(messages, logger);
-      });
-
-    await pkgPaths.parallelAsync(async (pkgPath) => {
-      const pkgConf = projConf.packages[path.basename(pkgPath)];
-      if (pkgConf?.type === "library" && pkgConf.noBuild) {
-        return;
-      }
-
-      await multiBuildRunner.runAsync({
-        cmd: "watch",
-        pkgPath,
-        projConf: projConf,
-        workspaces: projNpmConf.workspaces!,
-        emitOnly: opt.emitOnly ?? false,
-        noEmit: opt.noEmit ?? false,
-      });
+      },
     });
   }
 
@@ -87,48 +77,47 @@ export class SdCliProject {
     options?: string[];
     packages?: string[];
   }): Promise<void> {
-    const logger = SdLogger.get(["simplysm", "sd-cli", "SdCliProject", "buildAsync"]);
+    const logger = SdLogger.get(["simplysm", "sd-cli", "SdCliProject", "watchAsync"]);
 
     logger.debug("프로젝트 설정 가져오기...");
-    const projConf = await loadProjConfAsync(process.cwd(), false, opt);
+    const projConf = await loadProjConfAsync(process.cwd(), true, opt);
 
     logger.debug("프로젝트 package.json 가져오기...");
-    const projNpmConf = FsUtils.readJson(path.resolve(process.cwd(), "package.json")) as INpmConfig;
+    const projNpmConf = (await FsUtils.readJsonAsync(
+      path.resolve(process.cwd(), "package.json"),
+    )) as INpmConfig;
 
     logger.debug("패키지 목록 구성...");
     if (!projNpmConf.workspaces) {
       throw new Error("프로젝트 package.json에 workspaces가 설정되어있지 않습니다.");
     }
-    const allPkgPaths = projNpmConf.workspaces
-      .mapMany((item) => FsUtils.glob(item))
+    const allPkgPaths = (
+      await projNpmConf.workspaces.mapManyAsync(async (item) => await FsUtils.globAsync(item))
+    )
+      .filter((item) => !item.includes("."))
       .map((item) => PathUtils.norm(item));
     let pkgPaths = allPkgPaths.filter((pkgPath) => path.basename(pkgPath) in projConf.packages);
     if (opt.packages) {
       pkgPaths = pkgPaths.filter((pkgPath) => opt.packages!.includes(path.basename(pkgPath)));
     }
 
+    logger.debug("패키지 존재 확인...");
+    const notExistsPkgs = Object.keys(projConf.packages).filter((pkgConfKey) =>
+      allPkgPaths.every((pkgPath) => path.basename(pkgPath) !== pkgConfKey),
+    );
+    if (notExistsPkgs.length > 0) {
+      throw new Error("패키지를 찾을 수 없습니다. (" + notExistsPkgs.join(", ") + ")");
+    }
+
     logger.debug("프로젝트 및 패키지 버전 설정...");
     this.#upgradeVersion(projNpmConf, allPkgPaths);
 
     logger.debug("빌드 프로세스 시작...");
-    const multiBuildRunner = new SdMultiBuildRunner();
-
-    const messages = await pkgPaths.parallelAsync(async (pkgPath) => {
-      const pkgConf = projConf.packages[path.basename(pkgPath)];
-      if (pkgConf?.type === "library" && pkgConf.noBuild) {
-        return [];
-      }
-
-      return await multiBuildRunner.runAsync({
-        cmd: "build",
-        pkgPath,
-        projConf: projConf,
-        workspaces: projNpmConf.workspaces!,
-        emitOnly: false,
-        noEmit: false,
-      });
+    const messages = await SdProjectBuildRunner.buildAsync({
+      pkgPaths,
+      projConf,
     });
-    this.#logging(messages.mapMany(), logger);
+    this.#logging(messages, logger);
   }
 
   static async publishAsync(opt: {
@@ -172,6 +161,14 @@ export class SdCliProject {
       pkgPaths = pkgPaths.filter((pkgPath) => opt.packages!.includes(path.basename(pkgPath)));
     }
 
+    logger.debug("패키지 존재 확인...");
+    const notExistsPkgs = Object.keys(projConf.packages).filter((pkgConfKey) =>
+      allPkgPaths.every((pkgPath) => path.basename(pkgPath) !== pkgConfKey),
+    );
+    if (notExistsPkgs.length > 0) {
+      throw new Error("패키지를 찾을 수 없습니다. (" + notExistsPkgs.join(", ") + ")");
+    }
+
     if (!opt.noBuild) {
       logger.debug("프로젝트 및 패키지 버전 설정...");
       this.#upgradeVersion(projNpmConf, allPkgPaths);
@@ -179,25 +176,12 @@ export class SdCliProject {
       // 빌드
       try {
         logger.debug("빌드 프로세스 시작...");
-        const multiBuildRunner = new SdMultiBuildRunner();
-
-        const messages = await pkgPaths.parallelAsync(async (pkgPath) => {
-          const pkgConf = projConf.packages[path.basename(pkgPath)];
-          if (pkgConf?.type === "library" && pkgConf.noBuild) {
-            return [];
-          }
-
-          return await multiBuildRunner.runAsync({
-            cmd: "build",
-            pkgPath,
-            projConf: projConf,
-            workspaces: projNpmConf.workspaces!,
-            emitOnly: false,
-            noEmit: false,
-          });
+        const messages = await SdProjectBuildRunner.buildAsync({
+          pkgPaths,
+          projConf,
         });
 
-        this.#logging(messages.mapMany(), logger);
+        this.#logging(messages, logger);
       } catch (err) {
         await SdProcess.spawnAsync("git", ["checkout", "."]);
         throw err;

package/src/pkg-builders/SdProjectBuildRunner.ts

@@ -0,0 +1,347 @@
+import {
+  FsUtils,
+  PathUtils,
+  SdFsWatcher,
+  SdLogger,
+  SdWorker,
+  TNormPath,
+} from "@simplysm/sd-core-node";
+import { ISdProjectConfig, ISdServerPackageConfig } from "../types/config/ISdProjectConfig";
+import path from "path";
+import { ISdBuildMessage } from "../types/build/ISdBuildMessage";
+import { ISdBuildRunnerWorkerType } from "../types/worker/ISdBuildRunnerWorkerType";
+import { IServerWorkerType } from "../types/worker/IServerWorkerType";
+import { INpmConfig } from "../types/common-config/INpmConfig";
+
+export class SdProjectBuildRunner {
+  static #logger = SdLogger.get(["simplysm", "sd-cli", "SdProjectBuildRunner"]);
+
+  static #buildInfoMap = new Map<
+    TNormPath,
+    {
+      buildWorker: SdWorker<ISdBuildRunnerWorkerType>;
+      watchFileSet: Set<TNormPath>;
+    }
+  >();
+
+  static #serverInfoMap = new Map<
+    string,
+    {
+      worker?: SdWorker<any>;
+      port?: number;
+      clientMap?: Map<
+        string,
+        {
+          distPath: string;
+          buildTypes: ("web" | "electron" | "cordova")[];
+        }
+      >;
+    }
+  >();
+
+  static #resultCache = new Map<TNormPath, ISdBuildMessage[]>();
+
+  static async watchAsync(opt: {
+    pkgPaths: TNormPath[];
+    projConf: ISdProjectConfig;
+    emitOnly: boolean;
+    noEmit: boolean;
+    onChange: () => void;
+    onComplete: (buildMessages: ISdBuildMessage[]) => void;
+  }) {
+    const scopePathSet = await this.#getScopePathSetAsync(
+      opt.pkgPaths,
+      Object.keys(opt.projConf.localUpdates ?? {}),
+    );
+
+    const watcher = SdFsWatcher.watch(Array.from(scopePathSet), {
+      ignoreInitial: false,
+    });
+    watcher.onChange({ delay: 300 }, async (changeInfos) => {
+      // 변경된 패키지 정보 구성
+      const changeFiles = changeInfos.map((item) => PathUtils.norm(item.path));
+      const changedPkgInfos = opt.pkgPaths
+        .map((pkgPath) => {
+          let buildInfo = this.#buildInfoMap.get(pkgPath);
+          if (!buildInfo) return { pkgPath };
+
+          const modifiedFileSet = new Set(
+            changeFiles.filter((item) => buildInfo.watchFileSet.has(item)),
+          );
+
+          if (modifiedFileSet.size < 1) return;
+
+          return { pkgPath, buildInfo: buildInfo, modifiedFileSet };
+        })
+        .filterExists();
+      if (changedPkgInfos.length < 1) return;
+
+      // 변경된 패키지들에 대한 change처리
+      opt.onChange();
+      const buildResults = await changedPkgInfos.parallelAsync(async (changedPkgInfo) => {
+        // 처음
+        if (!changedPkgInfo.buildInfo) {
+          const buildWorker = new SdWorker<ISdBuildRunnerWorkerType>(
+            import.meta.resolve("../workers/build-runner.worker"),
+          );
+          await buildWorker.run("initialize", [
+            {
+              pkgPath: changedPkgInfo.pkgPath,
+              projConf: opt.projConf,
+              watch: true,
+              emitOnly: opt.emitOnly,
+              noEmit: opt.noEmit,
+              scopePathSet: scopePathSet,
+            },
+          ]);
+
+          const result = await buildWorker.run("rebuild", []);
+
+          this.#buildInfoMap.set(changedPkgInfo.pkgPath, {
+            buildWorker,
+            watchFileSet: result.watchFileSet,
+          });
+
+          return {
+            isFirst: true,
+            pkgPath: changedPkgInfo.pkgPath,
+            emitFileSet: result.emitFileSet,
+            affectedFileSet: result.affectedFileSet,
+
+            buildMessages: result.buildMessages,
+          };
+        }
+        // changed
+        else {
+          const result = await changedPkgInfo.buildInfo.buildWorker.run("rebuild", [
+            changedPkgInfo.modifiedFileSet,
+          ]);
+          changedPkgInfo.buildInfo.watchFileSet = result.watchFileSet;
+
+          return {
+            isFirst: false,
+            pkgPath: changedPkgInfo.pkgPath,
+            emitFileSet: result.emitFileSet,
+            affectedFileSet: result.affectedFileSet,
+
+            buildMessages: result.buildMessages,
+          };
+        }
+      });
+
+      if (!opt.noEmit) {
+        // 서버 구성 및 재시작
+        for (const buildResult of buildResults) {
+          const pkgConf = opt.projConf.packages[path.basename(buildResult.pkgPath)]!;
+          if (pkgConf.type === "server") {
+            const serverName = path.basename(buildResult.pkgPath);
+            this.#logger.debug(`서버 '${serverName}' 재시작...`);
+
+            const serverInfo = this.#serverInfoMap.getOrCreate(serverName, {});
+            const restartServerResult = await this.#restartServerAsync(
+              serverInfo.worker,
+              buildResult.pkgPath,
+              pkgConf,
+            );
+            serverInfo.worker = restartServerResult.worker;
+            serverInfo.port = restartServerResult.port;
+
+            /*await serverInfo.worker.run("addPathProxy", [
+              "node_modules",
+              path.resolve(process.cwd(), "node_modules"),
+            ]);
+            if (serverInfo.clientMap) {
+              for (const [clientName, clientInfo] of serverInfo.clientMap.entries()) {
+                await serverInfo.worker.run("addPathProxy", [clientName, clientInfo.path]);
+              }
+            }*/
+          } else if (pkgConf.type === "client" && typeof pkgConf.server === "object") {
+            const serverName = pkgConf.server.port.toString();
+            this.#logger.debug(`서버 '${serverName}' 재시작...`);
+
+            const serverInfo = this.#serverInfoMap.getOrCreate(serverName, {});
+            const restartServerResult = await this.#restartServerAsync(
+              serverInfo.worker,
+              buildResult.pkgPath,
+              pkgConf.server.port,
+            );
+            serverInfo.worker = restartServerResult.worker;
+            serverInfo.port = restartServerResult.port;
+
+            /*await worker.run("addPathProxy", [
+              "node_modules",
+              path.resolve(process.cwd(), "node_modules"),
+            ]);*/
+          }
+        }
+
+        // 클라이언트 구성 및 변경 Reload
+        for (const buildResult of buildResults) {
+          const pkgConf = opt.projConf.packages[path.basename(buildResult.pkgPath)]!;
+          if (pkgConf.type === "client") {
+            const clientName = path.basename(buildResult.pkgPath);
+            const serverKey =
+              typeof pkgConf.server === "string"
+                ? pkgConf.server
+                : typeof pkgConf.server === "object"
+                  ? pkgConf.server.port.toString()
+                  : undefined;
+            if (serverKey == null) continue;
+
+            const serverInfo = this.#serverInfoMap.get(serverKey);
+            if (!serverInfo || !serverInfo.worker) continue;
+
+            const distPath = path.resolve(buildResult.pkgPath, "dist");
+            serverInfo.clientMap = serverInfo.clientMap ?? new Map();
+            serverInfo.clientMap.set(clientName, {
+              distPath,
+              buildTypes: (pkgConf.builder ? Object.keys(pkgConf.builder) : ["web"]) as any,
+            });
+
+            if (buildResult.isFirst) continue;
+
+            this.#logger.debug(`클라이언트 '${clientName}' 새로고침...`);
+            await serverInfo.worker.run("broadcastReload", [
+              clientName,
+              new Set(
+                Array.from(buildResult.emitFileSet)
+                  .filter((item) => !item.endsWith(".map"))
+                  .map((item) => path.relative(distPath, item)),
+              ),
+            ]);
+          }
+        }
+
+        // 서버 Proxy 설정
+        for (const serverInfo of this.#serverInfoMap.values()) {
+          if (!serverInfo.worker) continue;
+
+          await serverInfo.worker.run("setPathProxy", [
+            {
+              ...Array.from(serverInfo.clientMap?.entries() ?? []).toObject(
+                (entry) => entry[0],
+                (entry) => entry[1].distPath,
+              ),
+              node_modules: path.resolve(process.cwd(), "node_modules"),
+            },
+          ]);
+        }
+
+        // 접속주소 logging
+        for (const serverName of this.#serverInfoMap.keys()) {
+          const serverInfo = this.#serverInfoMap.get(serverName);
+          const clientPaths: string[] = [];
+          for (const [clientName, clientInfo] of serverInfo?.clientMap?.entries() ?? []) {
+            for (const buildType of clientInfo.buildTypes) {
+              if (buildType === "web") {
+                clientPaths.push(`http://localhost:${serverInfo!.port}/${clientName}/`);
+              } else {
+                clientPaths.push(`http://localhost:${serverInfo!.port}/${clientName}/${buildType}`);
+              }
+            }
+          }
+
+          this.#logger.info("클라이언트 개발 서버 접속 주소\n" + clientPaths.join("\n"));
+        }
+      }
+
+      // 빌드 완료 이벤트
+
+      for (const buildResult of buildResults) {
+        this.#resultCache.delete(buildResult.pkgPath);
+        for (const affectedFilePath of buildResult.affectedFileSet) {
+          this.#resultCache.delete(affectedFilePath);
+        }
+
+        for (const buildMessage of buildResult.buildMessages) {
+          if (
+            !buildMessage.filePath ||
+            PathUtils.isChildPath(buildMessage.filePath, buildResult.pkgPath)
+          ) {
+            const cacheItem = this.#resultCache.getOrCreate(
+              buildMessage.filePath ?? buildResult.pkgPath,
+              [],
+            );
+            cacheItem.push(buildMessage);
+          }
+        }
+      }
+
+      opt.onComplete(Array.from(this.#resultCache.values()).mapMany());
+    });
+  }
+
+  static async buildAsync(opt: { pkgPaths: TNormPath[]; projConf: ISdProjectConfig }) {
+    const buildResults = await opt.pkgPaths.parallelAsync(async (pkgPath) => {
+      const worker = new SdWorker<ISdBuildRunnerWorkerType>(
+        import.meta.resolve("../workers/build-runner.worker"),
+      );
+
+      await worker.run("initialize", [
+        {
+          pkgPath,
+          projConf: opt.projConf,
+        },
+      ]);
+
+      const result = await worker.run("rebuild", []);
+      await worker.killAsync();
+      return {
+        buildMessages: result.buildMessages,
+      };
+    });
+
+    return buildResults.mapMany((item) => item.buildMessages);
+  }
+
+  static async #getScopePathSetAsync(pkgPaths: TNormPath[], localUpdateGlobs: string[]) {
+    const workspacePaths = pkgPaths.mapMany((item) => [
+      path.resolve(item, "src"),
+      path.resolve(item, "public"),
+      path.resolve(item, "public-dev"),
+    ]);
+    const localUpdatePaths = (
+      await localUpdateGlobs.mapManyAsync(
+        async (key) => await FsUtils.globAsync(path.resolve(process.cwd(), "node_modules", key)),
+      )
+    ).mapMany((key) => [
+      path.resolve(process.cwd(), "node_modules", key, "dist"),
+      path.resolve(process.cwd(), "node_modules", key, "src/**/*.scss"),
+    ]);
+
+    return new Set([...workspacePaths, ...localUpdatePaths].map((item) => PathUtils.norm(item)));
+  }
+
+  static async #restartServerAsync(
+    prevWorker: SdWorker<IServerWorkerType> | undefined,
+    pkgPath: string,
+    pkgConfOrPort: ISdServerPackageConfig | number,
+  ): Promise<{
+    worker: SdWorker<IServerWorkerType>;
+    port: number;
+  }> {
+    if (prevWorker) {
+      await prevWorker.killAsync();
+    }
+
+    const npmConf = FsUtils.readJson(path.resolve(pkgPath, "package.json")) as INpmConfig;
+
+    const worker = new SdWorker<IServerWorkerType>(
+      import.meta.resolve("../workers/server.worker"),
+      {
+        env: {
+          NODE_ENV: "development",
+          TZ: "Asia/Seoul",
+          SD_VERSION: npmConf.version,
+          ...(typeof pkgConfOrPort === "number" ? {} : pkgConfOrPort.env),
+        },
+      },
+    );
+    const port = await worker.run("listen", [
+      typeof pkgConfOrPort === "number" ? pkgConfOrPort : pkgPath,
+    ]);
+    this.#logger.debug("서버가 시작되었습니다.");
+
+    return { worker, port };
+  }
+}