@simplysm/sd-cli 14.0.4 → 14.0.6

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,12 @@ export class DevWatchOrchestrator {
     }
 
     // Start all engines
-    this._logger.start("Running initial build...");
+    this._logger.start("초기 빌드 실행 중...");
     const watchPromises: Array<Promise<void>> = [];
     watchPromises.push(...this._libraryEngines.map((e) => e.startWatch({ js: true, dts: true, lint: true })));
 
     await Promise.allSettled(watchPromises);
-    this._logger.success("Initial build completed");
+    this._logger.success("초기 빌드 실행 완료");
 
     // Print initial build results
     printErrors(this._resultCollector.toMap());
@@ -314,7 +314,7 @@ export class DevWatchOrchestrator {
       });
       this._watchHookWatchers.push(watcher);
 
-      this._logger.success(`Watch hook started: ${pkg.name}`);
+      this._logger.success(`워치 훅 시작됨: ${pkg.name}`);
     }
   }
 
@@ -329,11 +329,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 +342,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 +366,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 +400,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 +427,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 +440,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 +469,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 +519,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 +560,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/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");
 

package/src/utils/replace-deps.ts

@@ -199,7 +199,7 @@ async function resolveAllReplaceDepEntries(
       try {
         await fs.promises.access(resolvedSourcePath);
       } catch {
-        logger.warn(`Source path does not exist, skipping: ${resolvedSourcePath}`);
+        logger.warn(`소스 경로가 존재하지 않아 건너뜀: ${resolvedSourcePath}`);
         continue;
       }
 
@@ -244,7 +244,7 @@ export async function setupReplaceDeps(
   const logger = consola.withTag("sd:cli:replace-deps");
   let setupCount = 0;
 
-  logger.start("Setting up replace-deps");
+  logger.start("replace-deps 설정 중...");
 
   const entries = await resolveAllReplaceDepEntries(projectRoot, replaceDeps, logger);
 
@@ -255,11 +255,11 @@ export async function setupReplaceDeps(
 
       setupCount += 1;
     } catch (err) {
-      logger.error(`Copy replace failed (${targetName}): ${err instanceof Error ? err.message : err}`);
+      logger.error(`[${targetName}] 복사 실패: ${err instanceof Error ? err.message : err}`);
     }
   }
 
-  logger.success(`Replaced ${setupCount} dependencies`);
+  logger.success(`replace-deps 설정 완료 (${setupCount}개 의존성 교체)`);
 
   // Run postinstall scripts from replaced packages
   for (const { targetName, resolvedSourcePath, actualTargetPath } of entries) {
@@ -269,13 +269,13 @@ export async function setupReplaceDeps(
       const postinstall = pkgJson.scripts?.postinstall as string | undefined;
       if (postinstall == null) continue;
 
-      logger.warn(`Running postinstall script for ${targetName}: ${postinstall}`);
-      logger.start(`Running postinstall for ${targetName}`);
+      logger.warn(`[${targetName}] postinstall 스크립트 실행: ${postinstall}`);
+      logger.start(`[${targetName}] postinstall 실행 중...`);
       await promisify(exec)(postinstall, { cwd: actualTargetPath });
-      logger.success(`postinstall done: ${targetName}`);
+      logger.success(`[${targetName}] postinstall 실행 완료`);
     } catch (err) {
       logger.error(
-        `postinstall failed (${targetName}): ${err instanceof Error ? err.message : err}`,
+        `[${targetName}] postinstall 실패: ${err instanceof Error ? err.message : err}`,
       );
     }
   }
@@ -305,7 +305,7 @@ export async function watchReplaceDeps(
   const watchers: FsWatcher[] = [];
   const watchedSources = new Set<string>();
 
-  logger.start(`Watching ${entries.length} replace-deps target(s)`);
+  logger.start(`replace-deps 워치 시작 중... (${entries.length}개 대상)`);
 
   for (const entry of entries) {
     if (watchedSources.has(entry.resolvedSourcePath)) continue;
@@ -359,7 +359,7 @@ export async function watchReplaceDeps(
             }
           } catch (err) {
             logger.error(
-              `Copy failed (${e.targetName}/${relativePath}): ${err instanceof Error ? err.message : err}`,
+              `[${e.targetName}] 복사 실패 (${relativePath}): ${err instanceof Error ? err.message : err}`,
             );
           }
         }
@@ -369,7 +369,7 @@ export async function watchReplaceDeps(
     watchers.push(watcher);
   }
 
-  logger.success(`Replace-deps watch ready`);
+  logger.success("replace-deps 워치 준비 완료");
 
   return {
     entries,

package/src/utils/worker-utils.ts

@@ -33,7 +33,7 @@ export function registerCleanupHandlers(
         process.exit(0);
       })
       .catch((err) => {
-        logger.error("cleanup failed", err);
+        logger.error("정리 작업 실패", err);
         process.exit(1);
       });
   };

package/src/workers/server-build.worker.ts

@@ -142,7 +142,7 @@ async function cleanup(): Promise<void> {
  * Uses single-pass dependency tree traversal via collectAllDependencyExternals.
  */
 function collectAllExternals(pkgDir: string, manualExternals?: string[]): string[] {
-  logger.debug("[externals] Scanning dependency tree (single pass)...");
+  logger.debug("의존성 트리 스캔 중...");
   const { optionalPeerDeps, nativeModules } = collectAllDependencyExternals(pkgDir);
 
   const manual = manualExternals ?? [];
@@ -638,7 +638,7 @@ async function startWatch(info: ServerWatchInfo): Promise<void> {
           const result = await rebuildAll();
           sender.send("build", result);
         } else {
-          logger.debug("Changed files not included in build, skipping rebuild");
+          logger.debug("변경된 파일이 빌드에 포함되지 않아 리빌드 건너뜀");
         }
       } catch (err) {
         sender.send("error", { message: errNs.message(err) });

package/src/workers/server-runtime.worker.ts

@@ -63,7 +63,7 @@ async function cleanup(): Promise<void> {
 // Catch runtime errors that occur after server listen() and send them as a custom "error" event
 // (Without this handler, the worker will crash but dev.ts's buildResolver won't be called, causing listr to hang)
 process.on("uncaughtException", (err) => {
-  logger.error("Unhandled server runtime error", err);
+  logger.error("서버 런타임 미처리 에러", err);
   sender.send("error", {
     message: errNs.message(err),
   });
@@ -72,7 +72,7 @@ process.on("uncaughtException", (err) => {
 });
 
 process.on("unhandledRejection", (reason) => {
-  logger.error("Unhandled server runtime promise rejection", reason);
+  logger.error("서버 런타임 미처리 Promise 거부", reason);
   sender.send("error", {
     message: errNs.message(reason),
   });
@@ -127,10 +127,10 @@ async function start(info: ServerRuntimeStartInfo): Promise<void> {
     }
 
     // Import main.js (must export a server instance)
-    logger.debug("[start] Importing main.js...");
+    logger.debug("main.js 임포트 중...");
     let stepStart = performance.now();
     const module = await import(pathToFileURL(info.mainJsPath).href);
-    logger.debug(`[start] main.js imported (${Math.round(performance.now() - stepStart)}ms)`);
+    logger.debug(`main.js 임포트 완료 (${Math.round(performance.now() - stepStart)}ms)`);
     const server = module.server;
 
     if (server == null) {
@@ -143,7 +143,7 @@ async function start(info: ServerRuntimeStartInfo): Promise<void> {
     // Register client proxies (before listen)
     if (info.clientPorts != null && Object.keys(info.clientPorts).length > 0) {
       for (const [name, port] of Object.entries(info.clientPorts)) {
-        logger.debug(`[start] Registering proxy: /${name} -> http://127.0.0.1:${String(port)}`);
+        logger.debug(`프록시 등록: /${name} → http://127.0.0.1:${String(port)}`);
         await server.fastify.register(proxy, {
           prefix: `/${name}`,
           upstream: `http://127.0.0.1:${port}`,
@@ -154,31 +154,31 @@ async function start(info: ServerRuntimeStartInfo): Promise<void> {
     }
 
     // Find available port (auto-increment on port conflict)
-    logger.debug("[start] Finding available port...");
+    logger.debug("사용 가능한 포트 탐색 중...");
     stepStart = performance.now();
     const originalPort = server.options.port;
     const availablePort = await findAvailablePort(originalPort);
     if (availablePort !== originalPort) {
-      logger.info(`Port ${originalPort} in use, changing to ${availablePort}`);
+      logger.info(`포트 ${originalPort} 사용 중, ${availablePort}로 변경`);
       server.options.port = availablePort;
     }
     logger.debug(
-      `[start] Port ${String(availablePort)} available (${Math.round(performance.now() - stepStart)}ms)`,
+      `포트 ${String(availablePort)} 사용 가능 (${Math.round(performance.now() - stepStart)}ms)`,
     );
 
-    // Start server
-    logger.debug("[start] Starting server listen...");
+    // 서버 시작
+    logger.debug("서버 리슨 시작...");
     stepStart = performance.now();
     await server.listen();
-    logger.debug(`[start] Server listening (${Math.round(performance.now() - stepStart)}ms)`);
+    logger.debug(`서버 리슨 완료 (${Math.round(performance.now() - stepStart)}ms)`);
 
     logger.debug(
-      `[start] Total runtime startup: ${Math.round(performance.now() - startTime)}ms`,
+      `런타임 총 시작 시간: ${Math.round(performance.now() - startTime)}ms`,
     );
 
     sender.send("serverReady", { port: server.options.port });
   } catch (err) {
-    logger.error("Server Runtime startup failed", err);
+    logger.error("서버 런타임 시작 실패", err);
     sender.send("error", {
       message: errNs.message(err),
     });