@simplysm/sd-cli 14.0.15 → 14.0.17

package/src/commands/device.ts

@@ -1,3 +1,6 @@
+import fs from "node:fs";
+import http from "node:http";
+import path from "path";
 import { consola } from "consola";
 import { pathx } from "@simplysm/core-node";
 import { SdError } from "@simplysm/core-common";
@@ -8,7 +11,7 @@ import { Electron } from "../electron/electron";
 const logger = consola.withTag("sd:cli:device");
 
 export interface DeviceOptions {
-  package: string;
+  target?: string;
   url?: string;
   options: string[];
 }
@@ -21,45 +24,96 @@ export interface DeviceOptions {
  */
 export async function runDevice(options: DeviceOptions): Promise<void> {
   const cwd = process.cwd();
-  const sdConfig = await loadSdConfig({ cwd, dev: true, options: options.options });
+  const sdConfig = await loadSdConfig({ cwd, dev: true, opt: options.options });
 
-  const pkgConfig = sdConfig.packages[options.package];
+  // target 결정: 미지정 시 유일한 client 패키지 자동 선택
+  let targetName: string;
+  if (options.target != null) {
+    targetName = options.target;
+  } else {
+    const clientNames = Object.entries(sdConfig.packages)
+      .filter(([, cfg]) => cfg != null && cfg.target === "client")
+      .map(([name]) => name);
+    if (clientNames.length === 0) {
+      throw new SdError("device 실행 가능한 client 패키지가 없습니다.");
+    }
+    if (clientNames.length > 1) {
+      throw new SdError(
+        `client 패키지가 여러 개입니다. target을 지정해주세요: ${clientNames.join(", ")}`,
+      );
+    }
+    targetName = clientNames[0];
+  }
+
+  const pkgConfig = sdConfig.packages[targetName];
   if (pkgConfig == null) {
-    throw new SdError(`패키지를 찾을 수 없습니다: ${options.package}`);
+    throw new SdError(`패키지를 찾을 수 없습니다: ${targetName}`);
   }
   if (pkgConfig.target !== "client") {
-    throw new SdError(`client 패키지만 device 실행이 가능합니다: ${options.package} (target: ${pkgConfig.target})`);
+    throw new SdError(
+      `client 패키지만 device 실행이 가능합니다: ${targetName} (target: ${pkgConfig.target})`,
+    );
   }
 
   const clientConfig = pkgConfig;
-  const pkgDir = pathx.posixResolve(cwd, "packages", options.package);
+  const pkgDir = pathx.posixResolve(cwd, "packages", targetName);
 
   // 서버 URL 결정
   let serverUrl = options.url;
   if (serverUrl == null) {
     if (typeof clientConfig.server === "number") {
-      serverUrl = `http://localhost:${clientConfig.server}`;
+      serverUrl = `http://localhost:${clientConfig.server}/${targetName}/`;
     } else {
-      throw new SdError(
-        `--url 옵션이 필요합니다. server가 패키지명으로 설정되어 있습니다: ${clientConfig.server}`,
-      );
+      // server가 패키지명(string)인 경우: .dev-port 파일에서 포트 자동 탐지
+      const portFile = path.join(pkgDir, "dist", ".dev-port");
+      let portStr: string;
+      try {
+        portStr = fs.readFileSync(portFile, "utf-8").trim();
+      } catch {
+        throw new SdError(
+          "dev 서버가 실행 중이 아닙니다. 먼저 pnpm dev를 실행해주세요.",
+        );
+      }
+      const port = Number(portStr);
+      serverUrl = `http://localhost:${port}/${targetName}/`;
+
+      // HTTP 헬스체크
+      const alive = await checkDevServer(serverUrl);
+      if (!alive) {
+        throw new SdError(
+          "dev 서버가 응답하지 않습니다. pnpm dev를 다시 실행해주세요.",
+        );
+      }
     }
   }
 
   // Electron이 Capacitor보다 우선
   if (clientConfig.electron != null) {
-    logger.start(`${options.package} (electron) 실행 중...`);
+    logger.start(`${targetName} (electron) 실행 중...`);
     const electron = await Electron.create(pkgDir, clientConfig.electron, clientConfig.exclude);
     await electron.run(serverUrl);
-    logger.success(`${options.package} (electron) 실행 완료`);
+    logger.success(`${targetName} (electron) 실행 완료`);
   } else if (clientConfig.capacitor != null) {
-    logger.start(`${options.package} (capacitor) 실행 중...`);
+    logger.start(`${targetName} (capacitor) 실행 중...`);
     const cap = await Capacitor.create(pkgDir, clientConfig.capacitor, clientConfig.exclude);
     await cap.run(serverUrl);
-    logger.success(`${options.package} (capacitor) 실행 완료`);
+    logger.success(`${targetName} (capacitor) 실행 완료`);
   } else {
-    throw new SdError(
-      `${options.package}에 capacitor 또는 electron 설정이 없습니다.`,
-    );
+    throw new SdError(`${targetName}에 capacitor 또는 electron 설정이 없습니다.`);
   }
 }
+
+/** dev 서버가 응답하는지 HTTP GET으로 확인한다. */
+function checkDevServer(url: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const req = http.get(url, (res) => {
+      res.resume();
+      resolve(true);
+    });
+    req.on("error", () => resolve(false));
+    req.setTimeout(3000, () => {
+      req.destroy();
+      resolve(false);
+    });
+  });
+}

package/src/commands/lint.ts

@@ -2,8 +2,7 @@ import { ESLint } from "eslint";
 import { createJiti } from "jiti";
 import path from "path";
 import { fsx, pathx } from "@simplysm/core-node";
-import "@simplysm/core-common";
-import { SdError } from "@simplysm/core-common";
+import { env, SdError } from "@simplysm/core-common";
 import { consola } from "consola";
 
 //#region Types
@@ -128,7 +127,7 @@ export async function executeLint(options: LintOptions): Promise<LintResult> {
 
   // TIMING 환경변수 설정
   if (timing) {
-    process.env["TIMING"] = "1";
+    env("TIMING", "1");
   }
 
   // ESLint 설정 로드

package/src/commands/publish.ts

@@ -61,7 +61,7 @@ function replaceEnvVariables(str: string, version: string, projectPath: string):
     if (envName === "PROJECT") {
       return projectPath;
     }
-    return (env[envName] as string | undefined) ?? match;
+    return env(envName) ?? match;
   });
 
   // 치환되지 않은 환경변수가 남아있으면 에러 발생
@@ -147,7 +147,7 @@ async function ensureSshAuth(
   // 개인키 파싱 시도 (암호화 또는 형식 오류 시 Error 반환)
   const parsed = utils.parseKey(privateKeyData);
   const isKeyEncrypted = parsed instanceof Error;
-  const sshAgent = process.env["SSH_AUTH_SOCK"];
+  const sshAgent = env("SSH_AUTH_SOCK");
 
   // 각 서버에 대해 키 인증 검증
   for (const [label, target] of sshTargets) {
@@ -483,7 +483,7 @@ export async function runPublish(options: PublishOptions): Promise<void> {
   // sd.config.ts 로드
   let sdConfig: SdConfig;
   try {
-    sdConfig = await loadSdConfig({ cwd, dev: false, options: options.options });
+    sdConfig = await loadSdConfig({ cwd, dev: false, opt: options.options });
     logger.debug("sd.config.ts 로드 완료");
   } catch (err) {
     logger.error(`sd.config.ts 로드 실패: ${err instanceof Error ? err.message : err}`);

package/src/commands/replace-deps.ts

@@ -16,7 +16,7 @@ export interface ReplaceDepsOptions {
 export async function runReplaceDeps(opts: ReplaceDepsOptions): Promise<void> {
   const cwd = process.cwd();
 
-  const sdConfig = await loadSdConfig({ cwd, dev: false, options: opts.options });
+  const sdConfig = await loadSdConfig({ cwd, dev: false, opt: opts.options });
 
   if (sdConfig.replaceDeps == null) {
     consola.warn("sd.config.ts에 replaceDeps 설정이 없습니다.");

package/src/commands/typecheck.ts

@@ -97,7 +97,7 @@ export async function executeTypecheck(options: TypecheckOptions): Promise<Typec
   };
 
   // sd.config.ts 로드
-  const sdConfig = await loadSdConfig({ cwd, dev: false, options: options.options });
+  const sdConfig = await loadSdConfig({ cwd, dev: false, opt: options.options });
   logger.debug("sd.config.ts 로드 완료");
 
   // 워크스페이스 패키지 탐색 및 tests/를 설정에 병합
@@ -189,7 +189,6 @@ export async function executeTypecheck(options: TypecheckOptions): Promise<Typec
           logger.debug(`[${label}] 스택 트레이스:\n${stack}`);
         }
         return {
-          success: false,
           build: {
             success: false,
             errors: [`[${label}] ${message}`],

package/src/electron/electron.ts

@@ -3,20 +3,14 @@ import fs from "fs";
 import module from "module";
 import { cpx, fsx, pathx } from "@simplysm/core-node";
 import { consola, LogLevels } from "consola";
-import type { SdElectronConfig } from "../sd-config.types.js";
+import type { NpmConfig, SdElectronConfig } from "../sd-config.types.js";
 import { createEnvBanner } from "../utils/esbuild-config.js";
 
-interface NpmConfig {
-  name: string;
-  version: string;
-  description?: string;
-  dependencies?: Record<string, string>;
-}
-
 export class Electron {
   private static readonly _logger = consola.withTag("sd:cli:electron");
 
   private readonly _electronPath: string;
+  private readonly _srcPath: string;
 
   private constructor(
     private readonly _pkgPath: string,
@@ -25,6 +19,7 @@ export class Electron {
     private readonly _exclude: string[],
   ) {
     this._electronPath = pathx.posixResolve(this._pkgPath, ".electron");
+    this._srcPath = pathx.posixResolve(this._electronPath, "src");
   }
 
   static async create(
@@ -44,10 +39,6 @@ export class Electron {
     }
   }
 
-  private _localBin(name: string): string {
-    return pathx.posixResolve(this._pkgPath, "node_modules/.bin", name);
-  }
-
   private async _exec(
     cmd: string,
     args: string[],
@@ -70,20 +61,26 @@ export class Electron {
 
   async initialize(): Promise<void> {
     Electron._logger.debug("initialize 시작");
-    const srcPath = pathx.posixResolve(this._electronPath, "src");
 
     Electron._logger.debug("package.json 설정 시작");
-    await this._setupPackageJson(srcPath);
+    await this._setupNpmConf();
     Electron._logger.debug("package.json 설정 완료");
 
-    Electron._logger.debug("npm install 시작");
-    await this._exec("npm", ["install"], srcPath);
-    Electron._logger.debug("npm install 완료");
+    // pnpm-workspace.yaml 생성 (상위 workspace 탐색 차단)
+    const workspaceYamlPath = pathx.posixResolve(this._srcPath, "pnpm-workspace.yaml");
+    if (!(await fsx.exists(workspaceYamlPath))) {
+      await fsx.write(workspaceYamlPath, "");
+    }
+
+    Electron._logger.debug("pnpm install 시작");
+    await this._exec("pnpm", ["install"], this._srcPath);
+    await this._exec("pnpm", ["approve-builds", "--all"], this._srcPath);
+    Electron._logger.debug("pnpm install 완료");
 
     const reinstallDeps = this._config.reinstallDependencies ?? [];
     if (reinstallDeps.length > 0) {
       Electron._logger.debug(`electron-rebuild 시작 (${reinstallDeps.join(", ")})`);
-      await this._exec(this._localBin("electron-rebuild"), [], srcPath);
+      await this._exec("pnpm", ["exec", "electron-rebuild"], this._srcPath);
       Electron._logger.debug("electron-rebuild 완료");
     }
     Electron._logger.debug("initialize 완료");
@@ -91,9 +88,9 @@ export class Electron {
 
   async run(url: string): Promise<void> {
     Electron._logger.debug(`run 시작 (url: ${url})`);
-    const srcPath = pathx.posixResolve(this._electronPath, "src");
 
     await this.initialize();
+    await this._copyPublicAssets();
 
     const esbuild = await import("esbuild");
     const entryPoint = pathx.posixResolve(this._pkgPath, "src/electron-main.ts");
@@ -104,7 +101,6 @@ export class Electron {
 
     const builtinModules = module.builtinModules.flatMap((m) => [m, `node:${m}`]);
     const reinstallDeps = this._config.reinstallDependencies ?? [];
-    await fsx.mkdir(srcPath);
 
     let currentElectron: cpx.SpawnProcess | null = null;
     let isRestarting = false;
@@ -112,9 +108,10 @@ export class Electron {
 
     const spawnElectron = () => {
       Electron._logger.debug("Electron 프로세스 시작");
-      currentElectron = cpx.spawn(this._localBin("electron"), ["."], {
-        cwd: srcPath,
+      currentElectron = cpx.spawn("pnpm", ["exec", "electron", "."], {
+        cwd: this._srcPath,
         stdio: "inherit",
+        shell: true,
         reject: false,
       });
 
@@ -132,7 +129,7 @@ export class Electron {
     Electron._logger.debug("esbuild context 생성 시작");
     const ctx = await esbuild.context({
       entryPoints: [entryPoint],
-      outfile: pathx.posixResolve(srcPath, "electron-main.js"),
+      outfile: pathx.posixResolve(this._srcPath, "electron-main.js"),
       platform: "node",
       target: "node20",
       format: "cjs",
@@ -205,18 +202,19 @@ export class Electron {
 
   async build(outPath: string): Promise<void> {
     Electron._logger.debug("build 시작");
-    const srcPath = pathx.posixResolve(this._electronPath, "src");
+
+    await this.initialize();
 
     Electron._logger.debug("메인 프로세스 번들링 시작");
-    await this._bundleMainProcess(srcPath);
+    await this._bundleMainProcess();
     Electron._logger.debug("메인 프로세스 번들링 완료");
 
     Electron._logger.debug("웹 에셋 복사 시작");
-    await this._copyWebAssets(outPath, srcPath);
+    await this._copyWebAssets(outPath);
     Electron._logger.debug("웹 에셋 복사 완료");
 
     Electron._logger.debug("electron-builder 실행 시작");
-    await this._runElectronBuilder(srcPath);
+    await this._runElectronBuilder();
     Electron._logger.debug("electron-builder 실행 완료");
 
     Electron._logger.debug("빌드 산출물 복사 시작");
@@ -230,14 +228,19 @@ export class Electron {
 
   //#region Private - Initialization
 
-  private async _setupPackageJson(srcPath: string): Promise<void> {
-    await fsx.mkdir(srcPath);
+  private async _setupNpmConf(): Promise<void> {
+    await fsx.mkdir(this._srcPath);
+
+    const mainDeps: Record<string, string | undefined> = {
+      ...this._npmConfig.dependencies,
+      ...this._npmConfig.devDependencies,
+    };
 
     const reinstallDeps = this._config.reinstallDependencies ?? [];
 
     const dependencies: Record<string, string> = {};
     for (const dep of reinstallDeps) {
-      const version = this._npmConfig.dependencies?.[dep];
+      const version = mainDeps[dep];
       if (version != null) {
         dependencies[dep] = version;
       }
@@ -245,33 +248,39 @@ export class Electron {
 
     for (const excludePkg of this._exclude) {
       if (!(excludePkg in dependencies)) {
-        const version = this._npmConfig.dependencies?.[excludePkg];
+        const version = mainDeps[excludePkg];
         if (version != null) {
           dependencies[excludePkg] = version;
         }
       }
     }
 
+    const devDependencies: Record<string, string> = {};
+    devDependencies["electron"] = "^41";
+    devDependencies["@electron/rebuild"] = "^4";
+    devDependencies["electron-builder"] = "^26";
+
     const packageJson: Record<string, unknown> = {
       name: this._npmConfig.name.replace(/^@/, "").replace(/\//, "-"),
       version: this._npmConfig.version,
       description: this._npmConfig.description,
       main: "electron-main.js",
       dependencies,
+      devDependencies,
     };
 
     if (this._config.postInstallScript != null) {
       packageJson["scripts"] = { postinstall: this._config.postInstallScript };
     }
 
-    await fsx.writeJson(pathx.posixResolve(srcPath, "package.json"), packageJson, { space: 2 });
+    await fsx.writeJson(pathx.posixResolve(this._srcPath, "package.json"), packageJson, { space: 2 });
   }
 
   //#endregion
 
   //#region Private - Bundling
 
-  private async _bundleMainProcess(outDir: string): Promise<void> {
+  private async _bundleMainProcess(): Promise<void> {
     const esbuild = await import("esbuild");
     const entryPoint = pathx.posixResolve(this._pkgPath, "src/electron-main.ts");
 
@@ -282,14 +291,12 @@ export class Electron {
     const builtinModules = module.builtinModules.flatMap((m) => [m, `node:${m}`]);
     const reinstallDeps = this._config.reinstallDependencies ?? [];
 
-    await fsx.mkdir(outDir);
-
     const envBanner = createEnvBanner(this._config.env);
 
     Electron._logger.debug(`esbuild 번들링: ${entryPoint}`);
     await esbuild.build({
       entryPoints: [entryPoint],
-      outfile: pathx.posixResolve(outDir, "electron-main.js"),
+      outfile: pathx.posixResolve(this._srcPath, "electron-main.js"),
       platform: "node",
       target: "node20",
       format: "cjs",
@@ -301,15 +308,27 @@ export class Electron {
 
   //#endregion
 
+  private async _copyPublicAssets(): Promise<void> {
+    const publicPath = pathx.posixResolve(this._pkgPath, "public");
+    if (!(await fsx.exists(publicPath))) return;
+
+    const items = await fsx.readdir(publicPath);
+    for (const item of items) {
+      const source = pathx.posixResolve(publicPath, item);
+      const dest = pathx.posixResolve(this._srcPath, item);
+      await fsx.copy(source, dest);
+    }
+  }
+
   //#region Private - Build
 
-  private async _copyWebAssets(outPath: string, srcPath: string): Promise<void> {
+  private async _copyWebAssets(outPath: string): Promise<void> {
     const items = await fsx.readdir(outPath);
     for (const item of items) {
       if (item === "electron") continue;
 
       const source = pathx.posixResolve(outPath, item);
-      const dest = pathx.posixResolve(srcPath, item);
+      const dest = pathx.posixResolve(this._srcPath, item);
       await fsx.copy(source, dest);
     }
   }
@@ -331,7 +350,7 @@ export class Electron {
     }
   }
 
-  private async _runElectronBuilder(srcPath: string): Promise<void> {
+  private async _runElectronBuilder(): Promise<void> {
     if (!Electron._canCreateSymlink()) {
       throw new Error(
         "Symlink 생성 권한이 필요합니다. Windows 개발자 모드를 활성화하세요.",
@@ -349,7 +368,7 @@ export class Electron {
       },
       nsis: this._config.nsisOptions ?? {},
       directories: {
-        app: srcPath,
+        app: this._srcPath,
         output: distPath,
       },
       removePackageScripts: false,
@@ -366,9 +385,9 @@ export class Electron {
 
     Electron._logger.debug(`electron-builder 설정: ${configFilePath}`);
     await this._exec(
-      this._localBin("electron-builder"),
-      ["--win", "--config", configFilePath],
-      this._pkgPath,
+      "pnpm",
+      ["exec", "electron-builder", "--win", "--config", configFilePath],
+      this._srcPath,
     );
   }
 

package/src/engines/BaseEngine.ts

@@ -112,7 +112,7 @@ export abstract class BaseEngine<
     logger.debug(`[${this._pkg.name}] run 시작 (js: ${output.js}, dts: ${output.dts}, env: ${output.env ?? "none"})`);
     this._createWorker();
     const result = await this._callBuild(output);
-    logger.debug(`[${this._pkg.name}] run 완료 (success: ${result.success})`);
+    logger.debug(`[${this._pkg.name}] run 완료 (success: ${result.build.success})`);
     return result;
   }
 

package/src/engines/NgtscEngine.ts

@@ -53,7 +53,6 @@ export class NgtscEngine extends BaseEngine<
     });
 
     return {
-      success: result.build.success,
       build: {
         success: result.build.success,
         errors: result.build.errors ?? [],

package/src/engines/ServerEsbuildEngine.ts

@@ -58,7 +58,6 @@ export class ServerEsbuildEngine extends BaseEngine<
     });
 
     return {
-      success: result.build.success,
       build: {
         success: result.build.success,
         errors: result.build.errors ?? [],

package/src/engines/TscEngine.ts

@@ -54,7 +54,6 @@ export class TscEngine extends BaseEngine<
     });
 
     return {
-      success: result.build.success,
       build: {
         success: result.build.success,
         errors: result.build.errors ?? [],

package/src/engines/ViteEngine.ts

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import path from "path";
 import { Worker, type WorkerProxy } from "@simplysm/core-node";
 import { consola } from "consola";
 import type * as ClientWorkerModule from "../workers/client.worker";
@@ -73,6 +75,7 @@ export class ViteEngine implements BuildEngine {
       configs: this._pkg.config.configs,
       browserSupport: this._pkg.config.browserSupport,
       enableLint: output.lint,
+      pwa: this._pkg.config.pwa,
       exclude: this._pkg.config.exclude,
       outDir: this._outDir,
       base: this._base,
@@ -80,7 +83,6 @@ export class ViteEngine implements BuildEngine {
 
     logger.debug(`[${this._pkg.name}] ViteEngine.run 완료 (success: ${result.success})`);
     return {
-      success: result.success,
       build: {
         success: result.success,
         errors: result.errors ?? [],
@@ -185,6 +187,7 @@ export class ViteEngine implements BuildEngine {
       replaceDeps: this._replaceDeps,
       browserSupport: this._pkg.config.browserSupport,
       enableLint: output.lint,
+      pwa: this._pkg.config.pwa,
       exclude: this._pkg.config.exclude,
     });
   }
@@ -194,6 +197,11 @@ export class ViteEngine implements BuildEngine {
    */
   async stop(): Promise<void> {
     logger.debug(`[${this._pkg.name}] ViteEngine stop 시작`);
+
+    // .dev-port 파일 삭제
+    const portFile = path.join(this._pkg.dir, "dist", ".dev-port");
+    try { fs.unlinkSync(portFile); } catch { /* 파일 없으면 무시 */ }
+
     await stopEngineWorker(this._worker, this._isWatchMode);
     this._worker = undefined;
     logger.debug(`[${this._pkg.name}] ViteEngine stop 완료`);

package/src/engines/index.ts

@@ -10,16 +10,6 @@ import type { BuildEngine, BuildPackageInfo, ClientPackageInfo, ServerPackageInf
 
 const logger = consola.withTag("sd:cli:engine");
 
-export { BaseEngine } from "./BaseEngine";
-export type { BaseEngineOptions, CommonBuildWorkerEvents, CommonBuildWorkerModule } from "./BaseEngine";
-export { NgtscEngine } from "./NgtscEngine";
-export type { NgtscEngineOptions } from "./NgtscEngine";
-export { ServerEsbuildEngine } from "./ServerEsbuildEngine";
-export type { ServerEsbuildEngineOptions } from "./ServerEsbuildEngine";
-export { TscEngine } from "./TscEngine";
-export type { TscEngineOptions } from "./TscEngine";
-export { ViteEngine } from "./ViteEngine";
-export type { ViteEngineOptions } from "./ViteEngine";
 export type { BuildEngine, BuildOutput, BuildPackageInfo, ClientPackageInfo, EngineResult, PackageInfo, ServerPackageInfo } from "./types";
 
 /**

package/src/engines/types.ts

@@ -45,7 +45,6 @@ export interface BuildOutput {
  * BuildEngine.run() 반환값
  */
 export interface EngineResult {
-  success: boolean;
   build: {
     success: boolean;
     errors: string[];

package/src/infra/SignalHandler.ts

@@ -7,7 +7,6 @@
 export class SignalHandler {
   private _terminateResolver: (() => void) | null = null;
   private readonly _terminatePromise: Promise<void>;
-  private _terminated = false;
 
   constructor() {
     this._terminatePromise = new Promise((resolve) => {
@@ -17,8 +16,8 @@ export class SignalHandler {
     const handler = () => {
       process.off("SIGINT", handler);
       process.off("SIGTERM", handler);
-      this._terminated = true;
       this._terminateResolver?.();
+      this._terminateResolver = null;
     };
 
     process.on("SIGINT", handler);
@@ -32,21 +31,12 @@ export class SignalHandler {
     return this._terminatePromise;
   }
 
-  /**
-   * 종료 여부를 확인한다
-   */
-  isTerminated(): boolean {
-    return this._terminated;
-  }
-
   /**
    * 프로그래밍 방식으로 종료를 요청한다
-   * (테스트나 외부에서 종료를 트리거할 때 사용)
+   * (테스트에서 종료를 트리거할 때 사용)
    */
   requestTermination(): void {
-    if (!this._terminated) {
-      this._terminated = true;
-      this._terminateResolver?.();
-    }
+    this._terminateResolver?.();
+    this._terminateResolver = null;
   }
 }