@simplysm/sd-cli 13.0.68 → 13.0.70

package/src/electron/electron.ts

@@ -8,7 +8,7 @@ import type { SdElectronConfig } from "../sd-config.types";
 import { execa } from "execa";
 
 /**
- * package.json 타입
+ * package.json type
  */
 interface NpmConfig {
   name: string;
@@ -18,11 +18,11 @@ interface NpmConfig {
 }
 
 /**
- * Electron 프로젝트 관리 클래스
+ * Electron project management class
  *
- * - Electron 프로젝트 초기화 (package.json 생성, 의존성 설치, native 모듈 재빌드)
- * - Windows 실행 파일 빌드 (electron-builder)
- * - 개발 모드 실행 (Vite dev server URL 로드)
+ * - Initialize Electron project (create package.json, install dependencies, rebuild native modules)
+ * - Build Windows executable (electron-builder)
+ * - Run in development mode (load Vite dev server URL)
  */
 export class Electron {
   private static readonly _logger = consola.withTag("sd:cli:electron");
@@ -40,7 +40,7 @@ export class Electron {
   }
 
   /**
-   * Electron 인스턴스 생성 (설정 검증 포함)
+   * Create Electron instance (with configuration validation)
    */
   static async create(pkgPath: string, config: SdElectronConfig): Promise<Electron> {
     Electron._validateConfig(config);
@@ -50,16 +50,16 @@ export class Electron {
   }
 
   /**
-   * 설정 검증
+   * Validate configuration
    */
   private static _validateConfig(config: SdElectronConfig): void {
     if (typeof config.appId !== "string" || config.appId.trim() === "") {
-      throw new Error("electron.appId는 필수입니다.");
+      throw new Error("electron.appId is required.");
     }
   }
 
   /**
-   * 명령어 실행 (로깅 포함)
+   * Execute command (with logging)
    */
   private async _exec(
     cmd: string,
@@ -67,31 +67,31 @@ export class Electron {
     cwd: string,
     env?: Record<string, string>,
   ): Promise<string> {
-    Electron._logger.debug(`실행 명령: ${cmd} ${args.join(" ")}`);
+    Electron._logger.debug(`executed command: ${cmd} ${args.join(" ")}`);
     const { stdout: result } = await execa(cmd, args, { cwd, env: { ...process.env, ...env } });
-    Electron._logger.debug(`실행 결과: ${result}`);
+    Electron._logger.debug(`execution result: ${result}`);
     return result;
   }
 
   //#region Public Methods
 
   /**
-   * Electron 프로젝트 초기화
+   * Initialize Electron project
    *
-   * 1. .electron/src/package.json 생성
-   * 2. npm install 실행
-   * 3. electron-rebuild 실행 (native 모듈 재빌드)
+   * 1. Create .electron/src/package.json
+   * 2. Run npm install
+   * 3. Run electron-rebuild (rebuild native modules)
    */
   async initialize(): Promise<void> {
     const srcPath = path.resolve(this._electronPath, "src");
 
-    // 1. package.json 생성
+    // 1. Create package.json
     await this._setupPackageJson(srcPath);
 
     // 2. npm install
     await this._exec("npm", ["install"], srcPath);
 
-    // 3. native 모듈 재빌드
+    // 3. Rebuild native modules
     const reinstallDeps = this._config.reinstallDependencies ?? [];
     if (reinstallDeps.length > 0) {
       await this._exec("npx", ["electron-rebuild"], srcPath);
@@ -99,44 +99,44 @@ export class Electron {
   }
 
   /**
-   * 프로덕션 빌드
+   * Production build
    *
-   * 1. esbuild로 electron-main.ts 번들링
-   * 2. 웹 에셋 복사
-   * 3. electron-builder 설정 생성
-   * 4. electron-builder 실행
-   * 5. 결과물 복사
+   * 1. Bundle electron-main.ts with esbuild
+   * 2. Copy web assets
+   * 3. Create electron-builder configuration
+   * 4. Run electron-builder
+   * 5. Copy build output
    */
   async build(outPath: string): Promise<void> {
     const srcPath = path.resolve(this._electronPath, "src");
 
-    // 1. electron-main.ts 번들링
+    // 1. Bundle electron-main.ts
     await this._bundleMainProcess(srcPath);
 
-    // 2. 웹 에셋 복사 (outPath → .electron/src/)
+    // 2. Copy web assets (outPath → .electron/src/)
     await this._copyWebAssets(outPath, srcPath);
 
-    // 3. electron-builder 설정 생성 + 실행
+    // 3. Create electron-builder configuration and run
     await this._runElectronBuilder(srcPath);
 
-    // 4. 결과물 복사
+    // 4. Copy build output
     await this._copyBuildOutput(outPath);
   }
 
   /**
-   * 개발 모드 실행
+   * Run in development mode
    *
-   * 1. esbuild로 electron-main.ts 번들링
-   * 2. dist/electron/package.json 생성
-   * 3. npx electron . 실행
+   * 1. Bundle electron-main.ts with esbuild
+   * 2. Create dist/electron/package.json
+   * 3. Run npx electron .
    */
   async run(url?: string): Promise<void> {
     const electronRunPath = path.resolve(this._pkgPath, "dist/electron");
 
-    // 1. electron-main.ts 번들링
+    // 1. Bundle electron-main.ts
     await this._bundleMainProcess(electronRunPath);
 
-    // 2. package.json 생성
+    // 2. Create package.json
     await fsMkdir(electronRunPath);
     await fsWriteJson(
       path.resolve(electronRunPath, "package.json"),
@@ -144,7 +144,7 @@ export class Electron {
       { space: 2 },
     );
 
-    // 3. Electron 실행
+    // 3. Run Electron
     const runEnv: Record<string, string> = {
       NODE_ENV: "development",
       ...this._config.env,
@@ -159,17 +159,17 @@ export class Electron {
 
   //#endregion
 
-  //#region Private - 초기화
+  //#region Private - Initialization
 
   /**
-   * .electron/src/package.json 생성
+   * Create .electron/src/package.json
    */
   private async _setupPackageJson(srcPath: string): Promise<void> {
     await fsMkdir(srcPath);
 
     const reinstallDeps = this._config.reinstallDependencies ?? [];
 
-    // 메인 package.json에서 reinstallDependencies에 해당하는 버전 추출
+    // Extract versions from main package.json that match reinstallDependencies
     const dependencies: Record<string, string> = {};
     for (const dep of reinstallDeps) {
       const version = this._npmConfig.dependencies?.[dep];
@@ -195,17 +195,17 @@ export class Electron {
 
   //#endregion
 
-  //#region Private - 번들링
+  //#region Private - Bundling
 
   /**
-   * esbuild로 electron-main.ts 번들링
+   * Bundle electron-main.ts with esbuild
    */
   private async _bundleMainProcess(outDir: string): Promise<void> {
     const esbuild = await import("esbuild");
     const entryPoint = path.resolve(this._pkgPath, "src/electron-main.ts");
 
     if (!(await fsExists(entryPoint))) {
-      throw new Error(`electron-main.ts 파일을 찾을 수 없습니다: ${entryPoint}`);
+      throw new Error(`electron-main.ts file not found: ${entryPoint}`);
     }
 
     const builtinModules = module.builtinModules.flatMap((m) => [m, `node:${m}`]);
@@ -226,15 +226,15 @@ export class Electron {
 
   //#endregion
 
-  //#region Private - 빌드
+  //#region Private - Build
 
   /**
-   * 웹 에셋 복사 (빌드 결과물 → .electron/src/)
+   * Copy web assets (build output → .electron/src/)
    */
   private async _copyWebAssets(outPath: string, srcPath: string): Promise<void> {
     const items = await fsReaddir(outPath);
     for (const item of items) {
-      // electron/ 하위는 제외 (자기 자신 복사 방지)
+      // Exclude electron/ subdirectory (prevent self-copying)
       if (item === "electron") continue;
 
       const source = path.resolve(outPath, item);
@@ -244,7 +244,7 @@ export class Electron {
   }
 
   /**
-   * Symlink 생성 가능 여부 확인 (Windows 빌드 요구사항)
+   * Check if symlink creation is possible (Windows build requirement)
    */
   private static _canCreateSymlink(): boolean {
     const tmpDir = os.tmpdir();
@@ -264,12 +264,12 @@ export class Electron {
   }
 
   /**
-   * electron-builder 실행
+   * Run electron-builder
    */
   private async _runElectronBuilder(srcPath: string): Promise<void> {
     if (!Electron._canCreateSymlink()) {
       throw new Error(
-        "Electron 빌드를 위해서는 Symlink 생성 권한이 필요합니다. 윈도우의 개발자모드를 활성화하세요.",
+        "Symlink creation permission is required to build Electron. Enable Developer mode on Windows.",
       );
     }
 
@@ -307,7 +307,7 @@ export class Electron {
   }
 
   /**
-   * 빌드 결과물 복사 (.electron/dist/ → dist/electron/)
+   * Copy build output (.electron/dist/ → dist/electron/)
    */
   private async _copyBuildOutput(outPath: string): Promise<void> {
     const distPath = path.resolve(this._electronPath, "dist");
@@ -318,21 +318,21 @@ export class Electron {
     const version = this._npmConfig.version;
     const isPortable = this._config.portable === true;
 
-    // electron-builder 출력 파일명
+    // electron-builder output filename
     const builderFileName = `${description} ${isPortable ? "" : "Setup "}${version}.exe`;
     const sourcePath = path.resolve(distPath, builderFileName);
 
     if (await fsExists(sourcePath)) {
-      // latest 파일 복사
+      // Copy latest file
       const latestFileName = `${description}${isPortable ? "-portable" : ""}-latest.exe`;
       await fsCopy(sourcePath, path.resolve(electronOutPath, latestFileName));
 
-      // updates/ 버전별 파일 복사
+      // Copy per-version file to updates/
       const updatesPath = path.resolve(electronOutPath, "updates");
       await fsMkdir(updatesPath);
       await fsCopy(sourcePath, path.resolve(updatesPath, `${version}.exe`));
     } else {
-      Electron._logger.warn(`빌드 결과물을 찾을 수 없습니다: ${sourcePath}`);
+      Electron._logger.warn(`build output not found: ${sourcePath}`);
     }
   }
 

package/src/infra/ResultCollector.ts

@@ -1,5 +1,5 @@
 /**
- * 빌드 결과 상태
+ * Build result status
  */
 export interface BuildResult {
   name: string;
@@ -11,17 +11,17 @@ export interface BuildResult {
 }
 
 /**
- * 빌드 결과를 수집하고 관리하는 클래스
+ * Class that collects and manages build results
  *
- * 여러 Builder에서 발생하는 빌드 결과를 중앙에서 관리하고,
- * 상태별 필터링 및 출력 기능을 제공한다.
+ * Manages build results from multiple Builders at a central location and
+ * provides filtering and output functionality by status.
  */
 export class ResultCollector {
   private readonly _results = new Map<string, BuildResult>();
 
   /**
-   * 결과 추가
-   * @param result 빌드 결과
+   * Add result
+   * @param result build result
    */
   add(result: BuildResult): void {
     const key = `${result.name}:${result.type}`;
@@ -29,15 +29,15 @@ export class ResultCollector {
   }
 
   /**
-   * 키로 결과 조회
-   * @param key 결과 키 (예: "core-common:build")
+   * Get result by key
+   * @param key result key (e.g., "core-common:build")
    */
   get(key: string): BuildResult | undefined {
     return this._results.get(key);
   }
 
   /**
-   * 내부 Map 반환 (하위 호환성)
+   * Return internal Map (for backward compatibility)
    */
   toMap(): Map<string, BuildResult> {
     return this._results;

package/src/infra/SignalHandler.ts

@@ -1,8 +1,8 @@
 /**
- * 프로세스 종료 시그널을 처리하는 클래스
+ * Class that handles process termination signals
  *
- * SIGINT (Ctrl+C) 및 SIGTERM 시그널을 감지하고,
- * 종료 시점까지 대기하는 Promise를 제공한다.
+ * Detects SIGINT (Ctrl+C) and SIGTERM signals and
+ * provides a Promise that waits until termination.
  */
 export class SignalHandler {
   private _terminateResolver: (() => void) | null = null;
@@ -26,22 +26,22 @@ export class SignalHandler {
   }
 
   /**
-   * 종료 시그널이 수신될 때까지 대기
+   * Wait until termination signal is received
    */
   waitForTermination(): Promise<void> {
     return this._terminatePromise;
   }
 
   /**
-   * 종료 여부 확인
+   * Check if terminated
    */
   isTerminated(): boolean {
     return this._terminated;
   }
 
   /**
-   * 프로그래밍 방식으로 종료 요청
-   * (테스트 또는 외부에서 종료 트리거 시 사용)
+   * Request termination programmatically
+   * (used when triggering termination from tests or externally)
    */
   requestTermination(): void {
     if (!this._terminated) {

package/src/infra/WorkerManager.ts

@@ -1,19 +1,19 @@
 import { Worker, type WorkerProxy, type WorkerModule } from "@simplysm/core-node";
 
 /**
- * Worker 생명주기를 관리하는 클래스
+ * Class that manages Worker lifecycle
  *
- * Worker 생성, 조회, 종료를 중앙에서 관리하여
- * 리소스 누수를 방지하고 일관된 Worker 관리를 제공한다.
+ * Centrally manages Worker creation, lookup, and termination
+ * to prevent resource leaks and provide consistent Worker management.
  */
 export class WorkerManager {
   private readonly _workers = new Map<string, WorkerProxy<WorkerModule>>();
 
   /**
-   * 새 Worker 생성
-   * @param id Worker 식별자 (예: "core-common:build")
-   * @param workerPath Worker 파일 경로
-   * @returns 생성된 WorkerProxy
+   * Create a new Worker
+   * @param id Worker identifier (e.g., "core-common:build")
+   * @param workerPath Worker file path
+   * @returns Created WorkerProxy
    */
   create<TModule extends WorkerModule>(id: string, workerPath: string): WorkerProxy<TModule> {
     const worker = Worker.create<TModule>(workerPath);
@@ -22,16 +22,16 @@ export class WorkerManager {
   }
 
   /**
-   * ID로 Worker 조회
-   * @param id Worker 식별자
+   * Lookup Worker by ID
+   * @param id Worker identifier
    */
   get<TModule extends WorkerModule>(id: string): WorkerProxy<TModule> | undefined {
     return this._workers.get(id) as WorkerProxy<TModule> | undefined;
   }
 
   /**
-   * 특정 Worker 종료 및 제거
-   * @param id Worker 식별자
+   * Terminate and remove a specific Worker
+   * @param id Worker identifier
    */
   async terminate(id: string): Promise<void> {
     const worker = this._workers.get(id);
@@ -42,7 +42,7 @@ export class WorkerManager {
   }
 
   /**
-   * 모든 Worker 종료
+   * Terminate all Workers
    */
   async terminateAll(): Promise<void> {
     await Promise.all([...this._workers.values()].map((w) => w.terminate()));
@@ -50,14 +50,14 @@ export class WorkerManager {
   }
 
   /**
-   * 관리 중인 Worker 수
+   * Number of managed Workers
    */
   get size(): number {
     return this._workers.size;
   }
 
   /**
-   * 모든 Worker ID 목록
+   * List of all Worker IDs
    */
   get ids(): string[] {
     return [...this._workers.keys()];