@simplysm/sd-cli 14.0.11 → 14.0.12

package/src/utils/vite-config.ts

@@ -1,6 +1,5 @@
 import type { InlineConfig, PluginOption } from "vite";
 import path from "path";
-import { pathx } from "@simplysm/core-node";
 import tsconfigPaths from "vite-tsconfig-paths";
 import browserslistToEsbuild from "browserslist-to-esbuild";
 import { sdAngularPlugin } from "../angular/vite-angular-plugin.js";
@@ -36,7 +35,7 @@ export interface CreateClientViteConfigOptions {
     warnings?: string[];
     lint?: { success: boolean; errorCount: number; warningCount: number; formattedOutput: string };
   }) => void;
-  /** Enable lint using ts.Program from compilation */
+  /** 컴파일의 ts.Program을 사용하여 lint 실행 */
   enableLint?: boolean;
   /** replaceDeps 목록 (dev 모드에서 sdScopeWatchPlugin에 전달) */
   replaceDeps?: ScopeWatchReplaceDep[];
@@ -48,18 +47,21 @@ export interface CreateClientViteConfigOptions {
   postCssPlugins?: unknown[];
   /** polyfills 경로 배열 (transformIndexHtml로 주입) */
   polyfills?: string[];
-  /** legacy module support (disables code splitting + replaces import.meta) */
+  /** 레거시 모듈 지원 (코드 스플리팅 비활성화) */
   legacyModule?: boolean;
   /** PWA 설정. false로 비활성화. 미설정 시 기본값으로 활성화 */
   pwa?: false | SdPwaConfig;
+  /** Vite optimizeDeps.exclude에 전달할 패키지 목록 */
+  exclude?: string[];
+  /** watch 모드 (build.watch 활성화, emptyOutDir: false) */
+  watch?: boolean;
 }
 
 /**
  * Client Vite 설정을 생성한다. dev/build 모드에서 공용으로 사용한다.
  *
- * Feature 3.1 범위: sdAngularPlugin, tsconfigPaths, env define, server/build 기본 설정
- * Feature 5.1: browserslist, PostCSS, polyfills
- * Feature 1.1: legacyModule (import.meta 치환 + inlineDynamicImports)
+ * Angular AOT 플러그인, tsconfigPaths, env define, server/build 기본 설정,
+ * browserslist, PostCSS, polyfills, legacyModule (inlineDynamicImports) 등을 통합 구성한다.
  */
 export async function createClientViteConfig(
   options: CreateClientViteConfigOptions,
@@ -112,8 +114,12 @@ export async function createClientViteConfig(
     );
   }
 
-  // replaceDeps HMR (dev 모드만)
-  if (options.mode === "dev" && options.replaceDeps != null && options.replaceDeps.length > 0) {
+  // replaceDeps HMR (dev 모드 또는 watch 모드)
+  if (
+    (options.mode === "dev" || options.watch === true) &&
+    options.replaceDeps != null &&
+    options.replaceDeps.length > 0
+  ) {
     plugins.push(
       sdScopeWatchPlugin({
         pkgDir: options.pkgDir,
@@ -127,7 +133,7 @@ export async function createClientViteConfig(
   const serverConfig =
     options.mode === "dev"
       ? {
-          host: options.serverPort === 0 ? "127.0.0.1" : undefined,
+          host: options.serverPort === 0 ? "127.0.0.1" : "0.0.0.0",
           port: options.serverPort === 0 ? undefined : options.serverPort,
           strictPort: options.serverPort !== 0,
         }
@@ -139,6 +145,12 @@ export async function createClientViteConfig(
       ? { postcss: { plugins: options.postCssPlugins as import("postcss").AcceptedPlugin[] } }
       : undefined;
 
+  // optimizeDeps.exclude (사용자 지정 exclude)
+  const optimizeDepsConfig =
+    options.exclude != null && options.exclude.length > 0
+      ? { exclude: options.exclude }
+      : undefined;
+
   const config: InlineConfig = {
     root: options.pkgDir,
     base: `/${name}/`,
@@ -149,6 +161,15 @@ export async function createClientViteConfig(
     esbuild: {
       target: esbuildTarget,
     },
+    build: {
+      target: esbuildTarget,
+    },
+    optimizeDeps: {
+      ...optimizeDepsConfig,
+      esbuildOptions: {
+        target: esbuildTarget as string[],
+      },
+    },
   };
 
   // PWA (build 모드 + pwa !== false)
@@ -207,8 +228,15 @@ export async function createClientViteConfig(
     });
   }
 
-  // legacyModule: true → 단일 번들 + import.meta 치환
+  // legacyModule: true → 코드 스플리팅 비활성화 + esbuild import.meta/import() 변환 활성화
   if (options.legacyModule === true) {
+    config.esbuild = {
+      ...config.esbuild,
+      supported: {
+        "import-meta": false,
+        "dynamic-import": false,
+      },
+    };
     config.build = {
       ...config.build,
       rollupOptions: {
@@ -217,39 +245,21 @@ export async function createClientViteConfig(
         },
       },
     };
-
-    const pkgDir = options.pkgDir;
-    const base = `/${name}/`;
-
-    (config.plugins as PluginOption[]).push({
-      name: "sd-legacy-import-meta",
-      enforce: "post",
-      transform(code: string, id: string) {
-        if (!code.includes("import.meta")) return;
-
-        // id(파일 경로)를 Vite 서빙 URL로 변환
-        const relative = pathx.posix(path.relative(pkgDir, id));
-        const moduleUrl = id.startsWith("/") || id.startsWith("\0")
-          ? id // 가상 모듈(/@vite/client 등)은 그대로 사용
-          : base + relative;
-
-        const varName = "__sd_import_meta__";
-        const injected = `const ${varName} = { url: new URL(${JSON.stringify(moduleUrl)}, document.baseURI).href };\n`;
-        const replaced = code.replaceAll("import.meta", varName);
-
-        return { code: injected + replaced, map: null };
-      },
-    });
   }
 
   // build 모드 설정
   if (options.mode === "build") {
-    config.logLevel = "silent";
     config.build = {
       ...config.build,
       outDir: path.join(options.pkgDir, "dist"),
-      emptyOutDir: true,
     };
+    if (options.watch === true) {
+      config.build.watch = {};
+      config.build.emptyOutDir = false;
+    } else {
+      config.logLevel = "silent";
+      config.build.emptyOutDir = true;
+    }
   }
 
   return config;

package/src/utils/vite-scope-watch-plugin.ts

@@ -44,7 +44,12 @@ export function sdScopeWatchPlugin(options: SdScopeWatchPluginOptions): Plugin {
 
       const watchPaths: string[] = [];
       for (const dep of options.replaceDeps) {
-        const distDir = path.join(dep.sourcePath, "dist");
+        const distDir = path.join(
+          options.pkgDir,
+          "node_modules",
+          ...dep.packageName.split("/"),
+          "dist",
+        );
         if (fs.existsSync(distDir)) {
           watchPaths.push(distDir);
         }

package/src/utils/worker-events.ts

@@ -6,24 +6,24 @@ import { formatBuildMessages } from "./output-utils";
 
 const workerEventsLogger = consola.withTag("sd:cli:worker-events");
 
-/** Worker build completion event data */
+/** 워커 빌드 완료 이벤트 데이터 */
 export interface BuildEventData {
   success: boolean;
   errors?: string[];
   warnings?: string[];
 }
 
-/** Worker error event data */
+/** 워커 에러 이벤트 데이터 */
 export interface ErrorEventData {
   message: string;
 }
 
-/** Worker server ready event data */
+/** 워커 서버 준비 완료 이벤트 데이터 */
 export interface ServerReadyEventData {
   port: number;
 }
 
-/** Server Build completion event data */
+/** Server 빌드 완료 이벤트 데이터 */
 export interface ServerBuildEventData {
   success: boolean;
   mainJsPath: string;
@@ -32,7 +32,7 @@ export interface ServerBuildEventData {
 }
 
 /**
- * Base Worker info type
+ * 기본 Worker 정보 타입
  */
 export interface BaseWorkerInfo<TEvents extends Record<string, unknown> = Record<string, unknown>> {
   name: string;
@@ -46,7 +46,7 @@ export interface BaseWorkerInfo<TEvents extends Record<string, unknown> = Record
 }
 
 /**
- * Worker event handler options
+ * 워커 이벤트 핸들러 옵션
  */
 export interface WorkerEventHandlerOptions {
   resultKey: string;
@@ -55,13 +55,13 @@ export interface WorkerEventHandlerOptions {
 }
 
 /**
- * Register common Worker event handlers (buildStart, build, error only - serverReady not included)
+ * 공통 Worker 이벤트 핸들러를 등록한다 (buildStart, build, error만 — serverReady 미포함)
  *
- * @param workerInfo Worker info
- * @param opts Handler options
- * @param results Result map
- * @param rebuildManager Rebuild manager
- * @returns completeTask function (saves result and signals build completion)
+ * @param workerInfo 워커 정보
+ * @param opts 핸들러 옵션
+ * @param results 결과 맵
+ * @param rebuildManager 재빌드 매니저
+ * @returns completeTask 함수 (결과 저장 및 빌드 완료 신호)
  */
 export function registerWorkerEventHandlers(
   workerInfo: {
@@ -85,18 +85,18 @@ export function registerWorkerEventHandlers(
     workerInfo.isInitialBuild = false;
   };
 
-  // Build start (on rebuild)
+  // 빌드 시작 (재빌드 시)
   workerInfo.worker.on("buildStart", () => {
     if (!workerInfo.isInitialBuild) {
       workerInfo.buildResolver = rebuildManager.registerBuild(opts.resultKey, opts.listrTitle);
     }
   });
 
-  // Build completion
+  // 빌드 완료
   workerInfo.worker.on("build", (data) => {
     workerEventsLogger.debug(`[${workerInfo.name}] build: success=${String(data.success)}`);
 
-    // Print warnings
+    // 경고 출력
     if (data.warnings != null && data.warnings.length > 0) {
       workerEventsLogger.warn(
         formatBuildMessages(workerInfo.name, workerInfo.config.target, data.warnings),
@@ -112,7 +112,7 @@ export function registerWorkerEventHandlers(
     });
   });
 
-  // Error
+  // 에러
   workerInfo.worker.on("error", (data) => {
     workerEventsLogger.debug(`[${workerInfo.name}] error: ${data.message}`);
     completeTask({

package/src/utils/worker-utils.ts

@@ -2,11 +2,11 @@ import consola, { type ConsolaInstance, LogLevels } from "consola";
 import { SdCliReporter } from "./SdCliReporter";
 
 /**
- * Apply sd-cli reporter and debug log level in worker threads
+ * 워커 스레드에서 sd-cli 리포터와 디버그 로그 레벨을 적용한다.
  *
- * Checks the SD_DEBUG environment variable (set by --debug flag in main process)
- * and applies debug log level to consola in the current worker thread.
- * Must be called at worker module top level.
+ * SD_DEBUG 환경변수(메인 프로세스의 --debug 플래그로 설정)를 확인하고
+ * 현재 워커 스레드의 consola에 디버그 로그 레벨을 적용한다.
+ * 워커 모듈 최상위에서 호출해야 한다.
  */
 export function applyDebugLevel(): void {
   consola.options.reporters = [new SdCliReporter()];
@@ -16,14 +16,13 @@ export function applyDebugLevel(): void {
 }
 
 /**
- * Register cleanup handlers for worker process shutdown signals
+ * 워커 프로세스 종료 시그널에 대한 정리 핸들러를 등록한다.
  *
- * Registers SIGINT and SIGTERM handlers to gracefully cleanup resources
- * before process exit. Both handlers execute the cleanup function and
- * exit with code 0.
+ * 프로세스 종료 전 리소스를 정상적으로 정리하기 위해 SIGINT와 SIGTERM 핸들러를 등록한다.
+ * 두 핸들러 모두 정리 함수를 실행하고 코드 0으로 종료한다.
  *
- * @param cleanup - Cleanup function to execute on shutdown (sync or async)
- * @param logger - Consola logger instance for error logging
+ * @param cleanup - 종료 시 실행할 정리 함수 (동기 또는 비동기)
+ * @param logger - 에러 로깅용 consola 로거 인스턴스
  */
 export function registerCleanupHandlers(
   cleanup: () => void | Promise<void>,
@@ -45,10 +44,10 @@ export function registerCleanupHandlers(
 }
 
 /**
- * Create guard to prevent duplicate calls to Worker function
+ * Worker 함수의 중복 호출을 방지하는 가드를 생성한다.
  *
- * @param label - Function name to use in error message
- * @returns Guard function that throws error if called twice
+ * @param label - 에러 메시지에 사용할 함수명
+ * @returns 두 번 호출되면 에러를 던지는 가드 함수
  */
 export function createOnceGuard(label: string): () => void {
   let called = false;

package/src/vitest-plugin.ts

@@ -1,6 +1,7 @@
 import type { Plugin } from "vite";
 import path from "path";
 import ts from "typescript";
+import { pathx } from "@simplysm/core-node";
 import { NgtscProgram, type AngularLibraryHostExtensions } from "./utils/angular-build";
 import { compileScssString, compileScssFile } from "./utils/scss-compiler";
 
@@ -48,7 +49,7 @@ export function angularVitestPlugin(options: AngularVitestPluginOptions): Plugin
 
       const host = ts.createCompilerHost(compilerOptions);
 
-      // AngularLibraryHostExtensions duck-typing
+      // AngularLibraryHostExtensions 덕 타이핑
       const hostExt = host as ts.CompilerHost & AngularLibraryHostExtensions;
       hostExt.readResource = (fileName: string) => ts.sys.readFile(fileName) ?? "";
 
@@ -95,12 +96,12 @@ export function angularVitestPlugin(options: AngularVitestPluginOptions): Plugin
       const { transformers } = program.compiler.prepareEmit();
       const tsProgram = program.getTsProgram();
 
-      // per-file emit
+      // 파일별 emit
       for (const filePath of sourceFiles) {
         const sf = tsProgram.getSourceFile(filePath);
         if (sf == null) continue;
 
-        currentSourcePath = normalizePath(filePath);
+        currentSourcePath = pathx.posix(filePath);
         tsProgram.emit(sf, host.writeFile, undefined, false, transformers);
       }
     },
@@ -110,7 +111,7 @@ export function angularVitestPlugin(options: AngularVitestPluginOptions): Plugin
         return undefined;
       }
 
-      const compiled = compiledFiles.get(normalizePath(id));
+      const compiled = compiledFiles.get(pathx.posix(id));
       if (compiled == null) {
         return undefined;
       }
@@ -119,7 +120,3 @@ export function angularVitestPlugin(options: AngularVitestPluginOptions): Plugin
     },
   };
 }
-
-function normalizePath(p: string): string {
-  return p.replace(/\\/g, "/");
-}

package/src/workers/client.worker.ts

@@ -1,6 +1,8 @@
 import { createServer, build as viteBuild, type ViteDevServer } from "vite";
 import path from "path";
 import fs from "node:fs";
+import http from "node:http";
+import mime from "mime";
 import { createWorker } from "@simplysm/core-node";
 import { err as errNs } from "@simplysm/core-common";
 import { consola } from "consola";
@@ -31,8 +33,10 @@ export interface ClientBuildInfo {
   browserSupport?: SdBrowserSupportConfig;
   /** PWA 설정. false로 비활성화. 미설정 시 기본값으로 활성화 */
   pwa?: false | SdPwaConfig;
-  /** Enable lint using ts.Program from compilation */
+  /** 컴파일의 ts.Program을 사용하여 lint 실행 */
   enableLint?: boolean;
+  /** Vite optimizeDeps.exclude에 전달할 패키지 목록 */
+  exclude?: string[];
 }
 
 /** Client 빌드 결과 */
@@ -58,7 +62,113 @@ export interface ClientWorkerEvents extends Record<string, unknown> {
 
 const logger = consola.withTag("sd:cli:client:worker");
 
+/** viteBuild({ build: { watch: {} } }) 반환 타입의 최소 인터페이스 */
+interface WatcherHandle {
+  on(event: string, handler: (event: { code: string; error?: { message: string } }) => void): void;
+  close(): Promise<void>;
+}
+
 let viteServer: ViteDevServer | undefined;
+let rollupWatcher: WatcherHandle | undefined;
+let legacyHttpServer: http.Server | undefined;
+
+/** SSE 연결된 클라이언트 목록 (live reload용) */
+const sseClients = new Set<http.ServerResponse>();
+
+/** SSE 연결된 모든 클라이언트에 reload 신호를 전송한다 */
+function notifyLiveReload(): void {
+  for (const client of sseClients) {
+    client.write("data: reload\n\n");
+  }
+}
+
+
+/** live reload 클라이언트 스크립트 (HTML에 주입) */
+const LIVE_RELOAD_SCRIPT = `<script>(function(){var s=new EventSource("__live-reload");s.onmessage=function(){location.reload();};})()</script>`;
+
+/**
+ * HTML 응답 시 live reload 스크립트를 </body> 직전에 주입한다.
+ */
+function injectLiveReloadScript(html: string): string {
+  const idx = html.lastIndexOf("</body>");
+  if (idx !== -1) {
+    return html.slice(0, idx) + LIVE_RELOAD_SCRIPT + html.slice(idx);
+  }
+  return html + LIVE_RELOAD_SCRIPT;
+}
+
+/**
+ * legacy dev 모드용 HTTP 정적 파일 서버를 생성한다.
+ * dist/ 디렉토리의 파일을 서빙하고, SPA fallback + SSE live reload를 지원한다.
+ */
+function createLegacyHttpServer(distDir: string, basePath: string): http.Server {
+  return http.createServer((req, res) => {
+    const url = (req.url ?? "/").split("?")[0];
+
+    // basePath prefix 제거
+    let relativePath: string;
+    if (url.startsWith(basePath)) {
+      relativePath = url.slice(basePath.length);
+    } else {
+      res.writeHead(404);
+      res.end("Not Found");
+      return;
+    }
+
+    // SSE live reload 엔드포인트
+    if (relativePath === "__live-reload" || relativePath === "/__live-reload") {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+      });
+      sseClients.add(res);
+      req.on("close", () => {
+        sseClients.delete(res);
+      });
+      return;
+    }
+
+    // 빈 경로 또는 / → index.html
+    if (relativePath === "" || relativePath === "/") {
+      relativePath = "index.html";
+    }
+
+    // 선행 슬래시 제거
+    if (relativePath.startsWith("/")) {
+      relativePath = relativePath.slice(1);
+    }
+
+    const filePath = path.join(distDir, relativePath);
+    const ext = path.extname(filePath);
+
+    // 파일 존재 확인
+    if (fs.existsSync(filePath) && !fs.statSync(filePath).isDirectory()) {
+      const contentType = mime.getType(ext) ?? "application/octet-stream";
+      if (ext === ".html") {
+        // HTML: live reload 스크립트 주입
+        const content = injectLiveReloadScript(fs.readFileSync(filePath, "utf-8"));
+        res.writeHead(200, { "Content-Type": contentType });
+        res.end(content);
+      } else {
+        const content = fs.readFileSync(filePath);
+        res.writeHead(200, { "Content-Type": contentType });
+        res.end(content);
+      }
+    } else {
+      // SPA fallback: index.html 반환 (live reload 스크립트 주입)
+      const indexPath = path.join(distDir, "index.html");
+      if (fs.existsSync(indexPath)) {
+        const content = injectLiveReloadScript(fs.readFileSync(indexPath, "utf-8"));
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(content);
+      } else {
+        res.writeHead(404);
+        res.end("Not Found");
+      }
+    }
+  });
+}
 
 function resolvePackageInfo(info: ClientBuildInfo): {
   tsconfigPath: string;
@@ -77,6 +187,9 @@ function resolvePackageInfo(info: ClientBuildInfo): {
  * 서버가 준비되면 serverReady 이벤트로 포트를 알린다.
  */
 async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
+  if (info.browserSupport?.legacyModule === true) {
+    return startLegacyWatch(info);
+  }
   logger.debug(`[${info.name}] client worker startWatch 시작 (port: ${info.port ?? "auto"})`);
   try {
     const { tsconfigPath, pkgName } = resolvePackageInfo(info);
@@ -102,6 +215,7 @@ async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
       legacyModule: info.browserSupport?.legacyModule,
       polyfills,
       pwa: info.pwa,
+      exclude: info.exclude,
     });
 
     logger.debug(`[${info.name}] Vite server 생성 시작`);
@@ -138,15 +252,134 @@ async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
 }
 
 /**
- * dev server 중지. Vite server를 정리한다.
+ * legacy watch 시작. Vite build --watch로 파일 변경을 감시한다.
+ * legacyModule: true일 때 createServer 대신 사용한다.
+ */
+async function startLegacyWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
+  logger.debug(`[${info.name}] client worker startLegacyWatch 시작`);
+  try {
+    const { tsconfigPath, pkgName } = resolvePackageInfo(info);
+
+    // dist 초기화 (첫 빌드만 비움)
+    const distDir = path.join(info.pkgDir, "dist");
+    fs.rmSync(distDir, { recursive: true, force: true });
+
+    // polyfills.ts 자동 감지
+    const polyfillsPath = path.join(info.pkgDir, "src", "polyfills.ts");
+    const polyfills = fs.existsSync(polyfillsPath) ? ["./src/polyfills.ts"] : undefined;
+
+    const viteConfig = await createClientViteConfig({
+      pkgDir: info.pkgDir,
+      pkgName,
+      mode: "build",
+      tsconfigPath,
+      serverPort: 0,
+      env: info.env,
+      watch: true,
+      onBuildStart: () => sender.send("buildStart", {}),
+      onBuild: (result) => sender.send("build", result),
+      enableLint: info.enableLint,
+      replaceDeps: info.replaceDeps,
+      onScopeRebuild: () => sender.send("scopeRebuild", {}),
+      browserslist: info.browserSupport?.browserslist,
+      postCssPlugins: info.browserSupport?.postCss?.plugins,
+      legacyModule: info.browserSupport?.legacyModule,
+      polyfills,
+      pwa: false,
+      exclude: info.exclude,
+    });
+
+    const watcher = (await viteBuild(viteConfig)) as WatcherHandle;
+    rollupWatcher = watcher;
+
+    // .config.json 생성
+    writeConfigJson(info.pkgDir, info.configs);
+
+    // HTTP 정적 파일 서버 시작
+    const name = pkgName.replace(/^@[^/]+\//, "");
+    const basePath = `/${name}/`;
+    const httpServer = createLegacyHttpServer(distDir, basePath);
+    legacyHttpServer = httpServer;
+
+    const serverPort = await new Promise<number>((resolve, reject) => {
+      httpServer.listen(info.port ?? 0, "0.0.0.0", () => {
+        const addr = httpServer.address();
+        if (typeof addr === "object" && addr != null) {
+          resolve(addr.port);
+        } else {
+          reject(new Error("HTTP 서버 포트를 감지할 수 없습니다."));
+        }
+      });
+      httpServer.on("error", reject);
+    });
+
+    sender.send("serverReady", { port: serverPort });
+
+    // 첫 빌드 완료 대기
+    return await new Promise<ClientBuildResult>((resolve) => {
+      let firstBuildResolved = false;
+
+      watcher.on("event", (event: { code: string; error?: { message: string } }) => {
+        if (event.code === "END") {
+          if (!firstBuildResolved) {
+            firstBuildResolved = true;
+            resolve({ success: true });
+          } else {
+            // 재빌드 완료 → 브라우저 live reload
+            notifyLiveReload();
+          }
+        } else if (event.code === "ERROR") {
+          const message = event.error?.message ?? "Unknown build error";
+          sender.send("error", { message });
+          if (!firstBuildResolved) {
+            firstBuildResolved = true;
+            resolve({ success: false, errors: [message] });
+          }
+        }
+      });
+    });
+  } catch (err) {
+    const message = errNs.message(err);
+    sender.send("error", { message });
+    return { success: false, errors: [message] };
+  }
+}
+
+/**
+ * dev server 중지. Vite server 또는 RollupWatcher를 정리한다.
  */
 async function stopWatch(): Promise<void> {
   logger.debug("Vite server 정리 시작");
+
+  const watcherToClose = rollupWatcher;
+  rollupWatcher = undefined;
+  if (watcherToClose != null) {
+    await watcherToClose.close();
+  }
+
+  // SSE 클라이언트 정리
+  for (const client of sseClients) {
+    client.end();
+  }
+  sseClients.clear();
+
+  const httpServerToClose = legacyHttpServer;
+  legacyHttpServer = undefined;
+  if (httpServerToClose != null) {
+    await new Promise<void>((resolve, reject) => {
+      httpServerToClose.close((err) => {
+        if (err != null) reject(err);
+        else resolve();
+      });
+    });
+  }
+
   const serverToClose = viteServer;
   viteServer = undefined;
   if (serverToClose != null) {
     await serverToClose.close();
   }
+
   logger.debug("Vite server 정리 완료");
 }
 
@@ -182,6 +415,7 @@ async function build(info: ClientBuildInfo): Promise<ClientBuildResult> {
       legacyModule: info.browserSupport?.legacyModule,
       polyfills,
       pwa: info.pwa,
+      exclude: info.exclude,
     });
 
     await viteBuild(viteConfig);