@simplysm/sd-cli 14.0.6 → 14.0.8

package/tests/commands/check.spec.ts

@@ -35,8 +35,11 @@ vi.mock("../../src/utils/sd-config", () => ({
   loadSdConfig: mocks.loadSdConfig,
 }));
 
-vi.mock("execa", () => ({
-  execa: mocks.execa,
+vi.mock("@simplysm/core-node", () => ({
+  cpx: {
+    exec: mocks.execa,
+    execSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
+  },
 }));
 
 vi.mock("../../src/utils/package-utils", async (importOriginal) => {
@@ -117,21 +120,20 @@ describe("runCheck", () => {
     writeSpy.mockRestore();
   });
 
-  it("runs typecheck+lint and test, outputs ALL PASSED", async () => {
+  it("runs typecheck+lint and test", async () => {
     await runCheck({ targets: [], types: ["typecheck", "lint", "test"], fix: false });
 
     expect(mocks.executeTypecheck).toHaveBeenCalled();
     expect(mocks.execa).toHaveBeenCalled();
-    expect(stdoutOutput).toContain("ALL PASSED");
   });
 
-  it("outputs results in TYPECHECK → LINT → TEST → SUMMARY order", async () => {
+  it("outputs results in TYPECHECK → LINT → TEST → 요약 order", async () => {
     await runCheck({ targets: [], types: ["typecheck", "lint", "test"], fix: false });
 
     const tcIdx = stdoutOutput.indexOf("TYPECHECK");
     const lintIdx = stdoutOutput.indexOf("LINT");
     const testIdx = stdoutOutput.indexOf("TEST");
-    const summaryIdx = stdoutOutput.indexOf("SUMMARY");
+    const summaryIdx = stdoutOutput.indexOf("요약");
 
     expect(tcIdx).toBeLessThan(lintIdx);
     expect(lintIdx).toBeLessThan(testIdx);
@@ -146,7 +148,7 @@ describe("runCheck", () => {
     expect(mocks.execa).toHaveBeenCalled();
   });
 
-  it("outputs FAILED with failing check names when some fail", async () => {
+  it("sets exitCode 1 when typecheck fails", async () => {
     mocks.executeTypecheck.mockResolvedValue({
       success: false, errorCount: 2, warningCount: 0, formattedOutput: "type errors",
       lint: { success: true, errorCount: 0, warningCount: 0, formattedOutput: "" },
@@ -155,8 +157,6 @@ describe("runCheck", () => {
 
     await runCheck({ targets: [], types: ["typecheck", "lint", "test"], fix: false });
 
-    expect(stdoutOutput).toContain("FAILED");
-    expect(stdoutOutput).toContain("typecheck");
     expect(process.exitCode).toBe(1);
   });
 
@@ -170,14 +170,13 @@ describe("runCheck", () => {
     expect(process.exitCode).toBe(1);
   });
 
-  it("parses test failure count from vitest output", async () => {
+  it("sets exitCode 1 when test fails", async () => {
     mocks.execa.mockResolvedValue({
       stdout: "3 tests failed", stderr: "", exitCode: 1,
     });
 
     await runCheck({ targets: [], types: ["test"], fix: false });
 
-    expect(stdoutOutput).toContain("3 failed");
     expect(process.exitCode).toBe(1);
   });
 
@@ -271,8 +270,8 @@ describe("runCheck", () => {
       expect(mocks.runLintInWorker).not.toHaveBeenCalled();
     });
 
-    // Scenario: check 결과 출력에 LINT 섹션이 포함된다
-    it("outputs separate TYPECHECK and LINT sections from engine results", async () => {
+    // Scenario: lint 실패 시 exitCode 설정
+    it("sets exitCode 1 when engine lint fails", async () => {
       mocks.executeTypecheck.mockResolvedValue({
         success: true, errorCount: 0, warningCount: 0, formattedOutput: "",
         lint: { success: false, errorCount: 3, warningCount: 1, formattedOutput: "some lint output" },
@@ -281,10 +280,7 @@ describe("runCheck", () => {
 
       await runCheck({ targets: [], types: ["typecheck", "lint"], fix: false });
 
-      expect(stdoutOutput).toContain("TYPECHECK");
-      expect(stdoutOutput).toContain("LINT");
-      expect(stdoutOutput).toContain("3 errors");
-      expect(stdoutOutput).toContain("1 warnings");
+      expect(process.exitCode).toBe(1);
     });
 
     // Scenario: check에서 scripts 패키지의 lint가 별도 실행된다
@@ -391,43 +387,35 @@ describe("runCheck", () => {
     });
 
     // Scenario: lint 에러 없음
-    it("outputs ALL PASSED when lint has no errors", async () => {
+    it("does not set exitCode when lint passes", async () => {
       mocks.executeLint.mockResolvedValue({
         success: true, errorCount: 0, warningCount: 0, formattedOutput: "",
       });
 
       await runCheck({ targets: [], types: ["lint"], fix: false });
 
-      expect(stdoutOutput).toContain("LINT");
-      expect(stdoutOutput).toContain("✔ 0 errors, 0 warnings");
-      expect(stdoutOutput).toContain("✔ ALL PASSED");
       expect(process.exitCode).toBeUndefined();
     });
 
     // Scenario: lint 에러 발생
-    it("outputs FAILED when lint has errors", async () => {
+    it("sets exitCode 1 when lint has errors", async () => {
       mocks.executeLint.mockResolvedValue({
         success: false, errorCount: 3, warningCount: 2, formattedOutput: "lint errors",
       });
 
       await runCheck({ targets: [], types: ["lint"], fix: false });
 
-      expect(stdoutOutput).toContain("LINT");
-      expect(stdoutOutput).toContain("✖ 3 errors, 2 warnings");
-      expect(stdoutOutput).toContain("✖ 1/1 FAILED (lint)");
       expect(process.exitCode).toBe(1);
     });
 
     // Scenario: lint 대상 파일 없음
-    it("outputs ALL PASSED when no files to lint", async () => {
+    it("does not set exitCode when no files to lint", async () => {
       mocks.executeLint.mockResolvedValue({
         success: true, errorCount: 0, warningCount: 0, formattedOutput: "",
       });
 
       await runCheck({ targets: [], types: ["lint"], fix: false });
 
-      expect(stdoutOutput).toContain("✔ 0 errors, 0 warnings");
-      expect(stdoutOutput).toContain("✔ ALL PASSED");
       expect(process.exitCode).toBeUndefined();
     });
 

package/tests/commands/publish.spec.ts

@@ -48,12 +48,12 @@ vi.mock("../../src/utils/replace-deps", () => ({
   parseWorkspaceGlobs: mocks.parseWorkspaceGlobs,
 }));
 
-vi.mock("execa", () => ({
-  execa: mocks.execa,
-}));
-
 vi.mock("@simplysm/core-node", () => ({
   fsx: mocks.fsx,
+  cpx: {
+    exec: mocks.execa,
+    execSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
+  },
 }));
 
 vi.mock("@simplysm/core-common", () => {

package/tests/electron/electron.spec.ts

@@ -21,13 +21,14 @@ vi.mock("@simplysm/core-node", () => ({
     readdir: mockFsxReaddir,
     glob: mockFsxGlob,
   },
+  cpx: {
+    exec: mockCpxExec,
+    execSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
+  },
 }));
 
-// execa mock
-const mockExeca = vi.fn().mockResolvedValue({ stdout: "" });
-vi.mock("execa", () => ({
-  execa: mockExeca,
-}));
+// cpx mock (was execa)
+const mockCpxExec = vi.fn().mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
 
 // esbuild mock
 const mockEsbuildBuild = vi.fn().mockResolvedValue({});
@@ -91,13 +92,15 @@ function setupDefaultMocks() {
   });
   mockFsxReaddir.mockResolvedValue(["index.html", "assets", "electron"]);
   // Default: glob returns one exe file matching the builder output
-  mockFsxGlob.mockImplementation((pattern: string, opts?: { cwd?: string }) => {
-    if (pattern === "*.exe" && opts?.cwd != null) {
-      return Promise.resolve([opts.cwd.replace(/\\/g, "/") + "/My App Setup 1.0.0.exe"]);
+  mockFsxGlob.mockImplementation((pattern: string) => {
+    const normalized = pattern.replace(/\\/g, "/");
+    if (normalized.endsWith(".electron/dist/*.exe")) {
+      const dir = normalized.replace("/*.exe", "");
+      return Promise.resolve([dir + "/My App Setup 1.0.0.exe"]);
     }
     return Promise.resolve([]);
   });
-  mockExeca.mockResolvedValue({ stdout: "" });
+  mockCpxExec.mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
   mockEsbuildBuild.mockResolvedValue({});
 }
 
@@ -171,7 +174,7 @@ describe("Electron", () => {
 
       expect(findElectronPackageJson()).toBeDefined();
 
-      const execaCalls = mockExeca.mock.calls;
+      const execaCalls = mockCpxExec.mock.calls;
       expect(
         execaCalls.find((c) => c[0] === "npm" && (c[1] as string[]).includes("install")),
       ).toBeDefined();
@@ -188,7 +191,7 @@ describe("Electron", () => {
       const electron = await Electron.create(PKG_PATH, { appId: "com.test.app" });
       await electron.initialize();
 
-      const rebuildCall = mockExeca.mock.calls.find(
+      const rebuildCall = mockCpxExec.mock.calls.find(
         (c) => typeof c[0] === "string" && c[0].includes("electron-rebuild"),
       );
       expect(rebuildCall).toBeUndefined();
@@ -278,6 +281,25 @@ describe("Electron", () => {
 
       await expect(electron.build("/fake/out")).rejects.toThrow("electron-main.ts");
     });
+
+    it("config.env를 esbuild banner로 주입한다 (ELECTRON_DEV_URL 미포함)", async () => {
+      const { Electron } = await import("../../src/electron/electron.js");
+
+      const electron = await Electron.create(PKG_PATH, {
+        appId: "com.test.app",
+        env: { API_URL: "https://api.example.com" },
+      });
+      await electron.build("/fake/out");
+
+      const callArgs = mockEsbuildBuild.mock.calls[0][0];
+      const banner = callArgs.banner?.js as string;
+      expect(banner).toContain("process.env");
+      expect(banner).toContain("??=");
+      expect(banner).toContain("API_URL");
+      expect(banner).toContain("https://api.example.com");
+      expect(banner).not.toContain("ELECTRON_DEV_URL");
+      expect(callArgs.define).toBeUndefined();
+    });
   });
 
   //#endregion
@@ -399,7 +421,8 @@ describe("Electron", () => {
 
     it("빌드 산출물이 없으면 경고를 출력한다", async () => {
       mockFsxGlob.mockImplementation((pattern: string) => {
-        if (pattern === "*.exe") return Promise.resolve([]);
+        const normalized = pattern.replace(/\\/g, "/");
+        if (normalized.endsWith(".electron/dist/*.exe")) return Promise.resolve([]);
         return Promise.resolve([]);
       });
 
@@ -417,15 +440,15 @@ describe("Electron", () => {
   //#region Rule: 개발 모드에서 Electron 앱을 실행한다
 
   describe("인수 테스트: run()", () => {
-    // Helper: creates a deferred execa mock where Electron process can be controlled
-    function setupExecaForRun(): {
+    // Helper: creates a deferred cpx mock where Electron process can be controlled
+    function setupCpxForRun(): {
       electronKill: ReturnType<typeof vi.fn>;
       resolveElectron: () => void;
     } {
       const electronKill = vi.fn();
       let resolveElectron: () => void = () => {};
 
-      mockExeca.mockImplementation((cmd: string) => {
+      mockCpxExec.mockImplementation((cmd: string) => {
         if (typeof cmd === "string" && cmd.includes("electron")) {
           // Electron process: create a deferred promise we can resolve externally
           const p = new Promise<void>((resolve) => {
@@ -434,14 +457,14 @@ describe("Electron", () => {
           p.kill = electronKill;
           return p;
         }
-        return Promise.resolve({ stdout: "" });
+        return Promise.resolve({ stdout: "", stderr: "", exitCode: 0 });
       });
 
       return { electronKill, resolveElectron: () => resolveElectron() };
     }
 
-    it("creates esbuild context and spawns Electron on build success", async () => {
-      const { resolveElectron } = setupExecaForRun();
+    it("creates esbuild context with banner for env and spawns Electron", async () => {
+      const { resolveElectron } = setupCpxForRun();
 
       const { Electron } = await import("../../src/electron/electron.js");
       const electron = await Electron.create(PKG_PATH, { appId: "com.test.app" });
@@ -455,28 +478,20 @@ describe("Electron", () => {
       resolveElectron();
       await runPromise;
 
-      // esbuild.context was called
-      expect(mockEsbuildContext).toHaveBeenCalledWith(
-        expect.objectContaining({
-          platform: "node",
-          target: "node20",
-          format: "cjs",
-          bundle: true,
-          external: expect.arrayContaining(["electron"]),
-        }),
-      );
-
-      // Electron was spawned via execa
-      const electronCall = mockExeca.mock.calls.find(
-        (c: any[]) => typeof c[0] === "string" && c[0].includes("electron"),
-      );
-      expect(electronCall).toBeDefined();
-      expect(electronCall![2].env).toEqual(
-        expect.objectContaining({
-          NODE_ENV: "development",
-          ELECTRON_DEV_URL: "http://localhost:4200",
-        }),
-      );
+      // esbuild.context was called with banner containing ELECTRON_DEV_URL
+      const callArgs = mockEsbuildContext.mock.calls[0][0];
+      const banner = callArgs.banner?.js as string;
+      expect(banner).toContain("process.env");
+      expect(banner).toContain("??=");
+      expect(banner).toContain("ELECTRON_DEV_URL");
+      expect(banner).toContain("http://localhost:4200");
+      expect(callArgs.define).toBeUndefined();
+
+      expect(callArgs.platform).toBe("node");
+      expect(callArgs.target).toBe("node20");
+      expect(callArgs.format).toBe("cjs");
+      expect(callArgs.bundle).toBe(true);
+      expect(callArgs.external).toContain("electron");
     }, 10_000);
 
     it("throws when electron-main.ts entry point is missing", async () => {
@@ -492,7 +507,7 @@ describe("Electron", () => {
     });
 
     it("resolves on SIGINT signal", async () => {
-      const { electronKill } = setupExecaForRun();
+      const { electronKill } = setupCpxForRun();
 
       const { Electron } = await import("../../src/electron/electron.js");
       const electron = await Electron.create(PKG_PATH, { appId: "com.test.app" });
@@ -513,9 +528,9 @@ describe("Electron", () => {
   });
 
   describe("단위: run() 플러그인 동작", () => {
-    it("passes custom env and ELECTRON_DEV_URL to spawned Electron process", async () => {
+    it("passes custom env and ELECTRON_DEV_URL via esbuild banner", async () => {
       let resolveElectron: () => void = () => {};
-      mockExeca.mockImplementation((cmd: string) => {
+      mockCpxExec.mockImplementation((cmd: string) => {
         if (typeof cmd === "string" && cmd.includes("electron")) {
           const p = new Promise<void>((resolve) => {
             resolveElectron = resolve;
@@ -523,7 +538,7 @@ describe("Electron", () => {
           p.kill = vi.fn();
           return p;
         }
-        return Promise.resolve({ stdout: "" });
+        return Promise.resolve({ stdout: "", stderr: "", exitCode: 0 });
       });
 
       const { Electron } = await import("../../src/electron/electron.js");
@@ -537,22 +552,18 @@ describe("Electron", () => {
       resolveElectron();
       await runPromise;
 
-      const execaCall = mockExeca.mock.calls.find(
-        (c: any[]) => typeof c[0] === "string" && c[0].includes("electron"),
-      );
-      expect(execaCall).toBeDefined();
-      expect(execaCall![2].env).toEqual(
-        expect.objectContaining({
-          NODE_ENV: "development",
-          ELECTRON_DEV_URL: "http://localhost:5555",
-          CUSTOM_VAR: "test-value",
-        }),
-      );
+      const callArgs = mockEsbuildContext.mock.calls[0][0];
+      const banner = callArgs.banner?.js as string;
+      expect(banner).toContain("ELECTRON_DEV_URL");
+      expect(banner).toContain("http://localhost:5555");
+      expect(banner).toContain("CUSTOM_VAR");
+      expect(banner).toContain("test-value");
+      expect(callArgs.define).toBeUndefined();
     }, 10_000);
 
     it("calls initialize() before starting esbuild context", async () => {
       let resolveElectron: () => void = () => {};
-      mockExeca.mockImplementation((cmd: string) => {
+      mockCpxExec.mockImplementation((cmd: string) => {
         if (typeof cmd === "string" && cmd.includes("electron")) {
           const p = new Promise<void>((resolve) => {
             resolveElectron = resolve;
@@ -560,7 +571,7 @@ describe("Electron", () => {
           p.kill = vi.fn();
           return p;
         }
-        return Promise.resolve({ stdout: "" });
+        return Promise.resolve({ stdout: "", stderr: "", exitCode: 0 });
       });
 
       const { Electron } = await import("../../src/electron/electron.js");
@@ -572,7 +583,7 @@ describe("Electron", () => {
       await runPromise;
 
       // initialize calls npm install -> execa should have been called with npm install
-      const npmInstallCall = mockExeca.mock.calls.find(
+      const npmInstallCall = mockCpxExec.mock.calls.find(
         (c: any[]) => c[0] === "npm" && (c[1] as string[]).includes("install"),
       );
       expect(npmInstallCall).toBeDefined();

package/tests/orchestrators/build-orchestrator.spec.ts

@@ -221,7 +221,7 @@ describe("BuildOrchestrator.initialize", () => {
     );
   });
 
-  it("outputs message when no packages to build", async () => {
+  it("returns false when only scripts packages exist", async () => {
     setupDefaults({
       packages: {
         "sd-claude": { target: "scripts" } as any,
@@ -230,10 +230,9 @@ describe("BuildOrchestrator.initialize", () => {
 
     const orchestrator = new BuildOrchestrator({ targets: [], options: [] });
     await orchestrator.initialize();
+    const hasError = await orchestrator.start();
 
-    expect(process.stdout.write).toHaveBeenCalledWith(
-      expect.stringContaining("No packages to build"),
-    );
+    expect(hasError).toBe(false);
   });
 });
 
@@ -403,10 +402,9 @@ describe("BuildOrchestrator.start", () => {
     const hasError = await orchestrator.start();
 
     expect(hasError).toBe(false);
-    expect(mockLogger.info).toHaveBeenCalledWith("Build completed");
   });
 
-  it("returns true and logs error when any build fails", async () => {
+  it("returns true when any build fails", async () => {
     setupDefaults({
       packages: {
         "core-common": { target: "neutral", publish: { type: "npm" } },
@@ -429,7 +427,6 @@ describe("BuildOrchestrator.start", () => {
     const hasError = await orchestrator.start();
 
     expect(hasError).toBe(true);
-    expect(mockLogger.error).toHaveBeenCalledWith("Build failed");
   });
 
   it("returns false when no packages to build", async () => {
@@ -658,7 +655,6 @@ describe("BuildOrchestrator client build", () => {
     const hasError = await orchestrator.start();
 
     expect(hasError).toBe(true);
-    expect(mockLogger.error).toHaveBeenCalledWith("Build failed");
   });
 
   // Acceptance: Scenario "BuildOrchestrator가 env를 ViteEngine에 전달" + "프로덕션 빌드의 baseEnv"
@@ -1049,7 +1045,6 @@ describe("BuildOrchestrator lint integration", () => {
     const hasError = await orchestrator.start();
 
     expect(hasError).toBe(true);
-    expect(mockLogger.error).toHaveBeenCalledWith("Build failed");
   });
 
   // Scenario: build에서 scripts 패키지는 제외된다

package/tests/orchestrators/dev-watch-orchestrator.spec.ts

@@ -300,7 +300,6 @@ describe("DevWatchOrchestrator", () => {
       const orchestrator = new DevWatchOrchestrator({ mode: "watch", targets: [], options: [] });
       await orchestrator.initialize();
 
-      expect(process.stdout.write).toHaveBeenCalledWith(expect.stringContaining("No packages"));
       expect(createBuildEngine).not.toHaveBeenCalled();
     });
 
@@ -872,7 +871,6 @@ describe("DevWatchOrchestrator", () => {
 
       expect(mockBuildEngines[0].stop).toHaveBeenCalledOnce();
       expect(mockRuntimeProxies[0].terminate).toHaveBeenCalled();
-      expect(process.stdout.write).toHaveBeenCalledWith(expect.stringContaining("Shutting down"));
     });
 
     // --- Acceptance: dev에서 replaceDeps 감시 ---
@@ -890,8 +888,8 @@ describe("DevWatchOrchestrator", () => {
       expect(watchReplaceDeps).toHaveBeenCalledWith("/test-root", replaceDeps);
     });
 
-    // Unit: outputs warning when no server packages
-    it("outputs warning when no server packages in dev mode", async () => {
+    // Unit: no server packages in dev mode — does not create runtime proxies
+    it("does not create runtime proxies when no server packages in dev mode", async () => {
       setupDefaults(createConfig({
         packages: { "core-common": { target: "node" } },
       }));
@@ -899,7 +897,7 @@ describe("DevWatchOrchestrator", () => {
       const orchestrator = new DevWatchOrchestrator({ mode: "dev", targets: [], options: [] });
       await orchestrator.initialize();
 
-      expect(process.stdout.write).toHaveBeenCalledWith(expect.stringContaining("No"));
+      expect(createBuildEngine).not.toHaveBeenCalled();
     });
 
     // Unit: multiple server packages

package/tests/utils/esbuild-config.spec.ts

@@ -17,7 +17,7 @@ vi.mock("consola", () => ({
   },
 }));
 
-const { createServerEsbuildOptions, writeChangedOutputFiles } =
+const { createServerEsbuildOptions, createEnvBanner, writeChangedOutputFiles } =
   await import("../../src/utils/esbuild-config");
 
 const { default: mockFs } = await import("fs/promises");
@@ -53,20 +53,25 @@ describe("createServerEsbuildOptions", () => {
     expect((result.banner as Record<string, string>)["js"]).toContain("import.meta.url");
   });
 
-  it("substitutes env vars via define (process.env.KEY → constant)", () => {
+  it("injects env vars via banner (process.env merge) instead of define", () => {
     const result = createServerEsbuildOptions({
       ...baseOptions,
       env: { API_URL: "https://api.example.com", NODE_ENV: "production" },
     });
-    expect(result.define).toEqual({
-      "process.env.API_URL": '"https://api.example.com"',
-      "process.env.NODE_ENV": '"production"',
-    });
+    const banner = (result.banner as Record<string, string>)["js"];
+    expect(banner).toContain("process.env");
+    expect(banner).toContain("??=");
+    expect(banner).toContain("API_URL");
+    expect(banner).toContain("https://api.example.com");
+    expect(result.define).toBeUndefined();
   });
 
-  it("produces empty define when env is not provided", () => {
+  it("does not include env code in banner when env is not provided", () => {
     const result = createServerEsbuildOptions(baseOptions);
-    expect(result.define).toEqual({});
+    const banner = (result.banner as Record<string, string>)["js"];
+    expect(banner).toContain("createRequire");
+    expect(banner).not.toContain("??=");
+    expect(result.define).toBeUndefined();
   });
 
   it("passes external modules to esbuild", () => {
@@ -88,6 +93,31 @@ describe("createServerEsbuildOptions", () => {
   });
 });
 
+describe("createEnvBanner", () => {
+  it("generates process.env merge code with ??= for runtime override", () => {
+    const banner = createEnvBanner({ API_URL: "https://api.example.com", NODE_ENV: "production" });
+    expect(banner).toContain("process.env");
+    expect(banner).toContain("??=");
+    expect(banner).toContain('"API_URL"');
+    expect(banner).toContain('"https://api.example.com"');
+    expect(banner).toContain('"NODE_ENV"');
+    expect(banner).toContain('"production"');
+  });
+
+  it("returns empty string when env is undefined", () => {
+    expect(createEnvBanner()).toBe("");
+  });
+
+  it("returns empty string when env is empty object", () => {
+    expect(createEnvBanner({})).toBe("");
+  });
+
+  it("JSON-encodes special characters in values", () => {
+    const banner = createEnvBanner({ MSG: 'hello "world"' });
+    expect(banner).toContain('\\"world\\"');
+  });
+});
+
 describe("writeChangedOutputFiles", () => {
   beforeEach(() => {
     vi.mocked(mockFs.readFile).mockReset();

package/tests/utils/vite-config.spec.ts

@@ -67,6 +67,19 @@ afterEach(() => {
 });
 
 describe("createClientViteConfig", () => {
+  // Acceptance: Scenario "define['process.env'] 제거"
+  it("does not include process.env in define, only import.meta.env keys", async () => {
+    const config = await createClientViteConfig({
+      ...createDefaultOptions(),
+      env: { DEV: "true", VER: "1.0.0" },
+    });
+
+    const define = config.define as Record<string, string>;
+    expect(define).not.toHaveProperty("process.env");
+    expect(define["import.meta.env.DEV"]).toBe('"true"');
+    expect(define["import.meta.env.VER"]).toBe('"1.0.0"');
+  });
+
   // Acceptance: Scenario "browserslist 미설정 시 최신 브라우저 유지"
   it("uses es2022 esbuild target when no browserslist is provided", async () => {
     const config = await createClientViteConfig(createDefaultOptions());

package/tests/workers/server-build-worker.spec.ts

@@ -35,6 +35,8 @@ const mockRunTscPackageBuild = vi.fn(() => ({
   warningCount: 0,
 }));
 
+const mockCpxExecSync = vi.fn().mockReturnValue({ stdout: "v20.11.0", stderr: "", exitCode: 0 });
+
 vi.mock("@simplysm/core-node", () => ({
   createWorker: vi.fn((fns: Record<string, Function>) => {
     workerFns = fns as any;
@@ -50,6 +52,10 @@ vi.mock("@simplysm/core-node", () => ({
   pathx: {
     norm: vi.fn((...args: string[]) => path.resolve(...args).replace(/\\/g, "/")),
   },
+  cpx: {
+    exec: vi.fn().mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 }),
+    execSync: mockCpxExecSync,
+  },
 }));
 
 vi.mock("@simplysm/core-common", () => ({
@@ -95,9 +101,6 @@ vi.mock("fs", () => ({
   existsSync: (...args: unknown[]) => mockExistsSync(...(args as [string])),
 }));
 
-vi.mock("execa", () => ({
-  execaSync: vi.fn(() => ({ stdout: "v20.11.0" })),
-}));
 
 // Mock lockfile content for resolveLockedVersion
 let mockLockfileContent = "";