@simplysm/sd-cli 14.0.7 → 14.0.9

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/commands/typecheck.spec.ts

@@ -86,8 +86,7 @@ function createMockEngine() {
   const engine = {
     run: vi.fn().mockResolvedValue({
       success: true,
-      js: { success: true, errors: [], warnings: [] },
-      dts: { success: true, errors: [], warnings: [], diagnostics: [] },
+      build: { success: true, errors: [], warnings: [], diagnostics: [] },
 
     }),
     startWatch: vi.fn(),
@@ -161,7 +160,7 @@ describe("executeTypecheck", () => {
       }),
       expect.any(Object),
     );
-    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false, env: "node" });
+    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false, env: "node", includeTests: true });
   });
 
   it("excludes scripts packages from typecheck", async () => {
@@ -217,8 +216,7 @@ describe("executeTypecheck", () => {
       const engine = {
         run: vi.fn().mockResolvedValue({
           success: false,
-          js: { success: true, errors: [], warnings: [] },
-          dts: { success: false, errors: [], warnings: [], diagnostics: [engineDiag] },
+          build: { success: false, errors: [], warnings: [], diagnostics: [engineDiag] },
     
         }),
         startWatch: vi.fn(),
@@ -260,8 +258,7 @@ describe("executeTypecheck", () => {
           active--;
           return {
             success: true,
-            js: { success: true, errors: [], warnings: [] },
-            dts: { success: true, errors: [], warnings: [], diagnostics: [] },
+            build: { success: true, errors: [], warnings: [], diagnostics: [] },
       
           };
         }),
@@ -341,8 +338,8 @@ describe("executeTypecheck", () => {
 
     const runCalls = mockEngines.map((e) => e.run.mock.calls[0][0]);
     expect(runCalls).toEqual([
-      { js: false, dts: false, env: "node" },
-      { js: false, dts: false, env: "browser" },
+      { js: false, dts: false, env: "node", includeTests: true },
+      { js: false, dts: false, env: "browser", includeTests: true },
     ]);
   });
 
@@ -352,7 +349,7 @@ describe("executeTypecheck", () => {
     await executeTypecheck({ targets: [], options: [] });
 
     expect(mocks.createBuildEngine).toHaveBeenCalledTimes(1);
-    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false, env: "node" });
+    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false, env: "node", includeTests: true });
   });
 
   it("creates 1 task (browser) for browser target", async () => {
@@ -361,7 +358,7 @@ describe("executeTypecheck", () => {
     await executeTypecheck({ targets: [], options: [] });
 
     expect(mocks.createBuildEngine).toHaveBeenCalledTimes(1);
-    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false, env: "browser" });
+    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false, env: "browser", includeTests: true });
   });
 
   it("creates 1 task (node) for server target", async () => {
@@ -370,7 +367,7 @@ describe("executeTypecheck", () => {
     await executeTypecheck({ targets: [], options: [] });
 
     expect(mocks.createBuildEngine).toHaveBeenCalledTimes(1);
-    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false, env: "node" });
+    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false, env: "node", includeTests: true });
   });
 
   it("passes env to engine.run() for each task", async () => {
@@ -454,8 +451,7 @@ describe("executeTypecheck", () => {
       const engine = {
         run: vi.fn().mockResolvedValue({
           success: false,
-          js: { success: true, errors: [], warnings: [] },
-          dts: { success: false, errors: [], warnings: [], diagnostics: [diag] },
+          build: { success: false, errors: [], warnings: [], diagnostics: [diag] },
     
         }),
         startWatch: vi.fn(),
@@ -511,8 +507,7 @@ describe("executeTypecheck", () => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: true,
-            js: { success: true, errors: [], warnings: [] },
-            dts: { success: true, errors: [], warnings: [], diagnostics: [] },
+            build: { success: true, errors: [], warnings: [], diagnostics: [] },
             lint: { success: false, errorCount: 2, warningCount: 1, formattedOutput: "lint errors from pkg" },
           }),
           startWatch: vi.fn(),
@@ -567,8 +562,7 @@ describe("executeTypecheck", () => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: true,
-            js: { success: true, errors: [], warnings: [] },
-            dts: { success: true, errors: [], warnings: [], diagnostics: [] },
+            build: { success: true, errors: [], warnings: [], diagnostics: [] },
             lint: { success: true, errorCount: 0, warningCount: 0, formattedOutput: "" },
           }),
           startWatch: vi.fn(),
@@ -663,8 +657,7 @@ describe("executeTypecheck", () => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: true,
-            js: { success: true, errors: [], warnings: [] },
-            dts: { success: true, errors: [], warnings: [], diagnostics: [] },
+            build: { success: true, errors: [], warnings: [], diagnostics: [] },
             lint: { success: false, errorCount: 2, warningCount: 1, formattedOutput: "lint err" },
           }),
           startWatch: vi.fn(),
@@ -718,8 +711,7 @@ describe("executeTypecheck", () => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: false,
-            js: { success: true, errors: [], warnings: [] },
-            dts: {
+            build: {
               success: false,
               errors: ["[core-node:node] Something went wrong"],
               warnings: [],
@@ -741,7 +733,7 @@ describe("executeTypecheck", () => {
     });
 
     // Acceptance: Scenario "복수 엔진이 문자열 에러를 반환"
-    it("복수 엔진이 각각 dts.errors에 메시지를 반환하면 모든 에러 메시지가 formattedOutput에 포함된다", async () => {
+    it("복수 엔진이 각각 build.errors에 메시지를 반환하면 모든 에러 메시지가 formattedOutput에 포함된다", async () => {
       setupDefaults({
         "pkg-a": { target: "node" },
         "pkg-b": { target: "node" },
@@ -758,8 +750,7 @@ describe("executeTypecheck", () => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: false,
-            js: { success: true, errors: [], warnings: [] },
-            dts: {
+            build: {
               success: false,
               errors: [errorMessages[idx]],
               warnings: [],
@@ -780,16 +771,15 @@ describe("executeTypecheck", () => {
       expect(result.formattedOutput).toContain("[pkg-b:node] Error in package B");
     });
 
-    // Unit: 단일 엔진이 dts.errors에 복수 메시지를 반환하면 각각 합성 Diagnostic으로 변환된다
-    it("단일 엔진이 dts.errors에 복수 메시지를 담으면 errorCount가 메시지 수와 일치한다", async () => {
+    // Unit: 단일 엔진이 build.errors에 복수 메시지를 반환하면 각각 합성 Diagnostic으로 변환된다
+    it("단일 엔진이 build.errors에 복수 메시지를 담으면 errorCount가 메시지 수와 일치한다", async () => {
       setupDefaults({ "core-node": { target: "node" } });
 
       mocks.createBuildEngine.mockImplementation(() => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: false,
-            js: { success: true, errors: [], warnings: [] },
-            dts: {
+            build: {
               success: false,
               errors: ["Error message 1", "Error message 2", "Error message 3"],
               warnings: [],
@@ -821,8 +811,7 @@ describe("executeTypecheck", () => {
         const engine = {
           run: vi.fn().mockResolvedValue({
             success: false,
-            js: { success: true, errors: [], warnings: [] },
-            dts: { success: false, errors: [], warnings: [], diagnostics: [diag] },
+            build: { success: false, errors: [], warnings: [], diagnostics: [diag] },
           }),
           startWatch: vi.fn(),
           stop: vi.fn().mockResolvedValue(undefined),

package/tests/electron/electron.spec.ts

@@ -1,3 +1,4 @@
+import path from "path";
 import { describe, it, expect, vi, beforeEach } from "vitest";
 
 //#region Mocks
@@ -21,13 +22,18 @@ vi.mock("@simplysm/core-node", () => ({
     readdir: mockFsxReaddir,
     glob: mockFsxGlob,
   },
+  cpx: {
+    exec: mockCpxExec,
+    execSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
+  },
+  pathx: {
+    posixResolve: (...args: string[]) => path.resolve(...args).replace(/\\/g, "/"),
+    posix: (p: string) => p.replace(/\\/g, "/"),
+  },
 }));
 
-// 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 +97,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 +179,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 +196,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();
@@ -418,7 +426,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([]);
       });
 
@@ -436,15 +445,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) => {
@@ -453,14 +462,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 with banner for env and spawns Electron", async () => {
-      const { resolveElectron } = setupExecaForRun();
+      const { resolveElectron } = setupCpxForRun();
 
       const { Electron } = await import("../../src/electron/electron.js");
       const electron = await Electron.create(PKG_PATH, { appId: "com.test.app" });
@@ -503,7 +512,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" });
@@ -526,7 +535,7 @@ describe("Electron", () => {
   describe("단위: run() 플러그인 동작", () => {
     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;
@@ -534,7 +543,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");
@@ -559,7 +568,7 @@ describe("Electron", () => {
 
     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;
@@ -567,7 +576,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");
@@ -579,7 +588,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/engines/base-engine.spec.ts

@@ -46,8 +46,7 @@ function createMockPkg(overrides: Partial<BuildPackageInfo> = {}): BuildPackageI
 
 function setupDefaultBuildResult(): void {
   mockWorker.build.mockResolvedValue({
-    js: { success: true, errors: undefined, warnings: undefined },
-    dts: { success: true, errors: undefined, diagnostics: [] },
+    build: { success: true, errors: undefined, warnings: undefined, diagnostics: [] },
     lint: { success: true, errorCount: 0, warningCount: 0, formattedOutput: "" },
   });
   mockWorker.terminate.mockResolvedValue(undefined);
@@ -78,7 +77,7 @@ describe("BaseEngine", () => {
         const buildHandler = mockWorker.on.mock.calls.find(
           (call: any[]) => call[0] === "build",
         )?.[1];
-        buildHandler?.({ js: { success: true }, dts: { success: true } });
+        buildHandler?.({ build: { success: true } });
       });
 
       const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
@@ -101,7 +100,7 @@ describe("BaseEngine", () => {
         const buildHandler = mockWorker.on.mock.calls.find(
           (call: any[]) => call[0] === "build",
         )?.[1];
-        buildHandler?.({ js: { success: true }, dts: { success: true } });
+        buildHandler?.({ build: { success: true } });
       });
 
       const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
@@ -114,7 +113,7 @@ describe("BaseEngine", () => {
       await engine.stop();
     });
 
-    it("reports build and dts results separately to ResultCollector", async () => {
+    it("reports build result to ResultCollector", async () => {
       const mockResultCollector = { add: vi.fn() };
 
       mockWorker.startWatch.mockImplementation(() => {
@@ -122,8 +121,7 @@ describe("BaseEngine", () => {
           (call: any[]) => call[0] === "build",
         )?.[1];
         buildHandler?.({
-          js: { success: true, errors: undefined },
-          dts: { success: false, errors: ["type error"] },
+          build: { success: false, errors: ["type error"] },
         });
       });
 
@@ -137,13 +135,10 @@ describe("BaseEngine", () => {
 
       const addCalls = mockResultCollector.add.mock.calls;
       const buildResult = addCalls.find((c: any[]) => c[0].type === "build");
-      const dtsResult = addCalls.find((c: any[]) => c[0].type === "dts");
 
       expect(buildResult).toBeDefined();
-      expect(buildResult![0].status).toBe("success");
+      expect(buildResult![0].status).toBe("error");
       expect(buildResult![0].target).toBe("node");
-      expect(dtsResult).toBeDefined();
-      expect(dtsResult![0].status).toBe("error");
 
       await engine.stop();
     });
@@ -157,7 +152,7 @@ describe("BaseEngine", () => {
         const buildHandler = mockWorker.on.mock.calls.find(
           (call: any[]) => call[0] === "build",
         )?.[1];
-        buildHandler?.({ js: { success: true }, dts: { success: true } });
+        buildHandler?.({ build: { success: true } });
       });
 
       const engine = new TscEngine({
@@ -182,7 +177,7 @@ describe("BaseEngine", () => {
         "test-pkg (node)",
       );
 
-      buildHandler?.({ js: { success: true }, dts: { success: true } });
+      buildHandler?.({ build: { success: true } });
       expect(mockResolver).toHaveBeenCalled();
 
       await engine.stop();
@@ -209,7 +204,7 @@ describe("BaseEngine", () => {
         const buildHandler = mockWorker.on.mock.calls.find(
           (call: any[]) => call[0] === "build",
         )?.[1];
-        buildHandler?.({ js: { success: true }, dts: { success: true } });
+        buildHandler?.({ build: { success: true } });
       });
 
       const engine = new TscEngine({
@@ -229,7 +224,7 @@ describe("BaseEngine", () => {
       )?.[1];
 
       buildStartHandler?.({});
-      buildHandler?.({ js: { success: true }, dts: { success: true } });
+      buildHandler?.({ build: { success: true } });
 
       // The resolver should have been called, which resolves the RebuildManager promise
       expect(resolverFn).toBeDefined();
@@ -237,7 +232,7 @@ describe("BaseEngine", () => {
       await engine.stop();
     });
 
-    it("does not call registerBuild on initial buildStart (only on rebuilds)", async () => {
+    it("calls registerBuild on initial buildStart as well as rebuilds", async () => {
       const mockRebuildManager = { registerBuild: vi.fn(() => vi.fn()) };
 
       mockWorker.startWatch.mockImplementation(() => {
@@ -251,7 +246,7 @@ describe("BaseEngine", () => {
         const buildHandler = mockWorker.on.mock.calls.find(
           (call: any[]) => call[0] === "build",
         )?.[1];
-        buildHandler?.({ js: { success: true }, dts: { success: true } });
+        buildHandler?.({ build: { success: true } });
       });
 
       const engine = new TscEngine({
@@ -262,8 +257,8 @@ describe("BaseEngine", () => {
 
       await engine.startWatch({ js: true, dts: true });
 
-      // registerBuild should NOT have been called for the initial build
-      expect(mockRebuildManager.registerBuild).not.toHaveBeenCalled();
+      // registerBuild should be called for ALL builds including initial
+      expect(mockRebuildManager.registerBuild).toHaveBeenCalledOnce();
 
       await engine.stop();
     });
@@ -276,8 +271,7 @@ describe("BaseEngine", () => {
           (call: any[]) => call[0] === "build",
         )?.[1];
         buildHandler?.({
-          js: { success: true },
-          dts: { success: true },
+          build: { success: true },
         });
       });
 

package/tests/engines/engine-lint-integration.spec.ts

@@ -48,8 +48,7 @@ function createMockPkg(): BuildPackageInfo {
 beforeEach(() => {
   vi.clearAllMocks();
   mockWorker.build.mockResolvedValue({
-    js: { success: true },
-    dts: { success: true, diagnostics: [] },
+    build: { success: true, diagnostics: [] },
     lint: { success: true, errorCount: 0, warningCount: 0, formattedOutput: "" },
   });
   mockWorker.terminate.mockResolvedValue(undefined);
@@ -72,8 +71,7 @@ describe("엔진 lint 통합 (Slice 2)", () => {
   describe("Scenario: EngineResult includes lint field", () => {
     it("run() returns EngineResult with lint field when worker provides it", async () => {
       mockWorker.build.mockResolvedValue({
-        js: { success: true },
-        dts: { success: true, diagnostics: [] },
+        build: { success: true, diagnostics: [] },
         lint: { success: false, errorCount: 3, warningCount: 1, formattedOutput: "lint errors" },
       });
 
@@ -92,8 +90,7 @@ describe("엔진 lint 통합 (Slice 2)", () => {
 
     it("run() returns EngineResult without lint when lint is not in output", async () => {
       mockWorker.build.mockResolvedValue({
-        js: { success: true },
-        dts: { success: true, diagnostics: [] },
+        build: { success: true, diagnostics: [] },
       });
 
       const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
@@ -114,8 +111,7 @@ describe("엔진 lint 통합 (Slice 2)", () => {
           (call: any[]) => call[0] === "build",
         )?.[1];
         buildHandler?.({
-          js: { success: true },
-          dts: { success: true },
+          build: { success: true },
           lint: { success: false, errorCount: 2, warningCount: 0, formattedOutput: "errors" },
         });
       });
@@ -150,8 +146,7 @@ describe("엔진 lint 통합 (Slice 2)", () => {
           (call: any[]) => call[0] === "build",
         )?.[1];
         buildHandler?.({
-          js: { success: true },
-          dts: { success: true },
+          build: { success: true },
         });
       });