@simplysm/sd-cli 14.0.10 → 14.0.12

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

@@ -27,8 +27,8 @@ vi.mock("@simplysm/core-node", () => ({
     copy: mockFsxCopy,
   },
   cpx: {
-    exec: mockCpxExec,
-    execSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
+    spawn: mockCpxSpawn,
+    spawnSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
   },
   pathx: {
     posixResolve: (...args: string[]) => path.resolve(...args).replace(/\\/g, "/"),
@@ -49,7 +49,7 @@ const execaCalls: { command: string; args: string[] }[] = [];
 let execaFactory: (...args: unknown[]) => Promise<{ stdout: string; stderr: string; exitCode: number }> = () =>
   Promise.resolve({ stdout: "", stderr: "", exitCode: 0 });
 
-const mockCpxExec = vi.fn((...args: unknown[]) => {
+const mockCpxSpawn = vi.fn((...args: unknown[]) => {
   execaCalls.push({ command: args[0] as string, args: (args[1] as string[] | undefined) ?? [] });
   return execaFactory(...args);
 });
@@ -84,7 +84,9 @@ vi.mock("consola", () => ({
       warn: mockLoggerWarn,
       info: vi.fn(),
     }),
+    level: 0,
   },
+  LogLevels: { debug: 4 },
 }));
 
 //#endregion
@@ -175,14 +177,14 @@ describe("Capacitor.run()", () => {
 
     // cap copy android + cap run android
     const capCmds = execaCalls.filter(
-      (c) => c.command === "npx" && c.args.includes("cap"),
+      (c) => c.command === "pnpm" && c.args.includes("cap"),
     );
     expect(capCmds.some((c) => c.args.includes("copy") && c.args.includes("android"))).toBe(true);
     expect(capCmds.some((c) => c.args.includes("run") && c.args.includes("android"))).toBe(true);
   });
 
-  // Unit: adb kill-server retry on cap run failure
-  it("retries cap run after adb kill-server on android platform failure", async () => {
+  // Unit: cap run 실패 시 adb kill-server 호출 후 에러를 re-throw한다
+  it("calls adb kill-server and re-throws on android platform cap run failure", async () => {
     const { Capacitor } = await import("../../src/capacitor/capacitor.js");
 
     let capRunCallCount = 0;
@@ -191,16 +193,13 @@ describe("Capacitor.run()", () => {
       const cmdArgs = (args[1] as string[] | undefined) ?? [];
 
       if (
-        cmd === "npx" &&
+        cmd === "pnpm" &&
         cmdArgs.includes("cap") &&
         cmdArgs.includes("run") &&
         cmdArgs.includes("android")
       ) {
         capRunCallCount++;
-        if (capRunCallCount === 1) {
-          // First cap run fails
-          return Promise.reject(new Error("cap run failed"));
-        }
+        return Promise.reject(new Error("cap run failed"));
       }
       return Promise.resolve({ stdout: "", stderr: "", exitCode: 0 });
     };
@@ -211,16 +210,14 @@ describe("Capacitor.run()", () => {
       platform: { android: {} },
     });
 
-    await cap.run("http://localhost:4200");
+    await expect(cap.run("http://localhost:4200")).rejects.toThrow("cap run failed");
 
-    // adb kill-server should have been called between the two cap run attempts
+    // adb kill-server should have been called
     expect(
       execaCalls.some((c) => c.command === "adb" && c.args.includes("kill-server")),
     ).toBe(true);
-    expect(capRunCallCount).toBe(2);
-    expect(mockLoggerWarn).toHaveBeenCalledWith(
-      expect.stringContaining("adb kill-server"),
-    );
+    // cap run은 한 번만 호출 (재시도 없음)
+    expect(capRunCallCount).toBe(1);
   });
 
   // Unit: _updateServerUrl replaces existing url

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

@@ -26,8 +26,8 @@ vi.mock("@simplysm/core-node", () => ({
     copy: mockFsxCopy,
   },
   cpx: {
-    exec: mockCpxExec,
-    execSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
+    spawn: mockCpxSpawn,
+    spawnSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
   },
   pathx: {
     posixResolve: (...args: string[]) => path.resolve(...args).replace(/\\/g, "/"),
@@ -43,7 +43,7 @@ vi.mock("@simplysm/core-common", () => ({
 }));
 
 const execaCalls: { command: string; args: string[] }[] = [];
-const mockCpxExec = vi.fn((...args: unknown[]) => {
+const mockCpxSpawn = vi.fn((...args: unknown[]) => {
   execaCalls.push({ command: args[0] as string, args: (args[1] as string[] | undefined) ?? [] });
   return Promise.resolve({ stdout: "", stderr: "", exitCode: 0 });
 });
@@ -75,7 +75,9 @@ vi.mock("fs/promises", () => ({
 vi.mock("consola", () => ({
   consola: {
     withTag: () => ({ debug: vi.fn(), warn: vi.fn() }),
+    level: 0,
   },
+  LogLevels: { debug: 4 },
 }));
 
 //#endregion

package/tests/commands/check.spec.ts

@@ -37,8 +37,8 @@ vi.mock("../../src/utils/sd-config", () => ({
 
 vi.mock("@simplysm/core-node", () => ({
   cpx: {
-    exec: mocks.execa,
-    execSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
+    spawn: mocks.execa,
+    spawnSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
   },
 }));
 

package/tests/commands/device.spec.ts

@@ -0,0 +1,147 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Capacitor mock
+const mockCapacitorInstance = {
+  initialize: vi.fn().mockResolvedValue(undefined),
+  run: vi.fn().mockResolvedValue(undefined),
+  build: vi.fn().mockResolvedValue(undefined),
+};
+
+vi.mock("../../src/capacitor/capacitor", () => ({
+  Capacitor: {
+    create: vi.fn().mockResolvedValue(mockCapacitorInstance),
+  },
+}));
+
+// Electron mock
+const mockElectronInstance = {
+  initialize: vi.fn().mockResolvedValue(undefined),
+  run: vi.fn().mockResolvedValue(undefined),
+  build: vi.fn().mockResolvedValue(undefined),
+};
+
+vi.mock("../../src/electron/electron", () => ({
+  Electron: {
+    create: vi.fn().mockResolvedValue(mockElectronInstance),
+  },
+}));
+
+// loadSdConfig mock
+vi.mock("../../src/utils/sd-config", () => ({
+  loadSdConfig: vi.fn(),
+}));
+
+const { Capacitor } = await import("../../src/capacitor/capacitor");
+const { Electron } = await import("../../src/electron/electron");
+const { loadSdConfig } = await import("../../src/utils/sd-config");
+const { runDevice } = await import("../../src/commands/device");
+
+describe("runDevice", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockCapacitorInstance.run.mockResolvedValue(undefined);
+    mockElectronInstance.run.mockResolvedValue(undefined);
+  });
+
+  // Acceptance: Scenario "device 명령어로 Capacitor 앱 실행"
+  it("runs Capacitor.create + run when capacitor config exists", async () => {
+    vi.mocked(loadSdConfig).mockResolvedValue({
+      packages: {
+        "client-pda": {
+          target: "client",
+          server: 40480,
+          capacitor: { appId: "com.test.app", appName: "TestApp" },
+        },
+      },
+    });
+
+    await runDevice({ package: "client-pda", options: [] });
+
+    expect(Capacitor.create).toHaveBeenCalledWith(
+      expect.stringContaining("client-pda"),
+      { appId: "com.test.app", appName: "TestApp" },
+      undefined,
+    );
+    expect(mockCapacitorInstance.run).toHaveBeenCalledWith("http://localhost:40480");
+  });
+
+  // Acceptance: Scenario "device 명령어로 Electron 앱 실행"
+  it("runs Electron.create + run when electron config exists", async () => {
+    vi.mocked(loadSdConfig).mockResolvedValue({
+      packages: {
+        "my-client": {
+          target: "client",
+          server: 4200,
+          electron: { appId: "com.test.electron" },
+        },
+      },
+    });
+
+    await runDevice({ package: "my-client", options: [] });
+
+    expect(Electron.create).toHaveBeenCalledWith(
+      expect.stringContaining("my-client"),
+      { appId: "com.test.electron" },
+      undefined,
+    );
+    expect(mockElectronInstance.run).toHaveBeenCalledWith("http://localhost:4200");
+  });
+
+  // Acceptance: Scenario "device 명령어에 URL 옵션 지정"
+  it("uses provided URL instead of auto-generated one", async () => {
+    vi.mocked(loadSdConfig).mockResolvedValue({
+      packages: {
+        "client-pda": {
+          target: "client",
+          server: 40480,
+          capacitor: { appId: "com.test.app", appName: "TestApp" },
+        },
+      },
+    });
+
+    await runDevice({ package: "client-pda", url: "http://192.168.1.100:4200", options: [] });
+
+    expect(mockCapacitorInstance.run).toHaveBeenCalledWith("http://192.168.1.100:4200");
+  });
+
+  // Unit: electron이 capacitor보다 우선 (v13 동작)
+  it("prefers electron over capacitor when both are configured", async () => {
+    vi.mocked(loadSdConfig).mockResolvedValue({
+      packages: {
+        "my-client": {
+          target: "client",
+          server: 4200,
+          capacitor: { appId: "com.test.app", appName: "TestApp" },
+          electron: { appId: "com.test.electron" },
+        },
+      },
+    });
+
+    await runDevice({ package: "my-client", options: [] });
+
+    expect(Electron.create).toHaveBeenCalled();
+    expect(Capacitor.create).not.toHaveBeenCalled();
+  });
+
+  // Unit: 존재하지 않는 패키지 에러
+  it("throws when package does not exist", async () => {
+    vi.mocked(loadSdConfig).mockResolvedValue({
+      packages: {
+        "other-pkg": { target: "node" },
+      },
+    });
+
+    await expect(runDevice({ package: "nonexistent", options: [] })).rejects.toThrow();
+  });
+
+  // Unit: client가 아닌 패키지 에러
+  it("throws when package is not a client target", async () => {
+    vi.mocked(loadSdConfig).mockResolvedValue({
+      packages: {
+        "my-server": { target: "server" },
+      },
+    });
+
+    await expect(runDevice({ package: "my-server", options: [] })).rejects.toThrow();
+  });
+});

package/tests/commands/publish.spec.ts

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

package/tests/commands/typecheck.spec.ts

@@ -493,6 +493,14 @@ describe("executeTypecheck", () => {
 
   //#endregion
 
+  it("throws when loadSdConfig fails (fail fast)", async () => {
+    mocks.loadSdConfig.mockRejectedValue(new Error("sd.config.ts not found"));
+    mocks.discoverWorkspacePackages.mockReturnValue(new Map());
+    mocks.mergeTestsPackagesIntoConfig.mockReturnValue({ merged: {}, pathMap: new Map() });
+
+    await expect(executeTypecheck({ targets: [], options: [] })).rejects.toThrow("sd.config.ts not found");
+  });
+
   //#region Slice 1: executeTypecheck lint integration (Feature 3.2)
 
   describe("lint integration", () => {

package/tests/electron/electron.spec.ts

@@ -23,8 +23,8 @@ vi.mock("@simplysm/core-node", () => ({
     glob: mockFsxGlob,
   },
   cpx: {
-    exec: mockCpxExec,
-    execSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
+    spawn: mockCpxSpawn,
+    spawnSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
   },
   pathx: {
     posixResolve: (...args: string[]) => path.resolve(...args).replace(/\\/g, "/"),
@@ -33,7 +33,7 @@ vi.mock("@simplysm/core-node", () => ({
 }));
 
 // cpx mock (was execa)
-const mockCpxExec = vi.fn().mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
+const mockCpxSpawn = vi.fn().mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
 
 // esbuild mock
 const mockEsbuildBuild = vi.fn().mockResolvedValue({});
@@ -75,7 +75,9 @@ vi.mock("consola", () => ({
       warn: mockLoggerWarn,
       info: mockLoggerInfo,
     }),
+    level: 0,
   },
+  LogLevels: { debug: 4 },
 }));
 
 //#endregion
@@ -105,7 +107,7 @@ function setupDefaultMocks() {
     }
     return Promise.resolve([]);
   });
-  mockCpxExec.mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
+  mockCpxSpawn.mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
   mockEsbuildBuild.mockResolvedValue({});
 }
 
@@ -179,7 +181,7 @@ describe("Electron", () => {
 
       expect(findElectronPackageJson()).toBeDefined();
 
-      const execaCalls = mockCpxExec.mock.calls;
+      const execaCalls = mockCpxSpawn.mock.calls;
       expect(
         execaCalls.find((c) => c[0] === "npm" && (c[1] as string[]).includes("install")),
       ).toBeDefined();
@@ -196,7 +198,7 @@ describe("Electron", () => {
       const electron = await Electron.create(PKG_PATH, { appId: "com.test.app" });
       await electron.initialize();
 
-      const rebuildCall = mockCpxExec.mock.calls.find(
+      const rebuildCall = mockCpxSpawn.mock.calls.find(
         (c) => typeof c[0] === "string" && c[0].includes("electron-rebuild"),
       );
       expect(rebuildCall).toBeUndefined();
@@ -453,7 +455,7 @@ describe("Electron", () => {
       const electronKill = vi.fn();
       let resolveElectron: () => void = () => {};
 
-      mockCpxExec.mockImplementation((cmd: string) => {
+      mockCpxSpawn.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) => {
@@ -535,7 +537,7 @@ describe("Electron", () => {
   describe("단위: run() 플러그인 동작", () => {
     it("passes custom env and ELECTRON_DEV_URL via esbuild banner", async () => {
       let resolveElectron: () => void = () => {};
-      mockCpxExec.mockImplementation((cmd: string) => {
+      mockCpxSpawn.mockImplementation((cmd: string) => {
         if (typeof cmd === "string" && cmd.includes("electron")) {
           const p = new Promise<void>((resolve) => {
             resolveElectron = resolve;
@@ -568,7 +570,7 @@ describe("Electron", () => {
 
     it("calls initialize() before starting esbuild context", async () => {
       let resolveElectron: () => void = () => {};
-      mockCpxExec.mockImplementation((cmd: string) => {
+      mockCpxSpawn.mockImplementation((cmd: string) => {
         if (typeof cmd === "string" && cmd.includes("electron")) {
           const p = new Promise<void>((resolve) => {
             resolveElectron = resolve;
@@ -588,7 +590,7 @@ describe("Electron", () => {
       await runPromise;
 
       // initialize calls npm install -> execa should have been called with npm install
-      const npmInstallCall = mockCpxExec.mock.calls.find(
+      const npmInstallCall = mockCpxSpawn.mock.calls.find(
         (c: any[]) => c[0] === "npm" && (c[1] as string[]).includes("install"),
       );
       expect(npmInstallCall).toBeDefined();

package/tests/engines/base-engine.spec.ts

@@ -263,6 +263,43 @@ describe("BaseEngine", () => {
       await engine.stop();
     });
 
+    it("calls resolver on error event to release RebuildManager batch", async () => {
+      const mockResolver = vi.fn();
+      const mockRebuildManager = { registerBuild: vi.fn(() => mockResolver) };
+
+      mockWorker.startWatch.mockImplementation(() => {
+        // Trigger initial build to move past isInitialBuild
+        const buildHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "build",
+        )?.[1];
+        buildHandler?.({ build: { success: true } });
+      });
+
+      const engine = new TscEngine({
+        cwd: "/root",
+        pkg: createMockPkg(),
+        rebuildManager: mockRebuildManager as any,
+      });
+
+      await engine.startWatch({ js: true, dts: true });
+
+      // Simulate rebuild cycle: buildStart -> error (no build event)
+      const buildStartHandler = mockWorker.on.mock.calls.find(
+        (call: any[]) => call[0] === "buildStart",
+      )?.[1];
+      const errorHandler = mockWorker.on.mock.calls.find(
+        (call: any[]) => call[0] === "error",
+      )?.[1];
+
+      buildStartHandler?.({});
+      expect(mockRebuildManager.registerBuild).toHaveBeenCalled();
+
+      errorHandler?.({ message: "Worker crashed" });
+      expect(mockResolver).toHaveBeenCalled();
+
+      await engine.stop();
+    });
+
     it("uses _getTarget() for BuildResult target", async () => {
       const mockResultCollector = { add: vi.fn() };
 

package/tests/engines/vite-engine.spec.ts

@@ -191,6 +191,30 @@ describe("ViteEngine", () => {
       await engine.stop();
     });
 
+    // Acceptance: Scenario "exclude 전달 (build)"
+    it("passes exclude from config to worker build call", async () => {
+      mockWorker.build.mockResolvedValue({ success: true });
+
+      const engine = new ViteEngine({
+        cwd: "/root",
+        pkg: createMockPkg({
+          config: {
+            target: "client",
+            server: "my-server",
+            exclude: ["jeep-sqlite"],
+          } as any,
+        }),
+      });
+      await engine.run({ js: true, dts: false });
+
+      expect(mockWorker.build).toHaveBeenCalledWith(
+        expect.objectContaining({
+          exclude: ["jeep-sqlite"],
+        }),
+      );
+      await engine.stop();
+    });
+
     // Unit: build failure reflects in result
     it("reflects build failure in result", async () => {
       mockWorker.build.mockResolvedValue({
@@ -265,11 +289,18 @@ describe("ViteEngine", () => {
       await engine.stop();
     });
 
-    // Acceptance: Scenario "ResultCollector에 결과 보고"
-    it("reports build result to ResultCollector", async () => {
+    // Acceptance: Scenario "ResultCollector에 결과 보고 — build 이벤트 경유"
+    it("reports build result to ResultCollector via build event only", async () => {
       const mockResultCollector = { add: vi.fn() };
 
-      mockWorker.startWatch.mockResolvedValue({ success: true });
+      mockWorker.startWatch.mockImplementation(() => {
+        // Simulate "build" event during startWatch (Angular plugin buildStart)
+        const buildHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "build",
+        )?.[1];
+        buildHandler?.({ success: true });
+        return Promise.resolve({ success: true });
+      });
 
       const engine = new ViteEngine({
         cwd: "/root",
@@ -388,6 +419,32 @@ describe("ViteEngine", () => {
       await engine.stop();
     });
 
+    // Acceptance: Scenario "exclude 전달 (watch)"
+    it("passes exclude from config to worker startWatch call", async () => {
+      mockWorker.startWatch.mockResolvedValue({ success: true });
+
+      const engine = new ViteEngine({
+        cwd: "/root",
+        pkg: createMockPkg({
+          config: {
+            target: "client",
+            server: "my-server",
+            exclude: ["jeep-sqlite", "another-pkg"],
+          } as any,
+        }),
+      });
+
+      await engine.startWatch({ js: true, dts: false });
+
+      expect(mockWorker.startWatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          exclude: ["jeep-sqlite", "another-pkg"],
+        }),
+      );
+
+      await engine.stop();
+    });
+
     // Unit: server: string does not pass port
     it("does not pass port when config.server is a string", async () => {
       mockWorker.startWatch.mockResolvedValue({ success: true });
@@ -480,6 +537,61 @@ describe("ViteEngine", () => {
       await engine.stop();
     });
 
+    // Unit: mock worker가 serverReady를 발행하지 않으면 port가 undefined로 남는다
+    it("leaves port undefined when worker mock does not emit serverReady for legacyModule", async () => {
+      mockWorker.startWatch.mockResolvedValue({ success: true });
+
+      const engine = new ViteEngine({
+        cwd: "/root",
+        pkg: createMockPkg({
+          config: {
+            target: "client",
+            server: "my-server",
+            browserSupport: { legacyModule: true },
+          } as any,
+        }),
+      });
+
+      await engine.startWatch({ js: true, dts: false });
+
+      // serverReady is subscribed but never emitted — port stays undefined
+      expect(engine.port).toBeUndefined();
+
+      // buildStart/build event handlers are still registered
+      expect(mockWorker.on).toHaveBeenCalledWith("buildStart", expect.any(Function));
+      expect(mockWorker.on).toHaveBeenCalledWith("build", expect.any(Function));
+
+      await engine.stop();
+    });
+
+    // Unit: initial build result is reported exactly once (not duplicated by startWatch return)
+    it("reports initial build result exactly once to ResultCollector", async () => {
+      const mockResultCollector = { add: vi.fn() };
+
+      mockWorker.startWatch.mockImplementation(() => {
+        const buildHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "build",
+        )?.[1];
+        buildHandler?.({ success: true });
+        return Promise.resolve({ success: true });
+      });
+
+      const engine = new ViteEngine({
+        cwd: "/root",
+        pkg: createMockPkg(),
+        resultCollector: mockResultCollector as any,
+      });
+
+      await engine.startWatch({ js: true, dts: false });
+
+      const buildAddCalls = mockResultCollector.add.mock.calls.filter(
+        (c: any[]) => c[0].type === "build",
+      );
+      expect(buildAddCalls).toHaveLength(1);
+
+      await engine.stop();
+    });
+
     // Unit: error event reports to ResultCollector
     it("reports error from error event to ResultCollector", async () => {
       const mockResultCollector = { add: vi.fn() };