@simplysm/sd-cli 14.0.5 → 14.0.7

package/src/orchestrators/BuildOrchestrator.ts

@@ -141,9 +141,9 @@ export class BuildOrchestrator {
    * - Prepare environment variables
    */
   async initialize(): Promise<void> {
-    this._logger.debug("build started", { targets: this._options.targets });
+    this._logger.debug("빌드 시작", { targets: this._options.targets });
 
-    // Load sd.config.ts and validate targets
+    // sd.config.ts 로드 및 대상 유효성 검사
     try {
       this._sdConfig = await loadAndValidateConfig({
         cwd: this._cwd,
@@ -151,18 +151,19 @@ export class BuildOrchestrator {
         options: this._options.options,
         targets: this._options.targets,
       });
-      this._logger.debug("sd.config.ts loaded");
+      this._logger.debug("sd.config.ts 로드 완료");
     } catch (err) {
-      this._logger.error(`sd.config.ts load failed: ${err instanceof Error ? err.message : err}`);
+      this._logger.error(`sd.config.ts 로드 실패: ${err instanceof Error ? err.message : err}`);
       process.exitCode = 1;
       throw err;
     }
 
-    // Prepare VER and DEV environment variables
+    // 환경변수 준비 (VER, DEV)
     const version = await getVersion(this._cwd);
     this._baseEnv = { VER: version, DEV: "false" };
+    this._logger.debug("환경변수 준비 완료", { VER: version, DEV: "false" });
 
-    // Classify packages
+    // 패키지 분류
     this._classified = classifyPackages(this._sdConfig.packages, this._options.targets);
     this._allPackageNames = [
       ...this._classified.buildPackages.map((p) => p.name),
@@ -171,12 +172,12 @@ export class BuildOrchestrator {
     ];
 
     if (this._allPackageNames.length === 0) {
-      process.stdout.write("✔ No packages to build.\n");
+      process.stdout.write("✔ 빌드할 패키지가 없습니다.\n");
       return;
     }
 
-    this._logger.debug("package classification complete", {
-      buildPackages: this._classified.buildPackages.map((p) => p.name),
+    this._logger.debug("패키지 분류 완료", {
+      buildPackages: this._classified.buildPackages.map((p) => `${p.name} (${p.config.target})`),
       serverPackages: this._classified.serverPackages.map((p) => p.name),
       clientPackages: this._classified.clientPackages.map((p) => p.name),
     });
@@ -213,13 +214,13 @@ export class BuildOrchestrator {
       getNewLine: () => ts.sys.newLine,
     };
 
-    // Phase 1: Clean (must complete before build writes to dist)
-    this._logger.start("Clean");
+    // Phase 1: dist 클린
+    this._logger.start(`dist 폴더 정리 중... (${this._allPackageNames.length}개 패키지)`);
     await cleanDistFolders(this._cwd, this._allPackageNames);
-    this._logger.success("Clean");
+    this._logger.success("dist 폴더 정리 완료");
 
-    // Phase 2: Build (lint runs inside each engine)
-    this._logger.start("Build");
+    // Phase 2: 빌드
+    const concurrency = getMaxConcurrency();
 
     // Create list of build tasks
     const buildTasks: Array<() => Promise<void>> = [];
@@ -229,7 +230,7 @@ export class BuildOrchestrator {
       const pkgDir = path.join(this._cwd, "packages", name);
 
       buildTasks.push(async () => {
-        this._logger.debug(`${name} (${config.target}) started`);
+        this._logger.debug(`[${name}] (${config.target}) 빌드 시작`);
         const engine = createBuildEngine(
           { name, dir: pkgDir, config },
           { cwd: this._cwd },
@@ -238,7 +239,7 @@ export class BuildOrchestrator {
         try {
           const engineResult = await engine.run({ js: true, dts: true, lint: true });
 
-          // Handle JS build results
+          // JS 빌드 결과 처리
           results.push({
             name,
             target: config.target,
@@ -249,7 +250,7 @@ export class BuildOrchestrator {
           });
           if (!engineResult.js.success) state.hasError = true;
 
-          // Handle DTS results
+          // DTS 결과 처리
           const diagnostics = engineResult.dts.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
           results.push({
             name,
@@ -261,7 +262,7 @@ export class BuildOrchestrator {
           });
           if (!engineResult.dts.success) state.hasError = true;
 
-          // Handle lint results
+          // 린트 결과 처리
           if (engineResult.lint != null) {
             results.push({
               name,
@@ -277,11 +278,12 @@ export class BuildOrchestrator {
           await engine.stop();
         }
 
-        // Copy copySrc files
+        // copySrc 파일 복사
         if (config.copySrc != null && config.copySrc.length > 0) {
+          this._logger.debug(`[${name}] copySrc 파일 복사 중 (${config.copySrc.length}개)`);
           await copySrcFiles(pkgDir, config.copySrc);
         }
-        this._logger.debug(`${name} (${config.target}) completed`);
+        this._logger.debug(`[${name}] (${config.target}) 빌드 완료`);
       });
     }
 
@@ -290,7 +292,7 @@ export class BuildOrchestrator {
       const pkgDir = path.join(this._cwd, "packages", name);
 
       buildTasks.push(async () => {
-        this._logger.debug(`${name} (server) started`);
+        this._logger.debug(`[${name}] (server) 빌드 시작`);
         const engine = createBuildEngine(
           { name, dir: pkgDir, config: { ...config, env: { ...baseEnv, ...config.env } } },
           { cwd: this._cwd },
@@ -299,7 +301,7 @@ export class BuildOrchestrator {
         try {
           const engineResult = await engine.run({ js: true, dts: false, lint: true });
 
-          // Handle JS build results
+          // JS 빌드 결과 처리
           results.push({
             name,
             target: "server",
@@ -310,7 +312,7 @@ export class BuildOrchestrator {
           });
           if (!engineResult.js.success) state.hasError = true;
 
-          // Handle DTS/typecheck results
+          // DTS/타입체크 결과 처리
           const diagnostics = engineResult.dts.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
           results.push({
             name,
@@ -322,7 +324,7 @@ export class BuildOrchestrator {
           });
           if (!engineResult.dts.success) state.hasError = true;
 
-          // Handle lint results
+          // 린트 결과 처리
           if (engineResult.lint != null) {
             results.push({
               name,
@@ -337,7 +339,7 @@ export class BuildOrchestrator {
         } finally {
           await engine.stop();
         }
-        this._logger.debug(`${name} (server) completed`);
+        this._logger.debug(`[${name}] (server) 빌드 완료`);
       });
     }
 
@@ -346,7 +348,7 @@ export class BuildOrchestrator {
       const pkgDir = path.join(this._cwd, "packages", name);
 
       buildTasks.push(async () => {
-        this._logger.debug(`${name} (client) started`);
+        this._logger.debug(`[${name}] (client) 빌드 시작`);
         const engine = createBuildEngine(
           { name, dir: pkgDir, config: { ...config, env: { ...baseEnv, ...config.env } } },
           { cwd: this._cwd },
@@ -355,7 +357,7 @@ export class BuildOrchestrator {
         try {
           const engineResult = await engine.run({ js: true, dts: false, lint: true });
 
-          // Handle JS build results
+          // JS 빌드 결과 처리
           results.push({
             name,
             target: "client",
@@ -366,7 +368,7 @@ export class BuildOrchestrator {
           });
           if (!engineResult.js.success) state.hasError = true;
 
-          // Handle DTS results (always success for client)
+          // DTS 결과 처리
           const diagnostics = engineResult.dts.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
           results.push({
             name,
@@ -378,7 +380,7 @@ export class BuildOrchestrator {
           });
           if (!engineResult.dts.success) state.hasError = true;
 
-          // Handle lint results
+          // 린트 결과 처리
           if (engineResult.lint != null) {
             results.push({
               name,
@@ -390,27 +392,31 @@ export class BuildOrchestrator {
             if (!engineResult.lint.success) state.hasError = true;
           }
 
-          // Native builds (only when JS build succeeds)
+          // 네이티브 빌드 (JS 빌드 성공 시에만 실행)
           if (engineResult.js.success) {
             const distPath = path.join(pkgDir, "dist");
             const nativeBuildPromises: Array<Promise<void>> = [];
 
             if (config.capacitor != null) {
+              this._logger.debug(`[${name}] Capacitor 네이티브 빌드 시작`);
               nativeBuildPromises.push(
                 (async () => {
                   const cap = await Capacitor.create(pkgDir, config.capacitor!, config.exclude);
                   await cap.initialize();
                   await cap.build(distPath);
+                  this._logger.debug(`[${name}] Capacitor 네이티브 빌드 완료`);
                 })(),
               );
             }
 
             if (config.electron != null) {
+              this._logger.debug(`[${name}] Electron 네이티브 빌드 시작`);
               nativeBuildPromises.push(
                 (async () => {
                   const elc = await Electron.create(pkgDir, config.electron!, config.exclude);
                   await elc.initialize();
                   await elc.build(distPath);
+                  this._logger.debug(`[${name}] Electron 네이티브 빌드 완료`);
                 })(),
               );
             }
@@ -422,7 +428,7 @@ export class BuildOrchestrator {
                   state.hasError = true;
                   const err = nativeResult.reason;
                   this._logger.error(
-                    `${name} native build failed: ${err instanceof Error ? err.message : String(err)}`,
+                    `[${name}] 네이티브 빌드 실패: ${err instanceof Error ? err.message : String(err)}`,
                   );
                 }
               }
@@ -431,19 +437,18 @@ export class BuildOrchestrator {
         } finally {
           await engine.stop();
         }
-        this._logger.debug(`${name} (client) completed`);
+        this._logger.debug(`[${name}] (client) 빌드 완료`);
       });
     }
 
-    // Run all builds with concurrency limit (lint runs inside each engine)
-    const concurrency = getMaxConcurrency();
-    this._logger.debug(`빌드 실행 (${buildTasks.length}개 작업, 동시성: ${concurrency})`);
+    this._logger.start(`빌드 실행 중... (${buildTasks.length}개 작업, 동시성: ${concurrency})`);
+    this._logger.debug("빌드 작업 목록", { tasks: buildTasks.length, concurrency });
     const buildResults = await runWithConcurrency(buildTasks, concurrency);
     for (const settledResult of buildResults) {
       if (settledResult.status === "rejected") {
         const err = settledResult.reason;
         const stack = err instanceof Error ? err.stack : undefined;
-        this._logger.error("Unexpected error during build", {
+        this._logger.error("빌드 중 예기치 않은 에러", {
           error: String(err),
         });
         if (stack != null) {
@@ -452,24 +457,24 @@ export class BuildOrchestrator {
         state.hasError = true;
       }
     }
-    this._logger.success("Build");
+    this._logger.success("빌드 실행 완료");
 
-    // Output results
+    // 결과 출력
     const allDiagnostics: ts.Diagnostic[] = [];
     for (const result of results) {
       const typeLabel = result.type === "dts" ? "dts" : result.type === "lint" ? "lint" : result.target;
 
-      // Output warnings
+      // 경고 출력
       if (result.warnings != null) {
         this._logger.warn(formatBuildMessages(result.name, typeLabel, result.warnings));
       }
 
-      // Output errors
+      // 에러 출력
       if (!result.success) {
         if (result.errors != null) {
           this._logger.error(formatBuildMessages(result.name, typeLabel, result.errors));
         } else {
-          this._logger.error(`${result.name} (${typeLabel})`);
+          this._logger.error(`[${result.name}] (${typeLabel}) 실패`);
         }
       }
       if (result.diagnostics != null) {
@@ -477,18 +482,20 @@ export class BuildOrchestrator {
       }
     }
 
-    // Output diagnostics (deduplicated)
+    // 진단 정보 출력 (중복 제거)
     if (allDiagnostics.length > 0) {
       const uniqueDiagnostics = ts.sortAndDeduplicateDiagnostics(allDiagnostics);
       const message = ts.formatDiagnosticsWithColorAndContext(uniqueDiagnostics, formatHost);
       process.stdout.write(message);
     }
 
-    // Output result log
+    // 최종 결과 로그
+    const errorCount = results.filter((r) => !r.success).length;
+    const warningCount = results.filter((r) => r.warnings != null).length;
     if (state.hasError) {
-      this._logger.error("Build failed");
+      this._logger.error("빌드 에러 발생", { errorCount, warningCount });
     } else {
-      this._logger.info("Build completed");
+      this._logger.info("빌드 완료", { errorCount, warningCount });
     }
 
     return state.hasError;

package/src/orchestrators/DevWatchOrchestrator.ts

@@ -90,9 +90,9 @@ export class DevWatchOrchestrator {
   }
 
   async initialize(): Promise<void> {
-    this._logger.debug(`${this._options.mode} start`, { targets: this._options.targets });
+    this._logger.debug(`${this._options.mode} 시작`, { targets: this._options.targets });
 
-    // Load sd.config.ts
+    // sd.config.ts 로드
     let sdConfig: SdConfig;
     try {
       sdConfig = await loadSdConfig({
@@ -100,9 +100,9 @@ export class DevWatchOrchestrator {
         dev: true,
         options: this._options.options,
       });
-      this._logger.debug("sd.config.ts loaded");
+      this._logger.debug("sd.config.ts 로드 완료");
     } catch (err) {
-      this._logger.error(`Failed to load sd.config.ts: ${err instanceof Error ? err.message : err}`);
+      this._logger.error(`sd.config.ts 로드 실패: ${err instanceof Error ? err.message : err}`);
       process.exitCode = 1;
       throw err;
     }
@@ -147,8 +147,8 @@ export class DevWatchOrchestrator {
     // Check if there are packages to process
     const totalPackages = this._libraryPackages.length + this._serverPackages.length + this._watchHookPackages.length + this._clientPackages.length;
     if (totalPackages === 0) {
-      const modeLabel = this._options.mode === "watch" ? "watch" : "develop";
-      process.stdout.write(`⚠ No packages to ${modeLabel}.\n`);
+      const modeLabel = this._options.mode === "watch" ? "워치" : "개발";
+      process.stdout.write(`⚠ ${modeLabel} 대상 패키지가 없습니다.\n`);
       return;
     }
 
@@ -245,7 +245,7 @@ export class DevWatchOrchestrator {
       return;
     }
 
-    process.stdout.write("⏳ Shutting down...\n");
+    process.stdout.write("⏳ 종료 중...\n");
 
     const shutdownTasks: Array<Promise<void>> = [];
 
@@ -274,7 +274,7 @@ export class DevWatchOrchestrator {
     this._watchHookWatchers.length = 0;
     this._replaceDepWatcher?.dispose();
 
-    process.stdout.write("✔ Done\n");
+    process.stdout.write("✔ 종료 완료\n");
   }
 
   // --- Watch mode ---
@@ -289,12 +289,19 @@ export class DevWatchOrchestrator {
     }
 
     // Start all engines
-    this._logger.start("Running initial build...");
-    const watchPromises: Array<Promise<void>> = [];
-    watchPromises.push(...this._libraryEngines.map((e) => e.startWatch({ js: true, dts: true, lint: true })));
+    const total = this._libraryEngines.length;
+    this._logger.start(`초기 빌드 실행 중... (${total}개 패키지)`);
+    let completed = 0;
+
+    const watchPromises = this._libraryEngines.map(async (engine, i) => {
+      const pkgName = this._libraryPackages[i].name;
+      await engine.startWatch({ js: true, dts: true, lint: true });
+      completed++;
+      this._logger.info(`  [${completed}/${total}] ${pkgName} 완료`);
+    });
 
     await Promise.allSettled(watchPromises);
-    this._logger.success("Initial build completed");
+    this._logger.success("초기 빌드 실행 완료");
 
     // Print initial build results
     printErrors(this._resultCollector.toMap());
@@ -314,7 +321,7 @@ export class DevWatchOrchestrator {
       });
       this._watchHookWatchers.push(watcher);
 
-      this._logger.success(`Watch hook started: ${pkg.name}`);
+      this._logger.success(`워치 훅 시작됨: ${pkg.name}`);
     }
   }
 
@@ -329,11 +336,11 @@ export class DevWatchOrchestrator {
     this._watchHookChildren.set(pkgName, child);
 
     child.on("error", (err) => {
-      this._logger.error(`Watch hook error (${pkgName}): ${err.message}`);
+      this._logger.error(`[${pkgName}] 워치 훅 에러: ${err.message}`);
     });
     child.on("close", (code) => {
       if (code !== 0 && code !== null) {
-        this._logger.warn(`Watch hook (${pkgName}) exited with code ${String(code)}`);
+        this._logger.warn(`[${pkgName}] 워치 훅이 코드 ${String(code)}로 종료됨`);
       }
     });
   }
@@ -342,7 +349,7 @@ export class DevWatchOrchestrator {
 
   private async _startDevMode(): Promise<void> {
     // Start client and server engines in parallel
-    this._logger.debug("Starting initial build (Promise.allSettled)");
+    this._logger.debug("초기 빌드 시작");
     const initialBuildPromises: Array<{ name: string; promise: Promise<void> }> = [];
 
     for (const [name, engine] of this._clientEngines) {
@@ -366,9 +373,9 @@ export class DevWatchOrchestrator {
     initialResults.forEach((result, index) => {
       const taskName = initialBuildPromises[index].name;
       if (result.status === "rejected") {
-        this._logger.debug(`[${taskName}] Initial build failed:`, result.reason);
+        this._logger.debug(`[${taskName}] 초기 빌드 실패:`, result.reason);
       } else {
-        this._logger.debug(`[${taskName}] Initial build completed`);
+        this._logger.debug(`[${taskName}] 초기 빌드 완료`);
       }
     });
 
@@ -400,7 +407,7 @@ export class DevWatchOrchestrator {
         try {
           await this._startServerRuntime(name, mainJsPath, { ...this._baseEnv, ...config.env }, clientPorts);
         } catch (err) {
-          this._logger.error(`[${name}] Error starting Server Runtime:`, errNs.message(err));
+          this._logger.error(`[${name}] 서버 런타임 시작 실패:`, errNs.message(err));
           this._resultCollector.add({
             name,
             target: "server",
@@ -427,7 +434,7 @@ export class DevWatchOrchestrator {
           await cap.run(devServerUrl);
         } catch (err) {
           this._logger.error(
-            `[${name}] Capacitor run failed: ${errNs.message(err)}`,
+            `[${name}] Capacitor 실행 실패: ${errNs.message(err)}`,
           );
         }
       }
@@ -440,14 +447,14 @@ export class DevWatchOrchestrator {
             await elc.run(devServerUrl);
           } catch (err) {
             this._logger.error(
-              `[${name}] Electron run failed: ${errNs.message(err)}`,
+              `[${name}] Electron 실행 실패: ${errNs.message(err)}`,
             );
             this._resultCollector.add({
               name,
               target: "client",
               type: "build",
               status: "error",
-              message: `Electron run failed: ${errNs.message(err)}`,
+              message: `Electron 실행 실패: ${errNs.message(err)}`,
             });
           }
         })();
@@ -469,7 +476,7 @@ export class DevWatchOrchestrator {
         restartPromises.push(
           this._startServerRuntime(name, mainJsPath, { ...this._baseEnv, ...config.env }, clientPorts)
             .catch((err: unknown) => {
-              this._logger.error(`[${name}] Error starting Server Runtime:`, errNs.message(err));
+              this._logger.error(`[${name}] 서버 런타임 시작 실패:`, errNs.message(err));
               this._resultCollector.add({
                 name,
                 target: "server",
@@ -519,12 +526,12 @@ export class DevWatchOrchestrator {
     env?: Record<string, string>,
     clientPorts?: Record<string, number>,
   ): Promise<void> {
-    this._logger.debug(`[${serverName}] _startServerRuntime: ${mainJsPath}`);
+    this._logger.debug(`[${serverName}] 서버 런타임 시작: ${mainJsPath}`);
 
     // Terminate existing runtime
     const existingRuntime = this._serverRuntimeWorkers.get(serverName);
     if (existingRuntime != null) {
-      this._logger.info(`[${serverName}] Restarting server...`);
+      this._logger.info(`[${serverName}] 서버 재시작 중...`);
       await existingRuntime.terminate();
     }
 
@@ -560,7 +567,7 @@ export class DevWatchOrchestrator {
     runtimeWorker
       .start({ mainJsPath, clientPorts, env })
       .catch((err: unknown) => {
-        this._logger.error(`[${serverName}] Server Runtime Worker crashed:`, errNs.message(err));
+        this._logger.error(`[${serverName}] 서버 런타임 워커 비정상 종료:`, errNs.message(err));
         this._resultCollector.add({
           name: serverName,
           target: "server",

package/src/sd-cli.ts

@@ -31,7 +31,7 @@ if (isDev) {
     const { loadSdConfig } = await import("./utils/sd-config.js");
     const { setupReplaceDeps } = await import("./utils/replace-deps.js");
     const sdConfig = await loadSdConfig({ cwd: process.cwd(), dev: false, options: [] });
-    if (sdConfig.replaceDeps != null) {
+    if (process.argv[2] !== "replace-deps" && sdConfig.replaceDeps != null) {
       await setupReplaceDeps(process.cwd(), sdConfig.replaceDeps);
     }
   } catch {

package/src/utils/esbuild-config.ts

@@ -57,22 +57,29 @@ export interface ServerEsbuildOptions {
   dev?: boolean;
 }
 
+/**
+ * Generate a JS banner snippet that merges env vars into process.env at runtime.
+ * Uses ??= so that runtime ENV (e.g. `DEV=false node server.js`) takes precedence
+ * over build-time defaults.
+ */
+export function createEnvBanner(env?: Record<string, string>): string {
+  if (env == null || Object.keys(env).length === 0) return "";
+  return `for(const[__k,__v]of Object.entries(${JSON.stringify(env)})){process.env[__k]??=__v;}`;
+}
+
 /**
  * Create esbuild config for Server build
  *
  * Used for server package builds
  * - bundle: true (single bundle with all dependencies)
  * - minify: true (minify for code protection)
- * - banner: createRequire shim for CJS package require() support
- * - Replace env with define option (process.env.KEY format)
+ * - banner: createRequire shim for CJS package require() support + env injection
  */
 export function createServerEsbuildOptions(options: ServerEsbuildOptions): esbuild.BuildOptions {
-  const define: Record<string, string> = {};
-  if (options.env != null) {
-    for (const [key, value] of Object.entries(options.env)) {
-      define[`process.env.${key}`] = JSON.stringify(value);
-    }
-  }
+  const envBanner = createEnvBanner(options.env);
+  const bannerJs =
+    "import { createRequire } from 'module'; const require = createRequire(import.meta.url);" +
+    envBanner;
 
   return {
     entryPoints: options.entryPoints,
@@ -82,11 +89,8 @@ export function createServerEsbuildOptions(options: ServerEsbuildOptions): esbui
     platform: "node",
     target: "node20",
     bundle: true,
-    banner: {
-      js: "import { createRequire } from 'module'; const require = createRequire(import.meta.url);",
-    },
+    banner: { js: bannerJs },
     external: options.external,
-    define,
     tsconfig: path.join(options.pkgDir, "tsconfig.json"),
     logLevel: "silent",
   };

package/src/utils/output-utils.ts

@@ -25,7 +25,7 @@ export function printErrors(results: Map<string, BuildResult>): void {
       if (result.message != null && result.message !== "") {
         consola.error(formatBuildMessages(result.name, typeLabel, [result.message]));
       } else {
-        consola.error(`${result.name} (${typeLabel})`);
+        consola.error(`[${result.name}] (${typeLabel}) 실패`);
       }
     }
   }

package/src/utils/package-utils.ts

@@ -113,7 +113,7 @@ export function collectDeps(
   replaceDepsConfig?: Record<string, string>,
 ): DepsResult {
   const startTime = performance.now();
-  logger.debug("[collectDeps] Starting dependency collection...");
+  logger.debug("의존성 수집 시작");
   const rootPkgJsonPath = path.join(cwd, "package.json");
   const rootPkgJson = JSON.parse(fs.readFileSync(rootPkgJsonPath, "utf-8")) as { name: string };
   const scopeMatch = rootPkgJson.name.match(/^(@[^/]+)\//);
@@ -170,7 +170,7 @@ export function collectDeps(
 
   traverse(pkgDir);
   logger.debug(
-    `[collectDeps] Done: workspace=${String(workspaceDeps.length)}, replace=${String(replaceDeps.length)} (${Math.round(performance.now() - startTime)}ms)`,
+    `의존성 수집 완료: workspace=${String(workspaceDeps.length)}, replace=${String(replaceDeps.length)} (${Math.round(performance.now() - startTime)}ms)`,
   );
   return { workspaceDeps, replaceDeps };
 }
@@ -347,7 +347,7 @@ export function classifyDevPackages(
           serverClientsMap.set(clientConfig.server, clients);
         } else {
           process.stdout.write(
-            `⚠ Client "${name}" server "${clientConfig.server}" not in dev targets — running as standalone.\n`,
+            `⚠ 클라이언트 "${name}"의 서버 "${clientConfig.server}"가 dev 대상에 없어 독립 실행됩니다.\n`,
           );
         }
       }

package/src/utils/rebuild-manager.ts

@@ -45,7 +45,7 @@ export class RebuildManager extends EventEmitter<RebuildManagerEvents> {
 
     const tasks = Array.from(batchBuilds.entries());
     const titles = tasks.map(([, { title }]) => title).join(", ");
-    this._logger.start(`Rebuilding... (${titles})`);
+    this._logger.start(`리빌드 실행 중... (${titles})`);
 
     const results = await Promise.allSettled(tasks.map(([, { promise }]) => promise));
 
@@ -54,11 +54,11 @@ export class RebuildManager extends EventEmitter<RebuildManagerEvents> {
     const failed = results.filter((r): r is PromiseRejectedResult => r.status === "rejected");
     if (failed.length > 0) {
       for (const result of failed) {
-        this._logger.error("Error during rebuild", { error: String(result.reason) });
+        this._logger.error("리빌드 에러 발생", { error: String(result.reason) });
       }
     }
 
-    this._logger.success(`Rebuild completed (${titles})`);
+    this._logger.success(`리빌드 실행 완료 (${titles})`);
 
     this.emit("batchComplete");