@simplysm/sd-cli 14.1.11 → 14.1.13

package/src/deps/replace-deps/replace-deps-resolve.ts

@@ -59,7 +59,7 @@ export interface ReplaceDepEntry {
 /**
  * 프로젝트 루트 및 워크스페이스 패키지 경로를 수집한다.
  *
- * package.json#workspaces를 기준으로 워크스페이스 패키지의 절대 경로를 수집한다.
+ * pnpm-workspace.yaml를 기준으로 워크스페이스 패키지의 절대 경로를 수집한다.
  * 설정이 없거나 파싱 실패 시 루트 경로만 반환한다.
  *
  * @param projectRoot - 프로젝트 루트 경로
@@ -82,7 +82,7 @@ export function collectSearchRoots(projectRoot: string): string[] {
 /**
  * replaceDeps 설정에서 모든 교체 대상 항목을 해결한다.
  *
- * 1. package.json#workspaces 파싱 → 워크스페이스 패키지 경로
+ * 1. pnpm-workspace.yaml 파싱 → 워크스페이스 패키지 경로
  * 2. [루트, ...워크스페이스 패키지] node_modules에서 매칭 패키지 탐색
  * 3. 패턴 매칭 + 소스 경로 존재 확인 + symlink 해결
  *

package/src/deps/replace-deps/replace-deps.ts

@@ -160,7 +160,7 @@ export interface WatchReplaceDepResult {
 /**
  * replaceDeps 설정에 따라 node_modules의 패키지를 소스 디렉토리로 교체한다.
  *
- * 1. package.json#workspaces 파싱 → 워크스페이스 패키지 경로
+ * 1. pnpm-workspace.yaml 파싱 → 워크스페이스 패키지 경로
  * 2. [루트, ...워크스페이스 패키지] node_modules에서 매칭 패키지 탐색
  * 3. 소스 package.json의 files 필드 + npm 기본 파일만 대상 경로에 복사 (package.json 제외)
  *
@@ -207,7 +207,7 @@ export async function setupReplaceDeps(
 /**
  * replaceDeps 설정에 따라 소스 디렉토리를 감시하고 변경사항을 대상 경로에 복사한다.
  *
- * 1. package.json#workspaces 파싱 → 워크스페이스 패키지 경로
+ * 1. pnpm-workspace.yaml 파싱 → 워크스페이스 패키지 경로
  * 2. [루트, ...워크스페이스 패키지] node_modules에서 매칭 패키지 탐색
  * 3. FsWatcher로 files 항목 경로만 감시 (300ms 딜레이)
  * 4. 변경사항을 대상 경로에 복사

package/src/deps/server-externals/server-production-files.ts

@@ -29,43 +29,30 @@ export function collectAllExternals(
   };
 }
 
-interface BunLockFile {
-  packages?: Record<string, unknown>;
-}
-
-function parsePackageReferenceVersion(reference: string): string | undefined {
-  const normalized = reference.split("(")[0];
-  const match = /^(.+?)@(\d[^@]*)$/.exec(normalized);
-  return match?.[2];
-}
-
-function parsePackageKeyName(key: string): string {
-  const match = /^(.+?)@(\d.+)$/.exec(key);
-  return match?.[1] ?? key;
-}
-
 /**
- * bun.lock의 packages 섹션을 파싱하여 name→version 맵을 생성한다.
- * 키 형태는 일반 패키지명 또는 alias이고, 실제 버전은 package entry의 resolution에서 확인한다.
+ * pnpm-lock.yaml의 packages 섹션을 파싱하여 name→version 맵을 생성한다.
+ * 키 형태: "name@version" · "@scope/name@version" · "name@version(peer@ver)..."
  */
 export function parseLockfileVersions(cwd: string): Map<string, string> {
-  const lockfilePath = path.join(cwd, "bun.lock");
+  const lockfilePath = path.join(cwd, "pnpm-lock.yaml");
   if (!fsx.existsSync(lockfilePath)) {
-    throw new Error(`bun.lock not found in ${cwd}. Run "bun install" first.`);
+    throw new Error(`pnpm-lock.yaml not found in ${cwd}. Run "pnpm install" first.`);
   }
 
   const content = fsx.readSync(lockfilePath);
-  const parsed = YAML.parse(content) as BunLockFile;
+  const parsed = YAML.parse(content) as { packages?: Record<string, unknown> };
   const map = new Map<string, string>();
 
-  for (const [key, entry] of Object.entries(parsed.packages ?? {})) {
-    if (!Array.isArray(entry) || typeof entry[0] !== "string") continue;
-    const version = parsePackageReferenceVersion(entry[0]);
-    if (version == null) continue;
-
-    const keyName = parsePackageKeyName(key);
-    if (!map.has(keyName)) {
-      map.set(keyName, version);
+  for (const key of Object.keys(parsed.packages ?? {})) {
+    // 첫 번째 @숫자 기준으로 name / version 분리 (scope 패키지의 선두 @ 보존)
+    const m = /^(.+?)@(\d.+)$/.exec(key);
+    if (m == null) continue;
+    const name = m[1];
+    // peerDep suffix "(peer@ver)..." 제거
+    const parenIdx = m[2].indexOf("(");
+    const version = parenIdx === -1 ? m[2] : m[2].substring(0, parenIdx);
+    if (!map.has(name)) {
+      map.set(name, version);
     }
   }
 
@@ -73,7 +60,7 @@ export function parseLockfileVersions(cwd: string): Map<string, string> {
 }
 
 /**
- * bun.lock에서 주어진 모든 패키지의 잠긴 버전을 확인한다.
+ * pnpm-lock.yaml에서 주어진 모든 패키지의 잠긴 버전을 확인한다.
  * lockfile에서 패키지를 찾을 수 없으면 에러를 던진다.
  */
 export function resolveLockedVersions(cwd: string, pkgNames: string[]): Record<string, string> {
@@ -83,8 +70,8 @@ export function resolveLockedVersions(cwd: string, pkgNames: string[]): Record<s
     const version = versionMap.get(name);
     if (version == null) {
       throw new Error(
-        `External dependency "${name}" not found in bun.lock. ` +
-          `Run "bun install" and try again.`,
+        `External dependency "${name}" not found in pnpm-lock.yaml. ` +
+          `Run "pnpm install" and try again.`,
       );
     }
     result[name] = version;

package/src/electron/electron.ts

@@ -68,14 +68,20 @@ export class Electron {
     await this._setupNpmConf();
     Electron._logger.debug("package.json 설정 완료");
 
-    Electron._logger.debug("bun install 시작");
-    await this._exec("bun", ["install"], this._srcPath);
-    Electron._logger.debug("bun 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", "--config.dangerously-allow-all-builds=true"], 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("bun", ["run", "electron-rebuild"], this._srcPath);
+      await this._exec("pnpm", ["exec", "electron-rebuild"], this._srcPath);
       Electron._logger.debug("electron-rebuild 완료");
     }
     Electron._logger.success("initialize 완료");
@@ -96,7 +102,7 @@ export class Electron {
 
     const spawnElectron = () => {
       Electron._logger.debug("Electron 프로세스 시작");
-      currentElectron = shellSpawn("bun", ["run", "electron", "."], {
+      currentElectron = shellSpawn("pnpm", ["exec", "electron", "."], {
         cwd: this._srcPath,
         stdio: "inherit",
         reject: false,
@@ -379,8 +385,8 @@ export class Electron {
 
     Electron._logger.debug(`electron-builder 설정: ${configFilePath}`);
     await this._exec(
-      "bun",
-      ["run", "electron-builder", "--win", "--config", configFilePath],
+      "pnpm",
+      ["exec", "electron-builder", "--win", "--config", configFilePath],
       this._srcPath,
     );
   }

package/src/utils/package-utils.ts

@@ -20,7 +20,7 @@ export function findPackageRoot(startDir: string): string {
 }
 
 /**
- * package.json#workspaces의 모든 워크스페이스 패키지를 탐색한다.
+ * pnpm-workspace.yaml의 모든 워크스페이스 패키지를 탐색한다.
  * 디렉토리명 → 상대 경로의 맵을 반환한다 (예: "orm" → "tests/orm", "sd" → "plugins/sd").
  * packages/·tests/·plugins/ 등 종류를 가리지 않고 포함하며, 배포/검사 대상 구분은 소비자가 relPath로 판단한다.
  */

package/src/utils/workspace-utils.ts

@@ -1,6 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { globSync } from "glob";
+import YAML from "yaml";
 import { pathx } from "@simplysm/core-node";
 
 export interface WorkspacePackageDir {
@@ -10,16 +11,12 @@ export interface WorkspacePackageDir {
   absPath: string;
 }
 
-interface WorkspaceRootPackageJson {
-  workspaces?: unknown;
-}
-
 interface WorkspacePackageJson {
   name?: unknown;
 }
 
 /**
- * root package.json의 workspaces 값을 Bun workspace 패턴 배열로 정규화한다.
+ * 워크스페이스 정의 값(배열 또는 { packages: [...] })을 패턴 배열로 정규화한다.
  */
 export function parsePackageJsonWorkspaces(workspaces: unknown): string[] {
   const rawPatterns = Array.isArray(workspaces)
@@ -35,11 +32,11 @@ export function parsePackageJsonWorkspaces(workspaces: unknown): string[] {
 }
 
 export function readWorkspacePatterns(workspaceRoot: string): string[] {
-  const packageJsonPath = path.join(workspaceRoot, "package.json");
-  if (!fs.existsSync(packageJsonPath)) return [];
+  const workspaceYamlPath = path.join(workspaceRoot, "pnpm-workspace.yaml");
+  if (!fs.existsSync(workspaceYamlPath)) return [];
 
-  const pkgJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")) as WorkspaceRootPackageJson;
-  return parsePackageJsonWorkspaces(pkgJson.workspaces);
+  const parsed = YAML.parse(fs.readFileSync(workspaceYamlPath, "utf-8")) as unknown;
+  return parsePackageJsonWorkspaces(parsed);
 }
 
 export function findWorkspaceRoot(startDir: string): string | undefined {
@@ -76,7 +73,7 @@ function splitWorkspacePatterns(patterns: string[]): { include: string[]; exclud
 }
 
 /**
- * Bun workspace root의 package.json#workspaces 기준으로 실제 패키지 디렉터리를 수집한다.
+ * 워크스페이스 root의 pnpm-workspace.yaml(packages) 기준으로 실제 패키지 디렉터리를 수집한다.
  */
 export function collectWorkspacePackages(workspaceRoot: string): WorkspacePackageDir[] {
   const root = pathx.posix(path.resolve(workspaceRoot));

package/tests/capacitor/capacitor-npm-config.acc.spec.ts

@@ -1,114 +1,114 @@
-import { describe, it, expect, vi, beforeAll, afterAll, beforeEach } from "vitest";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { fsx, cpx } from "@simplysm/core-node";
-
-const mockFsxExists = vi.spyOn(fsx, "exists");
-vi.spyOn(fsx, "read");
-vi.spyOn(fsx, "write").mockResolvedValue(undefined);
-const mockFsxReadJson = vi.spyOn(fsx, "readJson");
-vi.spyOn(fsx, "writeJson").mockResolvedValue(undefined);
-vi.spyOn(fsx, "mkdir").mockResolvedValue(undefined);
-
-const execaCalls: { command: string; args: string[]; options: unknown }[] = [];
-vi.spyOn(cpx, "spawn").mockImplementation(((cmd: string, args: string[], options: unknown) => {
-  execaCalls.push({
-    command: cmd,
-    args,
-    options,
-  });
-  return { stdout: "", stderr: "", exitCode: 0 };
-}) as never);
-
-//#endregion
-
-let tmpRoot: string;
-let CAP_PATH: string;
-let PKG_PATH: string;
-
-beforeAll(() => {
-  tmpRoot = mkdtempSync(path.join(tmpdir(), "cap-npm-config-acc-"));
-  writeFileSync(path.join(tmpRoot, "package.json"), JSON.stringify({ private: true, workspaces: ["pkg"] }));
-  PKG_PATH = path.join(tmpRoot, "pkg");
-  CAP_PATH = path.join(PKG_PATH, ".capacitor");
-});
-
-afterAll(() => {
-  rmSync(tmpRoot, { recursive: true, force: true });
-});
-
-function setupDefaultMocks() {
-  mockFsxExists.mockImplementation(((p: string) => {
-    const n = p.replace(/\\/g, "/");
-    if (n.includes(".capacitor.lock")) return false;
-    return true;
-  }) as never);
-
-  mockFsxReadJson.mockImplementation(((p: string) => {
-    const normalized = p.replace(/\\/g, "/");
-    if (normalized.includes(".capacitor/package.json")) {
-      return {
-        name: "com.test.app",
-        version: "1.0.0",
-        dependencies: {
-          "@capacitor/core": "^7",
-          "@capacitor/app": "^7",
-          "@capacitor/android": "^7",
-        },
-        devDependencies: {
-          "@capacitor/cli": "^7",
-          "@capacitor/assets": "^3",
-        },
-      };
-    }
-    return { name: "test-pkg", version: "1.0.0" };
-  }) as never);
-
-  execaCalls.length = 0;
-}
-
-describe("initCapNpmProject", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    setupDefaultMocks();
-  });
-
-  it("의존성 미변경 + node_modules 존재 시 false를 반환하고 bun install을 실행하지 않는다", async () => {
-    const { initCapNpmProject } = await import(
-      "../../src/capacitor/capacitor-npm-config.js"
-    );
-
-    const changed = await initCapNpmProject(CAP_PATH, PKG_PATH, {
-      appId: "com.test.app",
-      appName: "Test App",
-      platform: { android: {} },
-    }, { name: "test-pkg", version: "1.0.0" }, ["android"], []);
-
-    expect(changed).toBe(false);
-  });
-
-  it("node_modules가 없으면 true를 반환하고 bun install을 실행한다", async () => {
-    mockFsxExists.mockImplementation(((p: string) => {
-      const n = p.replace(/\\/g, "/");
-      if (n.includes(".capacitor.lock")) return false;
-      if (n.includes("node_modules")) return false;
-      return true;
-    }) as never);
-
-    const { initCapNpmProject } = await import(
-      "../../src/capacitor/capacitor-npm-config.js"
-    );
-
-    const changed = await initCapNpmProject(CAP_PATH, PKG_PATH, {
-      appId: "com.test.app",
-      appName: "Test App",
-      platform: { android: {} },
-    }, {
-      name: "test-pkg",
-      version: "1.0.0",
-    }, ["android"], []);
-
-    expect(changed).toBe(true);
-  });
-});
+import { describe, it, expect, vi, beforeAll, afterAll, beforeEach } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fsx, cpx } from "@simplysm/core-node";
+
+const mockFsxExists = vi.spyOn(fsx, "exists");
+vi.spyOn(fsx, "read");
+vi.spyOn(fsx, "write").mockResolvedValue(undefined);
+const mockFsxReadJson = vi.spyOn(fsx, "readJson");
+vi.spyOn(fsx, "writeJson").mockResolvedValue(undefined);
+vi.spyOn(fsx, "mkdir").mockResolvedValue(undefined);
+
+const execaCalls: { command: string; args: string[]; options: unknown }[] = [];
+vi.spyOn(cpx, "spawn").mockImplementation(((cmd: string, args: string[], options: unknown) => {
+  execaCalls.push({
+    command: cmd,
+    args,
+    options,
+  });
+  return { stdout: "", stderr: "", exitCode: 0 };
+}) as never);
+
+//#endregion
+
+let tmpRoot: string;
+let CAP_PATH: string;
+let PKG_PATH: string;
+
+beforeAll(() => {
+  tmpRoot = mkdtempSync(path.join(tmpdir(), "cap-npm-config-acc-"));
+  writeFileSync(path.join(tmpRoot, "pnpm-workspace.yaml"), "packages:\n  - pkg\n");
+  PKG_PATH = path.join(tmpRoot, "pkg");
+  CAP_PATH = path.join(PKG_PATH, ".capacitor");
+});
+
+afterAll(() => {
+  rmSync(tmpRoot, { recursive: true, force: true });
+});
+
+function setupDefaultMocks() {
+  mockFsxExists.mockImplementation(((p: string) => {
+    const n = p.replace(/\\/g, "/");
+    if (n.includes(".capacitor.lock")) return false;
+    return true;
+  }) as never);
+
+  mockFsxReadJson.mockImplementation(((p: string) => {
+    const normalized = p.replace(/\\/g, "/");
+    if (normalized.includes(".capacitor/package.json")) {
+      return {
+        name: "com.test.app",
+        version: "1.0.0",
+        dependencies: {
+          "@capacitor/core": "^7",
+          "@capacitor/app": "^7",
+          "@capacitor/android": "^7",
+        },
+        devDependencies: {
+          "@capacitor/cli": "^7",
+          "@capacitor/assets": "^3",
+        },
+      };
+    }
+    return { name: "test-pkg", version: "1.0.0" };
+  }) as never);
+
+  execaCalls.length = 0;
+}
+
+describe("initCapNpmProject", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setupDefaultMocks();
+  });
+
+  it("의존성 미변경 + node_modules 존재 시 false를 반환하고 pnpm install을 실행하지 않는다", async () => {
+    const { initCapNpmProject } = await import(
+      "../../src/capacitor/capacitor-npm-config.js"
+    );
+
+    const changed = await initCapNpmProject(CAP_PATH, PKG_PATH, {
+      appId: "com.test.app",
+      appName: "Test App",
+      platform: { android: {} },
+    }, { name: "test-pkg", version: "1.0.0" }, ["android"], []);
+
+    expect(changed).toBe(false);
+  });
+
+  it("node_modules가 없으면 true를 반환하고 pnpm install을 실행한다", async () => {
+    mockFsxExists.mockImplementation(((p: string) => {
+      const n = p.replace(/\\/g, "/");
+      if (n.includes(".capacitor.lock")) return false;
+      if (n.includes("node_modules")) return false;
+      return true;
+    }) as never);
+
+    const { initCapNpmProject } = await import(
+      "../../src/capacitor/capacitor-npm-config.js"
+    );
+
+    const changed = await initCapNpmProject(CAP_PATH, PKG_PATH, {
+      appId: "com.test.app",
+      appName: "Test App",
+      platform: { android: {} },
+    }, {
+      name: "test-pkg",
+      version: "1.0.0",
+    }, ["android"], []);
+
+    expect(changed).toBe(true);
+  });
+});

package/tests/commands/publish-manifest.acc.spec.ts

@@ -39,14 +39,14 @@ afterEach(() => {
 });
 
 describe("npm package manifest", () => {
-  it("keeps CLI binary and replaces workspace dependency ranges in Bun pack output", async () => {
+  it("keeps CLI binary and replaces workspace dependency ranges in pnpm pack output", async () => {
     const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
     const destination = fs.mkdtempSync(path.join(os.tmpdir(), "sd-cli-pack-"));
     tmpDirs.push(destination);
 
     await cpx.spawn(
-      "bun",
-      ["pm", "pack", "--destination", destination, "--ignore-scripts", "--quiet"],
+      "pnpm",
+      ["pack", "--pack-destination", destination],
       { cwd: pkgRoot },
     );
 

package/tests/deps/server-externals/server-production-files.spec.ts

@@ -10,9 +10,9 @@ import {
 const tmpDirs: string[] = [];
 
 function createLock(content: string): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sd-bun-lock-"));
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sd-pnpm-lock-"));
   tmpDirs.push(dir);
-  fs.writeFileSync(path.join(dir, "bun.lock"), content);
+  fs.writeFileSync(path.join(dir, "pnpm-lock.yaml"), content);
   return dir;
 }
 
@@ -23,46 +23,44 @@ afterEach(() => {
 });
 
 describe("parseLockfileVersions", () => {
-  it("reads unscoped, scoped, alias, and optional entries from bun.lock", () => {
-    const cwd = createLock(`{
-  "lockfileVersion": 1,
-  "packages": {
-    "is-number": ["is-number@7.0.0", "", {}, "sha512-a"],
-    "@types/node": ["@types/node@24.13.2", "", {}, "sha512-b"],
-    "alias-pkg": ["is-number@6.0.0", "", {}, "sha512-c"],
-    "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-d"],
-  }
-}`);
+  it("reads unscoped and scoped entries from pnpm-lock.yaml", () => {
+    const cwd = createLock(`lockfileVersion: '9.0'
+packages:
+  is-number@7.0.0:
+    resolution: {integrity: sha512-a}
+  '@types/node@24.13.2':
+    resolution: {integrity: sha512-b}
+  fsevents@2.3.3:
+    resolution: {integrity: sha512-d}
+    os: [darwin]
+`);
 
     const map = parseLockfileVersions(cwd);
 
     expect(map.get("is-number")).toBe("7.0.0");
     expect(map.get("@types/node")).toBe("24.13.2");
-    expect(map.get("alias-pkg")).toBe("6.0.0");
     expect(map.get("fsevents")).toBe("2.3.3");
   });
 
-  it("strips peer suffix from package references", () => {
-    const cwd = createLock(`{
-  "lockfileVersion": 1,
-  "packages": {
-    "react-dom": ["react-dom@19.2.7(react@19.2.7)", "", {}, "sha512-a"],
-  }
-}`);
+  it("strips peer suffix from package keys", () => {
+    const cwd = createLock(`lockfileVersion: '9.0'
+packages:
+  'react-dom@19.2.7(react@19.2.7)':
+    resolution: {integrity: sha512-a}
+`);
 
     expect(parseLockfileVersions(cwd).get("react-dom")).toBe("19.2.7");
   });
 });
 
 describe("resolveLockedVersions", () => {
-  it("throws when an external dependency is missing from bun.lock", () => {
-    const cwd = createLock(`{
-  "lockfileVersion": 1,
-  "packages": {
-    "is-number": ["is-number@7.0.0", "", {}, "sha512-a"],
-  }
-}`);
+  it("throws when an external dependency is missing from pnpm-lock.yaml", () => {
+    const cwd = createLock(`lockfileVersion: '9.0'
+packages:
+  is-number@7.0.0:
+    resolution: {integrity: sha512-a}
+`);
 
-    expect(() => resolveLockedVersions(cwd, ["missing"])).toThrow("bun.lock");
+    expect(() => resolveLockedVersions(cwd, ["missing"])).toThrow("pnpm-lock.yaml");
   });
 });

package/tests/electron/electron.spec.ts

@@ -145,7 +145,7 @@ describe("Electron", () => {
   //#region Rule: Electron 프로젝트를 초기화한다
 
   describe("인수 테스트: 초기화", () => {
-    it("package.json 생성 + bun install + electron-rebuild를 실행한다", async () => {
+    it("package.json 생성 + pnpm install + electron-rebuild를 실행한다", async () => {
       const { Electron } = await import("../../src/electron/electron.js");
 
       const electron = await Electron.create(PKG_PATH, {
@@ -159,13 +159,13 @@ describe("Electron", () => {
 
       const spawnCalls = mockCpxSpawn.mock.calls;
       const installCall = spawnCalls.find(
-        (c) => c[0] === "bun" && c[1].includes("install"),
+        (c) => c[0] === "pnpm" && c[1].includes("install"),
       );
       expect(installCall).toBeDefined();
       expect(installCall?.[2]).toEqual(expect.objectContaining({ shell: true }));
       expect(
         spawnCalls.find(
-          (c) => c[0] === "bun" && c[1].includes("electron-rebuild"),
+          (c) => c[0] === "pnpm" && c[1].includes("electron-rebuild"),
         ),
       ).toBeDefined();
     });
@@ -177,7 +177,7 @@ describe("Electron", () => {
       await electron.initialize();
 
       const rebuildCall = mockCpxSpawn.mock.calls.find(
-        (c) => c[0] === "bun" && c[1].includes("electron-rebuild"),
+        (c) => c[0] === "pnpm" && c[1].includes("electron-rebuild"),
       );
       expect(rebuildCall).toBeUndefined();
     });
@@ -455,8 +455,8 @@ describe("Electron", () => {
       let resolveElectron: () => void = () => {};
 
       mockCpxSpawn.mockImplementation((cmd: string, args: string[]) => {
-        // bun run electron . → Electron 프로세스
-        if (cmd === "bun" && args[0] === "run" && args[1] === "electron" && args[2] === ".") {
+        // pnpm exec electron . → Electron 프로세스
+        if (cmd === "pnpm" && args[0] === "exec" && args[1] === "electron" && args[2] === ".") {
           const p = new Promise<void>((resolve) => {
             resolveElectron = resolve;
           }) as any;
@@ -499,7 +499,7 @@ describe("Electron", () => {
       expect(callArgs.bundle).toBe(true);
       expect(callArgs.external).toContain("electron");
       const electronCall = mockCpxSpawn.mock.calls.find(
-        (c) => c[0] === "bun" && c[1].includes("electron"),
+        (c) => c[0] === "pnpm" && c[1].includes("electron"),
       );
       expect(electronCall?.[2]).toEqual(expect.objectContaining({ shell: true, reject: false }));
 
@@ -545,7 +545,7 @@ describe("Electron", () => {
     it("passes custom env and ELECTRON_DEV_URL via esbuild banner", async () => {
       let resolveElectron: () => void = () => {};
       mockCpxSpawn.mockImplementation((cmd: string, args: string[]) => {
-        if (cmd === "bun" && args[0] === "run" && args[1] === "electron" && args[2] === ".") {
+        if (cmd === "pnpm" && args[0] === "exec" && args[1] === "electron" && args[2] === ".") {
           const p = new Promise<void>((resolve) => {
             resolveElectron = resolve;
           }) as any;
@@ -578,7 +578,7 @@ describe("Electron", () => {
     it("calls initialize() before starting esbuild context", async () => {
       let resolveElectron: () => void = () => {};
       mockCpxSpawn.mockImplementation((cmd: string, args: string[]) => {
-        if (cmd === "bun" && args[0] === "run" && args[1] === "electron" && args[2] === ".") {
+        if (cmd === "pnpm" && args[0] === "exec" && args[1] === "electron" && args[2] === ".") {
           const p = new Promise<void>((resolve) => {
             resolveElectron = resolve;
           }) as any;
@@ -596,11 +596,11 @@ describe("Electron", () => {
       resolveElectron();
       await runPromise;
 
-      // initialize calls bun install
-      const bunInstallCall = mockCpxSpawn.mock.calls.find(
-        (c: any[]) => c[0] === "bun" && (c[1] as string[]).includes("install"),
+      // initialize calls pnpm install
+      const pnpmInstallCall = mockCpxSpawn.mock.calls.find(
+        (c: any[]) => c[0] === "pnpm" && (c[1] as string[]).includes("install"),
       );
-      expect(bunInstallCall).toBeDefined();
+      expect(pnpmInstallCall).toBeDefined();
     }, 10_000);
   });