@simplysm/sd-cli 14.0.7 → 14.0.9

package/src/electron/electron.ts

@@ -1,10 +1,8 @@
-import path from "path";
 import os from "os";
 import fs from "fs";
 import module from "module";
-import { fsx } from "@simplysm/core-node";
+import { cpx, fsx, pathx } from "@simplysm/core-node";
 import { consola } from "consola";
-import { execa } from "execa";
 import type { SdElectronConfig } from "../sd-config.types.js";
 import { createEnvBanner } from "../utils/esbuild-config.js";
 
@@ -26,7 +24,7 @@ export class Electron {
     private readonly _npmConfig: NpmConfig,
     private readonly _exclude: string[],
   ) {
-    this._electronPath = path.resolve(this._pkgPath, ".electron");
+    this._electronPath = pathx.posixResolve(this._pkgPath, ".electron");
   }
 
   static async create(
@@ -36,7 +34,7 @@ export class Electron {
   ): Promise<Electron> {
     Electron._validateConfig(config);
 
-    const npmConfig = await fsx.readJson<NpmConfig>(path.resolve(pkgPath, "package.json"));
+    const npmConfig = await fsx.readJson<NpmConfig>(pathx.posixResolve(pkgPath, "package.json"));
     return new Electron(pkgPath, config, npmConfig, exclude ?? []);
   }
 
@@ -47,7 +45,7 @@ export class Electron {
   }
 
   private _localBin(name: string): string {
-    return path.resolve(this._pkgPath, "node_modules/.bin", name);
+    return pathx.posixResolve(this._pkgPath, "node_modules/.bin", name);
   }
 
   private async _exec(
@@ -57,7 +55,7 @@ export class Electron {
     env?: Record<string, string>,
   ): Promise<string> {
     Electron._logger.debug(`실행: ${cmd} ${args.join(" ")}`);
-    const { stdout: result } = await execa(cmd, args, { cwd, env: { ...process.env, ...env } });
+    const { stdout: result } = await cpx.exec(cmd, args, { cwd, env, shell: true });
     Electron._logger.debug(`결과: ${result}`);
     return result;
   }
@@ -65,7 +63,7 @@ export class Electron {
   //#region Public Methods
 
   async initialize(): Promise<void> {
-    const srcPath = path.resolve(this._electronPath, "src");
+    const srcPath = pathx.posixResolve(this._electronPath, "src");
 
     await this._setupPackageJson(srcPath);
     await this._exec("npm", ["install"], srcPath);
@@ -77,12 +75,12 @@ export class Electron {
   }
 
   async run(url: string): Promise<void> {
-    const srcPath = path.resolve(this._electronPath, "src");
+    const srcPath = pathx.posixResolve(this._electronPath, "src");
 
     await this.initialize();
 
     const esbuild = await import("esbuild");
-    const entryPoint = path.resolve(this._pkgPath, "src/electron-main.ts");
+    const entryPoint = pathx.posixResolve(this._pkgPath, "src/electron-main.ts");
 
     if (!(await fsx.exists(entryPoint))) {
       throw new Error(`electron-main.ts 파일을 찾을 수 없습니다: ${entryPoint}`);
@@ -92,12 +90,12 @@ export class Electron {
     const reinstallDeps = this._config.reinstallDependencies ?? [];
     await fsx.mkdir(srcPath);
 
-    let currentElectron: import("execa").ResultPromise | null = null;
+    let currentElectron: cpx.ExecProcess | null = null;
     let isRestarting = false;
     let resolveTermination: (() => void) | null = null;
 
     const spawnElectron = () => {
-      currentElectron = execa(this._localBin("electron"), ["."], {
+      currentElectron = cpx.exec(this._localBin("electron"), ["."], {
         cwd: srcPath,
         stdio: "inherit",
         reject: false,
@@ -116,12 +114,12 @@ export class Electron {
 
     const ctx = await esbuild.context({
       entryPoints: [entryPoint],
-      outfile: path.resolve(srcPath, "electron-main.js"),
+      outfile: pathx.posixResolve(srcPath, "electron-main.js"),
       platform: "node",
       target: "node20",
       format: "cjs",
       bundle: true,
-      external: ["electron", ...builtinModules, ...reinstallDeps],
+      external: ["electron", ...builtinModules, ...reinstallDeps, ...this._exclude],
       banner: { js: envBanner },
       plugins: [
         {
@@ -155,15 +153,22 @@ export class Electron {
     await ctx.watch();
 
     await new Promise<void>((resolve) => {
-      resolveTermination = () => {
+      let disposed = false;
+
+      const cleanup = () => {
+        if (disposed) return;
+        disposed = true;
+        process.removeListener("SIGINT", signalHandler);
+        process.removeListener("SIGTERM", signalHandler);
         void ctx.dispose();
         resolve();
       };
 
+      resolveTermination = cleanup;
+
       const signalHandler = () => {
         if (currentElectron != null) currentElectron.kill();
-        void ctx.dispose();
-        resolve();
+        cleanup();
       };
 
       process.once("SIGINT", signalHandler);
@@ -172,7 +177,7 @@ export class Electron {
   }
 
   async build(outPath: string): Promise<void> {
-    const srcPath = path.resolve(this._electronPath, "src");
+    const srcPath = pathx.posixResolve(this._electronPath, "src");
 
     await this._bundleMainProcess(srcPath);
     await this._copyWebAssets(outPath, srcPath);
@@ -218,7 +223,7 @@ export class Electron {
       packageJson["scripts"] = { postinstall: this._config.postInstallScript };
     }
 
-    await fsx.writeJson(path.resolve(srcPath, "package.json"), packageJson, { space: 2 });
+    await fsx.writeJson(pathx.posixResolve(srcPath, "package.json"), packageJson, { space: 2 });
   }
 
   //#endregion
@@ -227,7 +232,7 @@ export class Electron {
 
   private async _bundleMainProcess(outDir: string): Promise<void> {
     const esbuild = await import("esbuild");
-    const entryPoint = path.resolve(this._pkgPath, "src/electron-main.ts");
+    const entryPoint = pathx.posixResolve(this._pkgPath, "src/electron-main.ts");
 
     if (!(await fsx.exists(entryPoint))) {
       throw new Error(`electron-main.ts 파일을 찾을 수 없습니다: ${entryPoint}`);
@@ -242,12 +247,12 @@ export class Electron {
 
     await esbuild.build({
       entryPoints: [entryPoint],
-      outfile: path.resolve(outDir, "electron-main.js"),
+      outfile: pathx.posixResolve(outDir, "electron-main.js"),
       platform: "node",
       target: "node20",
       format: "cjs",
       bundle: true,
-      external: ["electron", ...builtinModules, ...reinstallDeps],
+      external: ["electron", ...builtinModules, ...reinstallDeps, ...this._exclude],
       banner: { js: envBanner },
     });
   }
@@ -261,16 +266,16 @@ export class Electron {
     for (const item of items) {
       if (item === "electron") continue;
 
-      const source = path.resolve(outPath, item);
-      const dest = path.resolve(srcPath, item);
+      const source = pathx.posixResolve(outPath, item);
+      const dest = pathx.posixResolve(srcPath, item);
       await fsx.copy(source, dest);
     }
   }
 
   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");
+    const testTarget = pathx.posixResolve(tmpDir, "sd-electron-symlink-test-target.txt");
+    const testLink = pathx.posixResolve(tmpDir, "sd-electron-symlink-test-link.txt");
 
     try {
       fs.writeFileSync(testTarget, "test");
@@ -291,11 +296,11 @@ export class Electron {
       );
     }
 
-    const distPath = path.resolve(this._electronPath, "dist");
+    const distPath = pathx.posixResolve(this._electronPath, "dist");
 
     const builderConfig: Record<string, unknown> = {
       appId: this._config.appId,
-      productName: this._npmConfig.description,
+      productName: this._npmConfig.description ?? this._npmConfig.name,
       asar: false,
       win: {
         target: this._config.portable === true ? "portable" : "nsis",
@@ -311,10 +316,10 @@ export class Electron {
     };
 
     if (this._config.installerIcon != null) {
-      builderConfig["icon"] = path.resolve(this._pkgPath, this._config.installerIcon);
+      builderConfig["icon"] = pathx.posixResolve(this._pkgPath, this._config.installerIcon);
     }
 
-    const configFilePath = path.resolve(this._electronPath, "builder-config.json");
+    const configFilePath = pathx.posixResolve(this._electronPath, "builder-config.json");
     await fsx.writeJson(configFilePath, builderConfig, { space: 2 });
 
     await this._exec(
@@ -325,16 +330,17 @@ export class Electron {
   }
 
   private async _copyBuildOutput(outPath: string): Promise<void> {
-    const distPath = path.resolve(this._electronPath, "dist");
-    const electronOutPath = path.resolve(outPath, "electron");
+    const distPath = pathx.posixResolve(this._electronPath, "dist");
+    const electronOutPath = pathx.posixResolve(outPath, "electron");
     await fsx.mkdir(electronOutPath);
 
-    const description = this._npmConfig.description ?? this._npmConfig.name;
+    const rawName = this._npmConfig.description ?? this._npmConfig.name;
+    const safeName = rawName.replace(/[<>:"/\\|?*]/g, "");
     const version = this._npmConfig.version;
     const isPortable = this._config.portable === true;
 
     // exe 파일 동적 탐색 — Setup 또는 portable exe를 우선 선택
-    const allExeFiles = await fsx.glob("*.exe", { cwd: distPath });
+    const allExeFiles = await fsx.glob(pathx.posixResolve(distPath, "*.exe"));
     if (allExeFiles.length === 0) {
       Electron._logger.warn(`빌드 산출물(.exe)을 찾을 수 없습니다: ${distPath}`);
       return;
@@ -343,12 +349,12 @@ export class Electron {
     const sourcePath =
       allExeFiles.find((f) => f.toLowerCase().includes(keyword.toLowerCase())) ?? allExeFiles[0];
 
-    const latestFileName = `${description}${isPortable ? "-portable" : ""}-latest.exe`;
-    await fsx.copy(sourcePath, path.resolve(electronOutPath, latestFileName));
+    const latestFileName = `${safeName}${isPortable ? "-portable" : ""}-latest.exe`;
+    await fsx.copy(sourcePath, pathx.posixResolve(electronOutPath, latestFileName));
 
-    const updatesPath = path.resolve(electronOutPath, "updates");
+    const updatesPath = pathx.posixResolve(electronOutPath, "updates");
     await fsx.mkdir(updatesPath);
-    await fsx.copy(sourcePath, path.resolve(updatesPath, `${version}.exe`));
+    await fsx.copy(sourcePath, pathx.posixResolve(updatesPath, `${version}.exe`));
   }
 
   //#endregion

package/src/engines/BaseEngine.ts

@@ -15,8 +15,7 @@ const logger = consola.withTag("sd:cli:engine");
 export interface CommonBuildWorkerEvents extends Record<string, unknown> {
   buildStart: Record<string, never>;
   build: {
-    js: { success: boolean; errors?: string[]; warnings?: string[] };
-    dts: { success: boolean; errors?: string[] };
+    build: { success: boolean; errors?: string[]; warnings?: string[] };
     lint?: LintWithProgramResult;
   };
   error: { message: string };
@@ -132,7 +131,7 @@ export abstract class BaseEngine<
       const workerKey = `${this._pkg.name}:build`;
 
       this._worker!.on("buildStart", () => {
-        if (!isInitialBuild && this._rebuildManager != null) {
+        if (this._rebuildManager != null) {
           resolver = this._rebuildManager.registerBuild(
             workerKey,
             `${this._pkg.name} (${this._getTarget()})`,
@@ -143,30 +142,20 @@ export abstract class BaseEngine<
       this._worker!.on("build", (data) => {
         const event = data;
 
-        if (event.js.warnings != null && event.js.warnings.length > 0) {
-          logger.warn(`${this._pkg.name}: ${event.js.warnings.join(", ")}`);
+        if (event.build.warnings != null && event.build.warnings.length > 0) {
+          logger.warn(`${this._pkg.name}: ${event.build.warnings.join(", ")}`);
         }
 
-        // JS 결과 보고
+        // 빌드 결과 보고
         const buildResult: BuildResult = {
           name: this._pkg.name,
           target: this._getTarget(),
           type: "build",
-          status: event.js.success ? "success" : "error",
-          message: event.js.errors?.join("\n"),
+          status: event.build.success ? "success" : "error",
+          message: event.build.errors?.join("\n"),
         };
         this._resultCollector?.add(buildResult);
 
-        // DTS 결과 보고
-        const dtsResult: BuildResult = {
-          name: this._pkg.name,
-          target: this._getTarget(),
-          type: "dts",
-          status: event.dts.success ? "success" : "error",
-          message: event.dts.errors?.join("\n"),
-        };
-        this._resultCollector?.add(dtsResult);
-
         // 린트 결과 보고 (있는 경우)
         if (event.lint != null) {
           const lintResult: BuildResult = {
@@ -184,7 +173,7 @@ export abstract class BaseEngine<
 
         if (isInitialBuild) {
           isInitialBuild = false;
-          logger.debug(`[${this._pkg.name}] 초기 빌드 완료 (success: ${event.js.success})`);
+          logger.debug(`[${this._pkg.name}] 초기 빌드 완료 (success: ${event.build.success})`);
           resolve();
         }
       });

package/src/engines/NgtscEngine.ts

@@ -3,6 +3,9 @@ import type { ResultCollector } from "../infra/ResultCollector";
 import type { RebuildManager } from "../utils/rebuild-manager";
 import type { BuildOutput, BuildPackageInfo, EngineResult } from "./types";
 import { BaseEngine, type CommonBuildWorkerModule } from "./BaseEngine";
+import { consola } from "consola";
+
+const logger = consola.withTag("sd:cli:engine:ngtsc");
 
 /**
  * NgtscEngine options
@@ -41,6 +44,7 @@ export class NgtscEngine extends BaseEngine<
   }
 
   protected async _callBuild(output: BuildOutput): Promise<EngineResult> {
+    logger.debug(`[${this._pkg.name}] worker.build 호출`);
     const result = await this._worker!.build({
       name: this._pkg.name,
       cwd: this._cwd,
@@ -49,23 +53,19 @@ export class NgtscEngine extends BaseEngine<
     });
 
     return {
-      success: result.js.success && result.dts.success,
-      js: {
-        success: result.js.success,
-        errors: result.js.errors ?? [],
-        warnings: result.js.warnings ?? [],
-      },
-      dts: {
-        success: result.dts.success,
-        errors: result.dts.errors ?? [],
-        warnings: [],
-        diagnostics: result.dts.diagnostics,
+      success: result.build.success,
+      build: {
+        success: result.build.success,
+        errors: result.build.errors ?? [],
+        warnings: result.build.warnings ?? [],
+        diagnostics: result.build.diagnostics,
       },
       lint: result.lint,
     };
   }
 
   protected async _callStartWatch(output: BuildOutput): Promise<void> {
+    logger.debug(`[${this._pkg.name}] worker.startWatch 호출`);
     await this._worker!.startWatch({
       name: this._pkg.name,
       cwd: this._cwd,

package/src/engines/ServerEsbuildEngine.ts

@@ -3,6 +3,9 @@ import type { ResultCollector } from "../infra/ResultCollector";
 import type { RebuildManager } from "../utils/rebuild-manager";
 import type { BuildOutput, EngineResult, ServerPackageInfo } from "./types";
 import { BaseEngine, type CommonBuildWorkerModule } from "./BaseEngine";
+import { consola } from "consola";
+
+const logger = consola.withTag("sd:cli:engine:server");
 
 /**
  * ServerEsbuildEngine options
@@ -41,6 +44,7 @@ export class ServerEsbuildEngine extends BaseEngine<
   }
 
   protected async _callBuild(output: BuildOutput): Promise<EngineResult> {
+    logger.debug(`[${this._pkg.name}] worker.build 호출`);
     const result = await this._worker!.build({
       name: this._pkg.name,
       cwd: this._cwd,
@@ -54,23 +58,19 @@ export class ServerEsbuildEngine extends BaseEngine<
     });
 
     return {
-      success: result.js.success && result.dts.success,
-      js: {
-        success: result.js.success,
-        errors: result.js.errors ?? [],
-        warnings: result.js.warnings ?? [],
-      },
-      dts: {
-        success: result.dts.success,
-        errors: result.dts.errors ?? [],
-        warnings: [],
-        diagnostics: result.dts.diagnostics,
+      success: result.build.success,
+      build: {
+        success: result.build.success,
+        errors: result.build.errors ?? [],
+        warnings: result.build.warnings ?? [],
+        diagnostics: result.build.diagnostics,
       },
       lint: result.lint,
     };
   }
 
   protected async _callStartWatch(output: BuildOutput): Promise<void> {
+    logger.debug(`[${this._pkg.name}] worker.startWatch 호출`);
     await this._worker!.startWatch({
       name: this._pkg.name,
       cwd: this._cwd,

package/src/engines/TscEngine.ts

@@ -3,6 +3,9 @@ import type { ResultCollector } from "../infra/ResultCollector";
 import type { RebuildManager } from "../utils/rebuild-manager";
 import type { BuildOutput, BuildPackageInfo, EngineResult } from "./types";
 import { BaseEngine, type CommonBuildWorkerModule } from "./BaseEngine";
+import { consola } from "consola";
+
+const logger = consola.withTag("sd:cli:engine:tsc");
 
 /**
  * TscEngine options
@@ -41,6 +44,7 @@ export class TscEngine extends BaseEngine<
   }
 
   protected async _callBuild(output: BuildOutput): Promise<EngineResult> {
+    logger.debug(`[${this._pkg.name}] worker.build 호출`);
     const result = await this._worker!.build({
       name: this._pkg.name,
       config: this._pkg.config,
@@ -50,23 +54,19 @@ export class TscEngine extends BaseEngine<
     });
 
     return {
-      success: result.js.success && result.dts.success,
-      js: {
-        success: result.js.success,
-        errors: result.js.errors ?? [],
-        warnings: result.js.warnings ?? [],
-      },
-      dts: {
-        success: result.dts.success,
-        errors: result.dts.errors ?? [],
-        warnings: [],
-        diagnostics: result.dts.diagnostics,
+      success: result.build.success,
+      build: {
+        success: result.build.success,
+        errors: result.build.errors ?? [],
+        warnings: result.build.warnings ?? [],
+        diagnostics: result.build.diagnostics,
       },
       lint: result.lint,
     };
   }
 
   protected async _callStartWatch(output: BuildOutput): Promise<void> {
+    logger.debug(`[${this._pkg.name}] worker.startWatch 호출`);
     await this._worker!.startWatch({
       name: this._pkg.name,
       config: this._pkg.config,

package/src/engines/ViteEngine.ts

@@ -69,15 +69,10 @@ export class ViteEngine implements BuildEngine {
     logger.debug(`[${this._pkg.name}] ViteEngine.run 완료 (success: ${result.success})`);
     return {
       success: result.success,
-      js: {
+      build: {
         success: result.success,
         errors: result.errors ?? [],
         warnings: result.warnings ?? [],
-      },
-      dts: {
-        success: true,
-        errors: [],
-        warnings: [],
         diagnostics: [],
       },
       lint: result.lint,
@@ -185,22 +180,16 @@ export class ViteEngine implements BuildEngine {
       message: result.errors?.join("\n"),
     };
     this._resultCollector?.add(buildResult);
-
-    const dtsResult: BuildResult = {
-      name: this._pkg.name,
-      target: "client",
-      type: "dts",
-      status: "success",
-    };
-    this._resultCollector?.add(dtsResult);
   }
 
   /**
    * 엔진을 중지하고 리소스를 정리한다
    */
   async stop(): Promise<void> {
+    logger.debug(`[${this._pkg.name}] ViteEngine stop 시작`);
     await stopEngineWorker(this._worker, this._isWatchMode);
     this._worker = undefined;
+    logger.debug(`[${this._pkg.name}] ViteEngine stop 완료`);
   }
 
   /**

package/src/engines/types.ts

@@ -37,6 +37,8 @@ export interface BuildOutput {
   lint?: boolean;
   /** Typecheck environment. When set, adjusts compilerOptions via getCompilerOptionsForEnv(). */
   env?: TypecheckEnv;
+  /** Include tests/ files in typecheck scope. Only used by check command. */
+  includeTests?: boolean;
 }
 
 /**
@@ -44,12 +46,7 @@ export interface BuildOutput {
  */
 export interface EngineResult {
   success: boolean;
-  js: {
-    success: boolean;
-    errors: string[];
-    warnings: string[];
-  };
-  dts: {
+  build: {
     success: boolean;
     errors: string[];
     warnings: string[];

package/src/infra/ResultCollector.ts

@@ -4,7 +4,7 @@
 export interface BuildResult {
   name: string;
   target: string;
-  type: "build" | "dts" | "lint" | "server";
+  type: "build" | "lint" | "server";
   status: "pending" | "building" | "success" | "error" | "running";
   message?: string;
   port?: number;