@simplysm/sd-cli 14.1.9 → 14.1.10

package/src/utils/workspace-utils.ts

@@ -0,0 +1,117 @@
+import fs from "fs";
+import path from "path";
+import { globSync } from "glob";
+import { pathx } from "@simplysm/core-node";
+
+export interface WorkspacePackageDir {
+  dirName: string;
+  packageName: string;
+  relPath: string;
+  absPath: string;
+}
+
+interface WorkspaceRootPackageJson {
+  workspaces?: unknown;
+}
+
+interface WorkspacePackageJson {
+  name?: unknown;
+}
+
+/**
+ * root package.json의 workspaces 값을 Bun workspace 패턴 배열로 정규화한다.
+ */
+export function parsePackageJsonWorkspaces(workspaces: unknown): string[] {
+  const rawPatterns = Array.isArray(workspaces)
+    ? workspaces
+    : typeof workspaces === "object" && workspaces != null && Array.isArray((workspaces as { packages?: unknown }).packages)
+      ? (workspaces as { packages: unknown[] }).packages
+      : [];
+
+  return rawPatterns
+    .filter((item): item is string => typeof item === "string")
+    .map((item) => item.trim())
+    .filter((item) => item !== "");
+}
+
+export function readWorkspacePatterns(workspaceRoot: string): string[] {
+  const packageJsonPath = path.join(workspaceRoot, "package.json");
+  if (!fs.existsSync(packageJsonPath)) return [];
+
+  const pkgJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")) as WorkspaceRootPackageJson;
+  return parsePackageJsonWorkspaces(pkgJson.workspaces);
+}
+
+export function findWorkspaceRoot(startDir: string): string | undefined {
+  let current = path.resolve(startDir);
+  if (fs.existsSync(current) && fs.statSync(current).isFile()) {
+    current = path.dirname(current);
+  }
+
+  while (true) {
+    if (readWorkspacePatterns(current).length > 0) {
+      return pathx.posix(current);
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) return undefined;
+    current = parent;
+  }
+}
+
+function splitWorkspacePatterns(patterns: string[]): { include: string[]; exclude: string[] } {
+  const include: string[] = [];
+  const exclude: string[] = [];
+
+  for (const pattern of patterns) {
+    if (pattern.startsWith("!")) {
+      const excluded = pattern.slice(1).trim();
+      if (excluded !== "") exclude.push(excluded);
+    } else {
+      include.push(pattern);
+    }
+  }
+
+  return { include, exclude };
+}
+
+/**
+ * Bun workspace root의 package.json#workspaces 기준으로 실제 패키지 디렉터리를 수집한다.
+ */
+export function collectWorkspacePackages(workspaceRoot: string): WorkspacePackageDir[] {
+  const root = pathx.posix(path.resolve(workspaceRoot));
+  const patterns = readWorkspacePatterns(root);
+  const { include, exclude } = splitWorkspacePatterns(patterns);
+  const absDirs = new Set<string>();
+
+  for (const pattern of include) {
+    const matches = globSync(pattern, {
+      cwd: root,
+      absolute: true,
+      nodir: false,
+      ignore: exclude,
+    });
+
+    for (const match of matches) {
+      const absPath = pathx.posix(path.resolve(match));
+      const packageJsonPath = path.join(absPath, "package.json");
+      if (!fs.existsSync(packageJsonPath)) continue;
+      if (!fs.statSync(absPath).isDirectory()) continue;
+      absDirs.add(absPath);
+    }
+  }
+
+  return [...absDirs]
+    .sort((a, b) => a.localeCompare(b))
+    .map((absPath): WorkspacePackageDir => {
+      const relPath = pathx.posix(path.relative(root, absPath));
+      const pkgJson = JSON.parse(fs.readFileSync(path.join(absPath, "package.json"), "utf-8")) as WorkspacePackageJson;
+      const packageName = typeof pkgJson.name === "string" ? pkgJson.name : path.basename(absPath);
+      return {
+        dirName: path.basename(absPath),
+        packageName,
+        relPath,
+        absPath,
+      };
+    });
+}

package/src/workers/client.worker.ts

@@ -57,7 +57,7 @@ export interface ClientWorkerEvents extends Record<string, unknown> {
   buildStart: Record<string, never>;
   build: ClientBuildResult;
   serverReady: { port: number };
-  error: { message: string };
+  error: { message: string; stack?: string };
 }
 
 //#endregion
@@ -207,6 +207,7 @@ async function build(info: ClientBuildInfo): Promise<ClientBuildResult> {
       errors.push(errNs.message(err));
     }
     logger.debug(`[${info.name}] client worker build 예외: ${errors.join("\n")}`);
+    logger.debug(`[${info.name}] client worker build 예외 스택:\n${errNs.stack(err)}`);
     return { success: false, errors };
   }
 }
@@ -313,8 +314,10 @@ function createDevBuildEndHandler(
       }
     } catch (err) {
       const message = errNs.message(err);
+      const stack = errNs.stack(err);
+      logger.debug(`client dev build end 예외 스택:\n${stack}`);
       if (!isInitialBuild) {
-        sender.send("error", { message });
+        sender.send("error", { message, stack });
       } else {
         isInitialBuild = false;
         initialBuildResolve?.({
@@ -423,7 +426,7 @@ async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
         hmrService?.broadcast({ type: "full-reload" });
         sender.send("build", { success: true });
       } catch (err) {
-        sender.send("error", { message: errNs.message(err) });
+        sender.send("error", { message: errNs.message(err), stack: errNs.stack(err) });
       }
     });
 
@@ -437,7 +440,9 @@ async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
     return initialResult;
   } catch (err) {
     const message = errNs.message(err);
-    sender.send("error", { message });
+    const stack = errNs.stack(err);
+    logger.debug(`[${info.name}] client worker startWatch 예외 스택:\n${stack}`);
+    sender.send("error", { message, stack });
     return { success: false, errors: [message] };
   }
 }

package/src/workers/library-build.worker.ts

@@ -36,7 +36,7 @@ export interface CombinedBuildEvent {
 export interface LibraryBuildWorkerEvents extends Record<string, unknown> {
   buildStart: Record<string, never>;
   build: CombinedBuildEvent;
-  error: { message: string };
+  error: { message: string; stack?: string };
 }
 
 //#endregion
@@ -135,6 +135,7 @@ async function build(info: LibraryBuildInfo): Promise<LibraryBuildResult> {
   } catch (err) {
     const message = errNs.message(err);
     logger.debug(`[${info.name}] library worker build 예외 발생: ${message}`);
+    logger.debug(`[${info.name}] library worker build 예외 스택:\n${errNs.stack(err)}`);
     return {
       build: { success: false, errors: [message], diagnostics: [] },
     };
@@ -323,11 +324,11 @@ async function startWatch(info: LibraryBuildInfo): Promise<void> {
         const event = buildWatchEvent(info, result, changedScssFiles);
         sender.send("build", event);
       } catch (err) {
-        sender.send("error", { message: errNs.message(err) });
+        sender.send("error", { message: errNs.message(err), stack: errNs.stack(err) });
       }
     });
   } catch (err) {
-    sender.send("error", { message: errNs.message(err) });
+    sender.send("error", { message: errNs.message(err), stack: errNs.stack(err) });
   }
 }
 

package/src/workers/server-build.worker.ts

@@ -92,7 +92,7 @@ export interface ServerCombinedBuildEvent {
 export interface ServerBuildWorkerEvents extends Record<string, unknown> {
   buildStart: Record<string, never>;
   build: ServerCombinedBuildEvent;
-  error: { message: string };
+  error: { message: string; stack?: string };
 }
 
 //#endregion
@@ -169,7 +169,7 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
       jsResult = await esbuild.build({ ...esbuildOptions, plugins: [createWorkerBundlePlugin(), tscPlugin.plugin] })
         .then(async (result) => {
           if (result.outputFiles) {
-            await writeChangedOutputFiles(result.outputFiles);
+            await writeChangedOutputFiles(result.outputFiles, { rewriteJsExtensions: false });
           }
           const errors = formatEsbuildMessages(result.errors, "error");
           const warnings = formatEsbuildMessages(result.warnings, "warning");
@@ -179,11 +179,14 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
             warnings: warnings.length > 0 ? warnings : undefined,
           };
         })
-        .catch((err) => ({
-          success: false,
-          errors: [errNs.message(err)],
-          warnings: undefined,
-        }));
+        .catch((err) => {
+          logger.debug(`[${info.name}] server esbuild build 예외 스택:\n${errNs.stack(err)}`);
+          return {
+            success: false,
+            errors: [errNs.message(err)],
+            warnings: undefined,
+          };
+        });
 
       tscErrors = tscPlugin.getErrors() ?? [];
       tscDiagnostics = tscPlugin.getDiagnostics();
@@ -231,11 +234,8 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
     };
   } catch (err) {
     const message = errNs.message(err);
-    const stack = err instanceof Error ? err.stack : undefined;
     logger.debug(`[${info.name}] server worker build 예외: ${message}`);
-    if (stack != null) {
-      logger.debug(`[${info.name}] 스택 트레이스:\n${stack}`);
-    }
+    logger.debug(`[${info.name}] 스택 트레이스:\n${errNs.stack(err)}`);
     return {
       build: { success: false, errors: [message], diagnostics: [] },
       mainJsPath,
@@ -358,11 +358,11 @@ async function startWatch(info: ServerWatchInfo): Promise<void> {
       initialExternals: cachedExternal,
       onBuildStart: () => sender.send("buildStart", {}),
       onBuild: (result) => sender.send("build", result),
-      onError: (message) => sender.send("error", { message }),
+      onError: (message, stack) => sender.send("error", { message, stack }),
       rebuild: () => rebuildAll(),
     });
   } catch (err) {
-    sender.send("error", { message: errNs.message(err) });
+    sender.send("error", { message: errNs.message(err), stack: errNs.stack(err) });
   }
 }
 

package/src/workers/server-esbuild-context.ts

@@ -1,6 +1,6 @@
 import type ts from "typescript";
 import esbuild from "esbuild";
-import { err as errNs } from "@simplysm/core-common";
+import { createLogger, err as errNs } from "@simplysm/core-common";
 import { formatEsbuildMessages } from "../utils/output-utils";
 import {
   createServerEsbuildOptions,
@@ -12,6 +12,8 @@ import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization"
 import type { LintWithProgramResult } from "../lint/lint-with-program";
 import { createWorkerBundlePlugin } from "../esbuild/esbuild-worker-plugin";
 
+const logger = createLogger("sd:cli:server-esbuild-context");
+
 /**
  * esbuild watch context 생성 옵션
  */
@@ -87,6 +89,7 @@ export async function rebuild(): Promise<{
   try {
     result = await context.rebuild();
   } catch (err) {
+    logger.debug(`server esbuild rebuild 예외 스택:\n${errNs.stack(err)}`);
     const tscErrors = tscPlugin?.getErrors() ?? [];
     const allErrors = [errNs.message(err), ...tscErrors];
     return {
@@ -101,7 +104,7 @@ export async function rebuild(): Promise<{
   }
 
   if (result.outputFiles) {
-    await writeChangedOutputFiles(result.outputFiles);
+    await writeChangedOutputFiles(result.outputFiles, { rewriteJsExtensions: false });
   }
 
   const esbuildErrors = formatEsbuildMessages(result.errors, "error");

package/src/workers/server-runtime.worker.ts

@@ -32,6 +32,7 @@ export interface ServerRuntimeReadyEvent {
  */
 export interface ServerRuntimeErrorEvent {
   message: string;
+  stack?: string;
 }
 
 /**
@@ -73,18 +74,22 @@ async function cleanup(): Promise<void> {
 // 서버 listen() 이후 발생하는 런타임 에러를 잡아 커스텀 "error" 이벤트로 전송
 // (이 핸들러 없이는 워커가 크래시해도 빌드 Promise가 resolve되지 않아 프로세스가 중단될 수 있다)
 process.on("uncaughtException", (err) => {
-  logger.error("서버 런타임 미처리 에러", err);
+  logger.error("서버 런타임 미처리 에러", errNs.message(err));
+  logger.debug(`서버 런타임 미처리 에러 스택:\n${errNs.stack(err)}`);
   sender.send("error", {
     message: errNs.message(err),
+    stack: errNs.stack(err),
   });
   // 이벤트 전송 후 종료할 수 있도록 대기
   setTimeout(() => process.exit(1), 500);
 });
 
 process.on("unhandledRejection", (reason) => {
-  logger.error("서버 런타임 미처리 Promise 거부", reason);
+  logger.error("서버 런타임 미처리 Promise 거부", errNs.message(reason));
+  logger.debug(`서버 런타임 미처리 Promise 거부 스택:\n${errNs.stack(reason)}`);
   sender.send("error", {
     message: errNs.message(reason),
+    stack: errNs.stack(reason),
   });
   // 이벤트 전송 후 종료할 수 있도록 대기
   setTimeout(() => process.exit(1), 500);
@@ -195,9 +200,11 @@ async function start(info: ServerRuntimeStartInfo): Promise<void> {
 
     sender.send("serverReady", { port: server.options.port });
   } catch (err) {
-    logger.error("서버 런타임 시작 실패", err);
+    logger.error("서버 런타임 시작 실패", errNs.message(err));
+    logger.debug(`서버 런타임 시작 실패 스택:\n${errNs.stack(err)}`);
     sender.send("error", {
       message: errNs.message(err),
+      stack: errNs.stack(err),
     });
   }
 }

package/src/workers/server-watch-manager.ts

@@ -25,7 +25,7 @@ export interface ServerWatchLoopConfig {
   /** 빌드 완료 이벤트 콜백 */
   onBuild: (result: { build: { success: boolean; errors?: string[]; warnings?: string[] }; mainJsPath: string }) => void;
   /** 에러 이벤트 콜백 */
-  onError: (message: string) => void;
+  onError: (message: string, stack?: string) => void;
   /** 리빌드 실행 콜백 */
   rebuild: () => Promise<{ build: { success: boolean; errors?: string[]; warnings?: string[] }; mainJsPath: string }>;
 }
@@ -99,7 +99,7 @@ export async function startServerWatchLoop(config: ServerWatchLoopConfig): Promi
 
       const hasRelevantChange = changes.some((c) => {
         if (metafileAbsPaths.has(c.path)) return true;
-        // pnpm symlink 경로와 esbuild resolved 경로 불일치 대응
+        // package manager symlink 경로와 esbuild resolved 경로 불일치 대응
         try {
           const realPath = pathx.posix(fs.realpathSync(c.path));
           return metafileAbsPaths.has(realPath);
@@ -116,7 +116,7 @@ export async function startServerWatchLoop(config: ServerWatchLoopConfig): Promi
         logger.debug("변경된 파일이 빌드에 포함되지 않아 리빌드 건너뜀");
       }
     } catch (err) {
-      config.onError(errNs.message(err));
+      config.onError(errNs.message(err), errNs.stack(err));
     }
   });
 

package/tests/capacitor/capacitor-build.spec.ts

@@ -1,142 +1,142 @@
-/* eslint-disable no-restricted-properties -- 테스트 환경변수 조작 필요 */
-import { describe, it, expect, vi, beforeAll, afterAll, beforeEach, afterEach } from "vitest";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { fsx, cpx } from "@simplysm/core-node";
-
-// sharp는 외부 npm 네이티브 라이브러리로 이미지 처리 시간이 크고 결정적 검증에 mock 필요
-vi.mock("sharp", () => ({
-  default: vi.fn().mockReturnValue({
-    resize: vi.fn().mockReturnThis(),
-    composite: vi.fn().mockReturnThis(),
-    png: vi.fn().mockReturnThis(),
-    toBuffer: vi.fn().mockResolvedValue(new Uint8Array([0])),
-    toFile: vi.fn().mockResolvedValue(undefined),
-  }),
-}));
-
-const mockFsxExists = vi.spyOn(fsx, "exists");
-const mockFsxRead = 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);
-vi.spyOn(fsx, "rm").mockResolvedValue(undefined);
-const mockFsxGlob = vi.spyOn(fsx, "glob").mockResolvedValue([]);
-vi.spyOn(fsx, "copy").mockResolvedValue(undefined);
-
-vi.spyOn(cpx, "spawn").mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
-vi.spyOn(cpx, "spawnSync").mockReturnValue({ stdout: "", stderr: "", exitCode: 0 });
-
-let tmpRoot: string;
-let PKG_PATH: string;
-
-beforeAll(() => {
-  tmpRoot = mkdtempSync(path.join(tmpdir(), "cap-build-"));
-  writeFileSync(path.join(tmpRoot, "pnpm-workspace.yaml"), "");
-  PKG_PATH = path.join(tmpRoot, "pkg");
-  mkdirSync(path.join(PKG_PATH, ".capacitor"), { recursive: true });
-});
-
-afterAll(() => {
-  rmSync(tmpRoot, { recursive: true, force: true });
-});
-
-function setupDefaultMocks() {
-  mockFsxExists.mockResolvedValue(true);
-
-  mockFsxReadJson.mockImplementation(((p: string) => {
-    const normalized = p.replace(/\\/g, "/");
-    if (normalized.includes(".capacitor/package.json")) {
-      return {
-        name: "com.test.app",
-        version: "1.2.3",
-        dependencies: {
-          "@capacitor/core": "^7.0.0",
-          "@capacitor/app": "^7.0.0",
-          "@capacitor/android": "^7.0.0",
-        },
-        devDependencies: {
-          "@capacitor/cli": "^7.0.0",
-          "@capacitor/assets": "^3.0.0",
-        },
-      };
-    }
-    return { name: "test-pkg", version: "1.2.3" };
-  }) as never);
-
-  mockFsxRead.mockImplementation(((p: string) => {
-    if (p.includes("AndroidManifest.xml")) {
-      return '<manifest xmlns:android="http://schemas.android.com/apk/res/android">\n<application>\n</application>\n</manifest>';
-    }
-    if (p.includes("build.gradle")) {
-      return `android {
-    defaultConfig {
-        versionCode 1
-        versionName "1.0"
-        minSdkVersion rootProject.ext.minSdkVersion
-        targetSdkVersion rootProject.ext.targetSdkVersion
-    }
-    buildTypes { release { } }
-}`;
-    }
-    if (p.includes("gradle.properties")) {
-      return "org.gradle.jvmargs=-Xmx2048m";
-    }
-    return "";
-  }) as never);
-
-  mockFsxGlob.mockImplementation(((pattern: string) => {
-    if (pattern.includes("Corretto") || pattern.includes("jdk")) {
-      return ["C:/Program Files/Amazon Corretto/jdk21.0.1"];
-    }
-    return [];
-  }) as never);
-
-  process.env["ANDROID_HOME"] = "C:/Android/Sdk";
-}
-
-let savedEnv: Record<string, string | undefined>;
-beforeEach(() => {
-  savedEnv = { ...process.env };
-});
-afterEach(() => {
-  process.env = savedEnv;
-});
-
-describe("Capacitor 빌드", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    setupDefaultMocks();
-  });
-
-  describe("서명", () => {
-    it("keystore 파일이 없으면 에러가 발생한다", async () => {
-      const { Capacitor } = await import("../../src/capacitor/capacitor.js");
-
-      // keystore 파일만 존재하지 않도록 설정
-      mockFsxExists.mockImplementation(((p: string) => {
-        if (p.includes("my-release.keystore")) return false;
-        return true;
-      }) as never);
-
-      const cap = await Capacitor.create(PKG_PATH, {
-        appId: "com.test.app",
-        appName: "Test App",
-        platform: {
-          android: {
-            sign: {
-              keystore: "my-release.keystore",
-              storePassword: "store123",
-              alias: "my-key",
-              password: "key123",
-            },
-          },
-        },
-      });
-
-      await expect(cap.build("/fake/out")).rejects.toThrow("keystore");
-    });
-  });
-});
+/* eslint-disable no-restricted-properties -- 테스트 환경변수 조작 필요 */
+import { describe, it, expect, vi, beforeAll, afterAll, beforeEach, afterEach } from "vitest";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fsx, cpx } from "@simplysm/core-node";
+
+// sharp는 외부 npm 네이티브 라이브러리로 이미지 처리 시간이 크고 결정적 검증에 mock 필요
+vi.mock("sharp", () => ({
+  default: vi.fn().mockReturnValue({
+    resize: vi.fn().mockReturnThis(),
+    composite: vi.fn().mockReturnThis(),
+    png: vi.fn().mockReturnThis(),
+    toBuffer: vi.fn().mockResolvedValue(new Uint8Array([0])),
+    toFile: vi.fn().mockResolvedValue(undefined),
+  }),
+}));
+
+const mockFsxExists = vi.spyOn(fsx, "exists");
+const mockFsxRead = 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);
+vi.spyOn(fsx, "rm").mockResolvedValue(undefined);
+const mockFsxGlob = vi.spyOn(fsx, "glob").mockResolvedValue([]);
+vi.spyOn(fsx, "copy").mockResolvedValue(undefined);
+
+vi.spyOn(cpx, "spawn").mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
+vi.spyOn(cpx, "spawnSync").mockReturnValue({ stdout: "", stderr: "", exitCode: 0 });
+
+let tmpRoot: string;
+let PKG_PATH: string;
+
+beforeAll(() => {
+  tmpRoot = mkdtempSync(path.join(tmpdir(), "cap-build-"));
+  writeFileSync(path.join(tmpRoot, "package.json"), JSON.stringify({ private: true, workspaces: ["pkg"] }));
+  PKG_PATH = path.join(tmpRoot, "pkg");
+  mkdirSync(path.join(PKG_PATH, ".capacitor"), { recursive: true });
+});
+
+afterAll(() => {
+  rmSync(tmpRoot, { recursive: true, force: true });
+});
+
+function setupDefaultMocks() {
+  mockFsxExists.mockResolvedValue(true);
+
+  mockFsxReadJson.mockImplementation(((p: string) => {
+    const normalized = p.replace(/\\/g, "/");
+    if (normalized.includes(".capacitor/package.json")) {
+      return {
+        name: "com.test.app",
+        version: "1.2.3",
+        dependencies: {
+          "@capacitor/core": "^7.0.0",
+          "@capacitor/app": "^7.0.0",
+          "@capacitor/android": "^7.0.0",
+        },
+        devDependencies: {
+          "@capacitor/cli": "^7.0.0",
+          "@capacitor/assets": "^3.0.0",
+        },
+      };
+    }
+    return { name: "test-pkg", version: "1.2.3" };
+  }) as never);
+
+  mockFsxRead.mockImplementation(((p: string) => {
+    if (p.includes("AndroidManifest.xml")) {
+      return '<manifest xmlns:android="http://schemas.android.com/apk/res/android">\n<application>\n</application>\n</manifest>';
+    }
+    if (p.includes("build.gradle")) {
+      return `android {
+    defaultConfig {
+        versionCode 1
+        versionName "1.0"
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+    }
+    buildTypes { release { } }
+}`;
+    }
+    if (p.includes("gradle.properties")) {
+      return "org.gradle.jvmargs=-Xmx2048m";
+    }
+    return "";
+  }) as never);
+
+  mockFsxGlob.mockImplementation(((pattern: string) => {
+    if (pattern.includes("Corretto") || pattern.includes("jdk")) {
+      return ["C:/Program Files/Amazon Corretto/jdk21.0.1"];
+    }
+    return [];
+  }) as never);
+
+  process.env["ANDROID_HOME"] = "C:/Android/Sdk";
+}
+
+let savedEnv: Record<string, string | undefined>;
+beforeEach(() => {
+  savedEnv = { ...process.env };
+});
+afterEach(() => {
+  process.env = savedEnv;
+});
+
+describe("Capacitor 빌드", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setupDefaultMocks();
+  });
+
+  describe("서명", () => {
+    it("keystore 파일이 없으면 에러가 발생한다", async () => {
+      const { Capacitor } = await import("../../src/capacitor/capacitor.js");
+
+      // keystore 파일만 존재하지 않도록 설정
+      mockFsxExists.mockImplementation(((p: string) => {
+        if (p.includes("my-release.keystore")) return false;
+        return true;
+      }) as never);
+
+      const cap = await Capacitor.create(PKG_PATH, {
+        appId: "com.test.app",
+        appName: "Test App",
+        platform: {
+          android: {
+            sign: {
+              keystore: "my-release.keystore",
+              storePassword: "store123",
+              alias: "my-key",
+              password: "key123",
+            },
+          },
+        },
+      });
+
+      await expect(cap.build("/fake/out")).rejects.toThrow("keystore");
+    });
+  });
+});