@simplysm/sd-cli 13.0.0-beta.46 → 13.0.0-beta.48

package/src/commands/typecheck.ts

@@ -0,0 +1,329 @@
+import ts from "typescript";
+import path from "path";
+import os from "os";
+import { Listr } from "listr2";
+import { pathPosix, pathFilterByTargets, Worker, type WorkerProxy } from "@simplysm/core-node";
+import "@simplysm/core-common";
+import { consola, LogLevels } from "consola";
+import type { SdConfig } from "../sd-config.types";
+import { parseRootTsconfig, type TypecheckEnv } from "../utils/tsconfig";
+import { loadSdConfig } from "../utils/sd-config";
+import { deserializeDiagnostic } from "../utils/typecheck-serialization";
+import type { DtsBuildInfo, DtsBuildResult } from "../workers/dts.worker";
+import type * as DtsWorkerModule from "../workers/dts.worker";
+
+//#region Types
+
+/**
+ * TypeScript 타입체크 옵션
+ */
+export interface TypecheckOptions {
+  /** 타입체크할 경로 필터 (예: `packages/core-common`). 빈 배열이면 tsconfig.json에 정의된 모든 파일 대상 */
+  targets: string[];
+  /** sd.config.ts에 전달할 추가 옵션 */
+  options: string[];
+}
+
+// 패키지 정보 (packages/* 하위 파일 분류용)
+interface PackageInfo {
+  name: string;
+  dir: string;
+  envs: TypecheckEnv[]; // neutral은 ["node", "browser"], 나머지는 단일 환경
+}
+
+// 타입체크 작업 정보 (내부 사용)
+interface TypecheckTask {
+  /** 작업 표시 이름 (예: "패키지: core-common [node]") */
+  displayName: string;
+  /** dts.worker에 전달할 정보 */
+  buildInfo: DtsBuildInfo;
+}
+
+//#endregion
+
+//#region Utilities
+
+/** 경로 분류용 정규표현식 */
+const PATH_PATTERNS = {
+  /** packages/{pkg}/... */
+  PACKAGE: /^packages\/([^/]+)\//,
+} as const;
+
+/**
+ * 패키지 타겟을 타입체크 환경 목록으로 변환합니다.
+ * - node/browser: 해당 환경만
+ * - neutral: node + browser 둘 다
+ * - client: browser로 처리
+ * @param target 패키지 빌드 타겟
+ * @returns 타입체크 환경 목록
+ */
+function toTypecheckEnvs(target: string | undefined): TypecheckEnv[] {
+  if (target === "node") return ["node"];
+  if (target === "browser" || target === "client") return ["browser"];
+  // neutral 또는 미지정은 둘 다
+  return ["node", "browser"];
+}
+
+/**
+ * 파일 경로에서 패키지 정보를 추출합니다.
+ * scripts 타겟 패키지는 제외합니다.
+ * @internal 테스트용으로 export
+ */
+export function extractPackages(fileNames: string[], cwd: string, config: SdConfig): Map<string, PackageInfo> {
+  const packages = new Map<string, PackageInfo>();
+
+  for (const fileName of fileNames) {
+    const relativePath = pathPosix(path.relative(cwd, fileName));
+
+    // packages/{pkg}/...
+    const packageMatch = relativePath.match(PATH_PATTERNS.PACKAGE);
+    if (packageMatch) {
+      const pkgName = packageMatch[1];
+      // scripts 타겟 패키지는 제외
+      if (config.packages[pkgName]?.target === "scripts") continue;
+
+      if (!packages.has(pkgName)) {
+        packages.set(pkgName, {
+          name: pkgName,
+          dir: path.resolve(cwd, "packages", pkgName),
+          envs: toTypecheckEnvs(config.packages[pkgName]?.target),
+        });
+      }
+    }
+  }
+
+  return packages;
+}
+
+/**
+ * 패키지 정보로부터 타입체크 작업 목록을 생성합니다.
+ * neutral 패키지는 node/browser 두 환경으로 분리하여 각각 체크합니다.
+ * @param packages 패키지 정보 맵
+ * @param cwd 현재 작업 디렉토리
+ * @returns 타입체크 작업 정보 배열
+ */
+function createTypecheckTasks(packages: Map<string, PackageInfo>, cwd: string): TypecheckTask[] {
+  const tasks: TypecheckTask[] = [];
+
+  // packages/* - 각 env마다 별도 task 생성
+  for (const info of packages.values()) {
+    for (const env of info.envs) {
+      const envSuffix = info.envs.length > 1 ? ` [${env}]` : "";
+      tasks.push({
+        displayName: `패키지: ${info.name}${envSuffix}`,
+        buildInfo: {
+          name: info.name,
+          cwd,
+          pkgDir: info.dir,
+          env,
+          emit: false, // 타입체크만 수행 (dts 생성 안 함)
+        },
+      });
+    }
+  }
+
+  return tasks;
+}
+
+//#endregion
+
+//#region Main
+
+/**
+ * TypeScript 타입체크를 실행한다.
+ *
+ * - `tsconfig.json`을 로드하여 컴파일러 옵션 적용
+ * - `sd.config.ts`를 로드하여 패키지별 타겟 정보 확인 (없으면 기본값 사용)
+ * - Worker threads를 사용하여 실제 병렬 타입체크 수행
+ * - incremental 컴파일 사용 (`.cache/typecheck-{env}.tsbuildinfo`)
+ * - listr2를 사용하여 진행 상황 표시
+ * - 에러 발생 시 `process.exitCode = 1` 설정
+ *
+ * @param options - 타입체크 실행 옵션
+ * @returns 완료 시 resolve. 에러 발견 시 `process.exitCode`를 1로 설정하고 resolve (throw하지 않음)
+ */
+export async function runTypecheck(options: TypecheckOptions): Promise<void> {
+  const { targets } = options;
+  const cwd = process.cwd();
+  const logger = consola.withTag("sd:cli:typecheck");
+
+  logger.debug("타입체크 시작", { targets });
+
+  const formatHost: ts.FormatDiagnosticsHost = {
+    getCanonicalFileName: (f) => f,
+    getCurrentDirectory: () => cwd,
+    getNewLine: () => ts.sys.newLine,
+  };
+
+  // tsconfig.json 로드 및 파싱
+  let parsedConfig: ts.ParsedCommandLine;
+  try {
+    parsedConfig = parseRootTsconfig(cwd);
+  } catch (err) {
+    consola.error(err instanceof Error ? err.message : err);
+    process.exitCode = 1;
+    return;
+  }
+
+  // sd.config.ts 로드
+  let sdConfig: SdConfig;
+  try {
+    sdConfig = await loadSdConfig({ cwd, dev: false, opt: options.options });
+    logger.debug("sd.config.ts 로드 완료");
+  } catch (err) {
+    // sd.config.ts가 없거나 로드 실패 시 기본값 사용
+    sdConfig = { packages: {} };
+    logger.debug("sd.config.ts 로드 실패, 기본값 사용", err);
+  }
+
+  // targets가 지정되면 fileNames 필터링
+  const fileNames = pathFilterByTargets(parsedConfig.fileNames, targets, cwd);
+
+  if (fileNames.length === 0) {
+    process.stdout.write("✔ 타입체크할 파일이 없습니다.\n");
+    logger.info("타입체크할 파일 없음");
+    return;
+  }
+
+  // 패키지 정보 추출
+  const packages = extractPackages(fileNames, cwd, sdConfig);
+  logger.debug("패키지 추출 완료", {
+    packageCount: packages.size,
+    packages: [...packages.keys()],
+  });
+
+  // 타입체크 작업 생성
+  const tasks = createTypecheckTasks(packages, cwd);
+
+  if (tasks.length === 0) {
+    process.stdout.write("✔ 타입체크할 패키지가 없습니다.\n");
+    return;
+  }
+
+  // 동시성 설정: CPU 코어의 7/8만 사용 (일반적인 병렬 빌드 도구의 기본값, OS/다른 프로세스 여유분 확보, 최소 1, 작업 수 이하)
+  const maxConcurrency = Math.max(Math.floor((os.cpus().length * 7) / 8), 1);
+  const concurrency = Math.min(maxConcurrency, tasks.length);
+  logger.debug("동시성 설정", { concurrency, maxConcurrency, taskCount: tasks.length });
+
+  // Worker 풀 생성 (작업 수만큼만 생성)
+  const workerPath = import.meta.resolve("../workers/dts.worker");
+  const workers: WorkerProxy<typeof DtsWorkerModule>[] = [];
+  for (let i = 0; i < concurrency; i++) {
+    workers.push(Worker.create<typeof DtsWorkerModule>(workerPath));
+  }
+
+  // 결과 수집용
+  const allResults: { displayName: string; result: DtsBuildResult }[] = [];
+
+  // listr2-Worker 연동 패턴:
+  // 1. listr2의 각 task는 Promise를 반환하고, 해당 Promise가 resolve되면 task가 완료됨
+  // 2. taskResolvers 맵에 task별 resolve 함수를 저장
+  // 3. Worker가 작업 완료 시 해당 task의 resolver를 호출하여 listr2 UI 업데이트
+  // 4. Worker 풀은 독립적으로 작업 큐에서 task를 가져와 실행
+  const taskResolvers = new Map<string, () => void>();
+
+  try {
+    // 작업 큐
+    let taskIndex = 0;
+
+    // Worker에서 작업 실행
+    async function runNextTask(worker: WorkerProxy<typeof DtsWorkerModule>): Promise<void> {
+      while (taskIndex < tasks.length) {
+        const currentIndex = taskIndex++;
+        const task = tasks[currentIndex];
+
+        try {
+          const result = await worker.buildDts(task.buildInfo);
+
+          allResults.push({ displayName: task.displayName, result });
+        } catch (err) {
+          // Worker 오류 로깅 및 결과로 변환
+          logger.error(`Worker 오류: ${task.displayName}`, {
+            error: err instanceof Error ? err.message : String(err),
+          });
+          allResults.push({
+            displayName: task.displayName,
+            result: {
+              success: false,
+              errors: [err instanceof Error ? err.message : String(err)],
+              diagnostics: [],
+              errorCount: 1,
+              warningCount: 0,
+            },
+          });
+        } finally {
+          // 성공/실패 모두 task 완료 처리
+          taskResolvers.get(task.displayName)?.();
+        }
+      }
+    }
+
+    // listr2로 진행 상황 표시
+    const listr = new Listr(
+      tasks.map((task) => ({
+        title: task.displayName,
+        task: () =>
+          new Promise<void>((resolve) => {
+            taskResolvers.set(task.displayName, resolve);
+          }),
+      })),
+      {
+        concurrent: concurrency,
+        exitOnError: false,
+        renderer: consola.level >= LogLevels.debug ? "verbose" : "default",
+      },
+    );
+
+    // 병렬로 모든 worker 실행
+    const workerPromises = workers.map((worker) => runNextTask(worker));
+
+    // listr와 worker 동시 실행
+    await Promise.all([listr.run(), ...workerPromises]);
+  } finally {
+    // 미해결 resolver 정리 (타임아웃/비정상 종료 대비)
+    for (const resolver of taskResolvers.values()) {
+      resolver();
+    }
+    // Worker 종료 (성공/실패 모두)
+    await Promise.all(workers.map((w) => w.terminate()));
+  }
+
+  // 결과 출력
+  const allDiagnostics: ts.Diagnostic[] = [];
+  let totalErrorCount = 0;
+  let totalWarningCount = 0;
+  const fileCache = new Map<string, string>(); // 파일 내용 캐시 (동일 파일 중복 읽기 방지)
+  for (const { result } of allResults) {
+    totalErrorCount += result.errorCount;
+    totalWarningCount += result.warningCount;
+    for (const serialized of result.diagnostics) {
+      allDiagnostics.push(deserializeDiagnostic(serialized, fileCache));
+    }
+  }
+
+  if (totalErrorCount > 0) {
+    logger.error("타입체크 에러 발생", {
+      errorCount: totalErrorCount,
+      warningCount: totalWarningCount,
+    });
+  } else if (totalWarningCount > 0) {
+    logger.info("타입체크 완료 (경고 있음)", {
+      errorCount: totalErrorCount,
+      warningCount: totalWarningCount,
+    });
+  } else {
+    logger.info("타입체크 완료", { errorCount: totalErrorCount, warningCount: totalWarningCount });
+  }
+
+  if (allDiagnostics.length > 0) {
+    const uniqueDiagnostics = ts.sortAndDeduplicateDiagnostics(allDiagnostics);
+    const message = ts.formatDiagnosticsWithColorAndContext(uniqueDiagnostics, formatHost);
+    process.stdout.write(message);
+  }
+
+  if (totalErrorCount > 0) {
+    process.exitCode = 1;
+  }
+}
+
+//#endregion

package/src/commands/watch.ts

@@ -0,0 +1,38 @@
+// packages/cli/src/commands/watch.ts
+import { WatchOrchestrator, type WatchOrchestratorOptions } from "../orchestrators/WatchOrchestrator";
+
+/**
+ * Watch 명령 옵션 (하위 호환성)
+ */
+export interface WatchOptions {
+  targets: string[];
+  options: string[];
+}
+
+/**
+ * Library 패키지를 watch 모드로 빌드한다.
+ *
+ * - `sd.config.ts`를 로드하여 패키지별 빌드 타겟 정보 확인 (필수)
+ * - `node`/`browser`/`neutral` 타겟: esbuild watch 모드로 빌드 + .d.ts 생성
+ * - 파일 변경 시 자동 리빌드
+ * - SIGINT/SIGTERM 시그널로 종료
+ *
+ * @param options - watch 실행 옵션
+ * @returns 종료 시그널 수신 시 resolve
+ */
+export async function runWatch(options: WatchOptions): Promise<void> {
+  const orchestratorOptions: WatchOrchestratorOptions = {
+    targets: options.targets,
+    options: options.options,
+  };
+
+  const orchestrator = new WatchOrchestrator(orchestratorOptions);
+
+  try {
+    await orchestrator.initialize();
+    await orchestrator.start();
+    await orchestrator.awaitTermination();
+  } finally {
+    await orchestrator.shutdown();
+  }
+}

package/src/electron/electron.ts

@@ -0,0 +1,329 @@
+import path from "path";
+import os from "os";
+import fs from "fs";
+import module from "module";
+import { fsExists, fsMkdir, fsCopy, fsReaddir, fsReadJson, fsWriteJson } from "@simplysm/core-node";
+import { consola } from "consola";
+import type { SdElectronConfig } from "../sd-config.types";
+import { spawn } from "../utils/spawn";
+
+/**
+ * package.json 타입
+ */
+interface NpmConfig {
+  name: string;
+  version: string;
+  description?: string;
+  dependencies?: Record<string, string>;
+}
+
+/**
+ * Electron 프로젝트 관리 클래스
+ *
+ * - Electron 프로젝트 초기화 (package.json 생성, 의존성 설치, native 모듈 재빌드)
+ * - Windows 실행 파일 빌드 (electron-builder)
+ * - 개발 모드 실행 (Vite dev server URL 로드)
+ */
+export class Electron {
+  private static readonly _logger = consola.withTag("sd:cli:electron");
+
+  private readonly _electronPath: string;
+  private readonly _npmConfig: NpmConfig;
+
+  private constructor(
+    private readonly _pkgPath: string,
+    private readonly _config: SdElectronConfig,
+    npmConfig: NpmConfig,
+  ) {
+    this._npmConfig = npmConfig;
+    this._electronPath = path.resolve(this._pkgPath, ".electron");
+  }
+
+  /**
+   * Electron 인스턴스 생성 (설정 검증 포함)
+   */
+  static async create(pkgPath: string, config: SdElectronConfig): Promise<Electron> {
+    Electron._validateConfig(config);
+
+    const npmConfig = await fsReadJson<NpmConfig>(path.resolve(pkgPath, "package.json"));
+    return new Electron(pkgPath, config, npmConfig);
+  }
+
+  /**
+   * 설정 검증
+   */
+  private static _validateConfig(config: SdElectronConfig): void {
+    if (typeof config.appId !== "string" || config.appId.trim() === "") {
+      throw new Error("electron.appId는 필수입니다.");
+    }
+  }
+
+  /**
+   * 명령어 실행 (로깅 포함)
+   */
+  private async _exec(cmd: string, args: string[], cwd: string, env?: Record<string, string>): Promise<string> {
+    Electron._logger.debug(`실행 명령: ${cmd} ${args.join(" ")}`);
+    const result = await spawn(cmd, args, { cwd, env });
+    Electron._logger.debug(`실행 결과: ${result}`);
+    return result;
+  }
+
+  //#region Public Methods
+
+  /**
+   * Electron 프로젝트 초기화
+   *
+   * 1. .electron/src/package.json 생성
+   * 2. npm install 실행
+   * 3. electron-rebuild 실행 (native 모듈 재빌드)
+   */
+  async initialize(): Promise<void> {
+    const srcPath = path.resolve(this._electronPath, "src");
+
+    // 1. package.json 생성
+    await this._setupPackageJson(srcPath);
+
+    // 2. npm install
+    await this._exec("npm", ["install"], srcPath);
+
+    // 3. native 모듈 재빌드
+    const reinstallDeps = this._config.reinstallDependencies ?? [];
+    if (reinstallDeps.length > 0) {
+      await this._exec("npx", ["electron-rebuild"], srcPath);
+    }
+  }
+
+  /**
+   * 프로덕션 빌드
+   *
+   * 1. esbuild로 electron-main.ts 번들링
+   * 2. 웹 에셋 복사
+   * 3. electron-builder 설정 생성
+   * 4. electron-builder 실행
+   * 5. 결과물 복사
+   */
+  async build(outPath: string): Promise<void> {
+    const srcPath = path.resolve(this._electronPath, "src");
+
+    // 1. electron-main.ts 번들링
+    await this._bundleMainProcess(srcPath);
+
+    // 2. 웹 에셋 복사 (outPath → .electron/src/)
+    await this._copyWebAssets(outPath, srcPath);
+
+    // 3. electron-builder 설정 생성 + 실행
+    await this._runElectronBuilder(srcPath);
+
+    // 4. 결과물 복사
+    await this._copyBuildOutput(outPath);
+  }
+
+  /**
+   * 개발 모드 실행
+   *
+   * 1. esbuild로 electron-main.ts 번들링
+   * 2. dist/electron/package.json 생성
+   * 3. npx electron . 실행
+   */
+  async run(url?: string): Promise<void> {
+    const electronRunPath = path.resolve(this._pkgPath, "dist/electron");
+
+    // 1. electron-main.ts 번들링
+    await this._bundleMainProcess(electronRunPath);
+
+    // 2. package.json 생성
+    await fsMkdir(electronRunPath);
+    await fsWriteJson(
+      path.resolve(electronRunPath, "package.json"),
+      { name: this._npmConfig.name, version: this._npmConfig.version, main: "electron-main.js" },
+      { space: 2 },
+    );
+
+    // 3. Electron 실행
+    const runEnv: Record<string, string> = {
+      NODE_ENV: "development",
+      ...this._config.env,
+    };
+
+    if (url != null) {
+      runEnv["ELECTRON_DEV_URL"] = url;
+    }
+
+    await this._exec("npx", ["electron", "."], electronRunPath, runEnv);
+  }
+
+  //#endregion
+
+  //#region Private - 초기화
+
+  /**
+   * .electron/src/package.json 생성
+   */
+  private async _setupPackageJson(srcPath: string): Promise<void> {
+    await fsMkdir(srcPath);
+
+    const reinstallDeps = this._config.reinstallDependencies ?? [];
+
+    // 메인 package.json에서 reinstallDependencies에 해당하는 버전 추출
+    const dependencies: Record<string, string> = {};
+    for (const dep of reinstallDeps) {
+      const version = this._npmConfig.dependencies?.[dep];
+      if (version != null) {
+        dependencies[dep] = version;
+      }
+    }
+
+    const packageJson: Record<string, unknown> = {
+      name: this._npmConfig.name.replace(/^@/, "").replace(/\//, "-"),
+      version: this._npmConfig.version,
+      description: this._npmConfig.description,
+      main: "electron-main.js",
+      dependencies,
+    };
+
+    if (this._config.postInstallScript != null) {
+      packageJson["scripts"] = { postinstall: this._config.postInstallScript };
+    }
+
+    await fsWriteJson(path.resolve(srcPath, "package.json"), packageJson, { space: 2 });
+  }
+
+  //#endregion
+
+  //#region Private - 번들링
+
+  /**
+   * esbuild로 electron-main.ts 번들링
+   */
+  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}`);
+    }
+
+    const builtinModules = module.builtinModules.flatMap((m) => [m, `node:${m}`]);
+    const reinstallDeps = this._config.reinstallDependencies ?? [];
+
+    await fsMkdir(outDir);
+
+    await esbuild.build({
+      entryPoints: [entryPoint],
+      outfile: path.resolve(outDir, "electron-main.js"),
+      platform: "node",
+      target: "node20",
+      format: "cjs",
+      bundle: true,
+      external: ["electron", ...builtinModules, ...reinstallDeps],
+    });
+  }
+
+  //#endregion
+
+  //#region Private - 빌드
+
+  /**
+   * 웹 에셋 복사 (빌드 결과물 → .electron/src/)
+   */
+  private async _copyWebAssets(outPath: string, srcPath: string): Promise<void> {
+    const items = await fsReaddir(outPath);
+    for (const item of items) {
+      // electron/ 하위는 제외 (자기 자신 복사 방지)
+      if (item === "electron") continue;
+
+      const source = path.resolve(outPath, item);
+      const dest = path.resolve(srcPath, item);
+      await fsCopy(source, dest);
+    }
+  }
+
+  /**
+   * Symlink 생성 가능 여부 확인 (Windows 빌드 요구사항)
+   */
+  private static _canCreateSymlink(): boolean {
+    const tmpDir = os.tmpdir();
+    const testTarget = path.join(tmpDir, "sd-electron-symlink-test-target.txt");
+    const testLink = path.join(tmpDir, "sd-electron-symlink-test-link.txt");
+
+    try {
+      fs.writeFileSync(testTarget, "test");
+      fs.symlinkSync(testTarget, testLink, "file");
+      const isSymlink = fs.lstatSync(testLink).isSymbolicLink();
+      fs.unlinkSync(testLink);
+      fs.unlinkSync(testTarget);
+      return isSymlink;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * electron-builder 실행
+   */
+  private async _runElectronBuilder(srcPath: string): Promise<void> {
+    if (!Electron._canCreateSymlink()) {
+      throw new Error("Electron 빌드를 위해서는 Symlink 생성 권한이 필요합니다. 윈도우의 개발자모드를 활성화하세요.");
+    }
+
+    const distPath = path.resolve(this._electronPath, "dist");
+
+    const builderConfig: Record<string, unknown> = {
+      appId: this._config.appId,
+      productName: this._npmConfig.description,
+      asar: false,
+      win: {
+        target: this._config.portable ? "portable" : "nsis",
+      },
+      nsis: this._config.nsisOptions ?? {},
+      directories: {
+        app: srcPath,
+        output: distPath,
+      },
+      removePackageScripts: false,
+      npmRebuild: false,
+      forceCodeSigning: false,
+    };
+
+    if (this._config.installerIcon != null) {
+      builderConfig["icon"] = path.resolve(this._pkgPath, this._config.installerIcon);
+    }
+
+    const configFilePath = path.resolve(this._electronPath, "builder-config.json");
+    await fsWriteJson(configFilePath, builderConfig, { space: 2 });
+
+    await this._exec("npx", ["electron-builder", "--win", "--config", configFilePath], this._pkgPath);
+  }
+
+  /**
+   * 빌드 결과물 복사 (.electron/dist/ → dist/electron/)
+   */
+  private async _copyBuildOutput(outPath: string): Promise<void> {
+    const distPath = path.resolve(this._electronPath, "dist");
+    const electronOutPath = path.resolve(outPath, "electron");
+    await fsMkdir(electronOutPath);
+
+    const description = this._npmConfig.description ?? this._npmConfig.name;
+    const version = this._npmConfig.version;
+    const isPortable = this._config.portable === true;
+
+    // electron-builder 출력 파일명
+    const builderFileName = `${description} ${isPortable ? "" : "Setup "}${version}.exe`;
+    const sourcePath = path.resolve(distPath, builderFileName);
+
+    if (await fsExists(sourcePath)) {
+      // latest 파일 복사
+      const latestFileName = `${description}${isPortable ? "-portable" : ""}-latest.exe`;
+      await fsCopy(sourcePath, path.resolve(electronOutPath, latestFileName));
+
+      // updates/ 버전별 파일 복사
+      const updatesPath = path.resolve(electronOutPath, "updates");
+      await fsMkdir(updatesPath);
+      await fsCopy(sourcePath, path.resolve(updatesPath, `${version}.exe`));
+    } else {
+      Electron._logger.warn(`빌드 결과물을 찾을 수 없습니다: ${sourcePath}`);
+    }
+  }
+
+  //#endregion
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./sd-config.types";