@simplysm/sd-cli 13.0.70 → 13.0.72

package/templates/init/tests/e2e/src/employee-crud.ts

@@ -0,0 +1,204 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import type { Page } from "playwright";
+
+export function employeeCrudTests(ctx: { page: Page; baseUrl: string }) {
+  describe("EmployeeSheet CRUD", () => {
+    const sheetSelector = '[data-sheet="employee-page-sheet"]';
+
+    function sheetRows() {
+      return ctx.page.locator(`${sheetSelector} tbody tr`);
+    }
+
+    function dialogLocator() {
+      return ctx.page.locator("[data-modal-dialog]").last();
+    }
+
+    async function waitForSheetLoaded() {
+      await sheetRows().first().waitFor({ timeout: 1000 });
+    }
+
+    async function waitForBusyDone() {
+      await ctx.page.waitForTimeout(50);
+      await ctx.page.waitForFunction(() => !document.querySelector(".animate-spin"));
+    }
+
+    async function waitForDialogClosed() {
+      await ctx.page.waitForFunction(
+        () =>
+          document.querySelectorAll("[data-modal-dialog]").length === 0 &&
+          document.querySelectorAll("[data-modal-backdrop]").length === 0,
+      );
+    }
+
+    async function assertNotification(text: string) {
+      const alert = ctx.page
+        .locator("[data-notification-banner]")
+        .filter({ hasText: text })
+        .first();
+      await alert.waitFor();
+      const closeButtons = ctx.page.locator(
+        '[data-notification-banner] button[aria-label="알림 닫기"]',
+      );
+      const count = await closeButtons.count();
+      for (let i = count - 1; i >= 0; i--) {
+        await closeButtons
+          .nth(i)
+          .click()
+          .catch(() => {});
+      }
+      await ctx.page.waitForFunction(
+        () => document.querySelectorAll("[data-notification-banner]").length === 0,
+      );
+    }
+
+    async function clickSearch() {
+      await ctx.page.getByRole("button", { name: "조회" }).click();
+      await waitForBusyDone();
+    }
+
+    async function clickAdd() {
+      await ctx.page.getByRole("button", { name: /등록/ }).click();
+      await dialogLocator().waitFor();
+    }
+
+    async function clickEditRow(rowIndex: number) {
+      await sheetRows().nth(rowIndex).locator("a").first().click();
+      await dialogLocator().waitFor();
+      await waitForBusyDone();
+    }
+
+    async function fillDialogField(label: string, value: string) {
+      const dlg = dialogLocator();
+      const th = dlg.locator("th").filter({ hasText: label });
+      const td = th.locator("xpath=following-sibling::td[1]");
+      const field = td.locator("input:not([aria-hidden])").first();
+      await field.fill(value);
+    }
+
+    async function clickDialogSubmit() {
+      await dialogLocator().getByRole("button", { name: "확인" }).click();
+    }
+
+    async function closeDialog() {
+      await ctx.page.keyboard.press("Escape");
+      await waitForDialogClosed();
+    }
+
+    beforeAll(async () => {
+      await ctx.page.goto(`${ctx.baseUrl}/#/home/base/employee`);
+      await waitForSheetLoaded();
+    });
+
+    describe("Create", () => {
+      it("새 직원 등록", async () => {
+        await clickAdd();
+
+        await fillDialogField("이름", "E2E테스트유저");
+        await fillDialogField("이메일", "e2e@test.com");
+
+        await clickDialogSubmit();
+        await assertNotification("저장되었습니다");
+        await waitForDialogClosed();
+        await clickSearch();
+
+        const firstCell = sheetRows().first().locator("td").nth(1);
+        await expect(firstCell.textContent()).resolves.toContain("E2E테스트유저");
+      });
+    });
+
+    describe("Read / Filter", () => {
+      it("검색어 필터링", async () => {
+        const searchInput = ctx.page.locator("form").first().locator("input").first();
+        await searchInput.fill("E2E테스트");
+        await clickSearch();
+
+        const rowCount = await sheetRows().count();
+        expect(rowCount).toBe(1);
+        await expect(sheetRows().first().locator("td").nth(1).textContent()).resolves.toContain(
+          "E2E테스트유저",
+        );
+
+        await searchInput.fill("");
+        await clickSearch();
+        const allRowCount = await sheetRows().count();
+        expect(allRowCount).toBe(2);
+      });
+    });
+
+    describe("Update", () => {
+      it("기존 유저 이름 수정", async () => {
+        await clickEditRow(0);
+
+        await fillDialogField("이름", "E2E수정유저");
+
+        await clickDialogSubmit();
+        await assertNotification("저장되었습니다");
+        await waitForDialogClosed();
+        await clickSearch();
+
+        await expect(sheetRows().first().locator("td").nth(1).textContent()).resolves.toContain(
+          "E2E수정유저",
+        );
+      });
+    });
+
+    describe("Delete", () => {
+      it("유저 soft delete", async () => {
+        await clickEditRow(0);
+
+        await dialogLocator().getByRole("button", { name: "삭제" }).click();
+        await assertNotification("삭제되었습니다");
+        await waitForDialogClosed();
+        await clickSearch();
+
+        const rowCount = await sheetRows().count();
+        expect(rowCount).toBe(1);
+        await expect(sheetRows().first().locator("td").nth(1).textContent()).resolves.toContain(
+          "테스트",
+        );
+      });
+
+      it("삭제항목 포함 필터로 삭제된 유저 확인", async () => {
+        await ctx.page.getByText("삭제항목 포함").click();
+        await clickSearch();
+
+        const rowCount = await sheetRows().count();
+        expect(rowCount).toBe(2);
+
+        await ctx.page.getByText("삭제항목 포함").click();
+        await clickSearch();
+      });
+    });
+
+    describe("Error cases", () => {
+      it("이름 중복 에러", async () => {
+        await clickAdd();
+        await fillDialogField("이름", "테스트");
+        await clickDialogSubmit();
+        await assertNotification("동일한 이름이 이미 등록되어 있습니다");
+
+        await closeDialog();
+      });
+
+      it("이메일 중복 에러", async () => {
+        await clickAdd();
+        await fillDialogField("이름", "고유이름");
+        await fillDialogField("이메일", "admin@test.com");
+        await clickDialogSubmit();
+        await assertNotification("동일한 이메일이 이미 등록되어 있습니다");
+
+        await closeDialog();
+      });
+
+      it("자기 자신 삭제 불가", async () => {
+        await clickEditRow(0);
+        await waitForBusyDone();
+
+        const deleteBtn = dialogLocator().getByRole("button", { name: "삭제" });
+        expect(await deleteBtn.count()).toBe(0);
+
+        await closeDialog();
+      });
+    });
+  });
+}

package/templates/init/tests/e2e/src/login.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import type { Page } from "playwright";
+
+export function loginTests(ctx: { page: Page; baseUrl: string }) {
+  describe("Login", () => {
+    it("/ 접속 시 /login으로 리다이렉트", async () => {
+      await ctx.page.goto(`${ctx.baseUrl}/`, { timeout: 5000 });
+      await ctx.page.waitForURL(`${ctx.baseUrl}/#/login`);
+      await expect(
+        ctx.page.getByRole("button", { name: "로그인" }).textContent(),
+      ).resolves.toContain("로그인");
+    });
+
+    it("토큰 없이 /home/main 접근 시 /login으로 리다이렉트", async () => {
+      await ctx.page.goto(`${ctx.baseUrl}/#/home/main`);
+      await ctx.page.waitForURL(`${ctx.baseUrl}/#/login`);
+      await expect(
+        ctx.page.getByRole("button", { name: "로그인" }).textContent(),
+      ).resolves.toContain("로그인");
+    });
+
+    it("틀린 비밀번호 시 에러 메시지", async () => {
+      await ctx.page.getByPlaceholder("이메일을 입력하세요").fill("admin@test.com");
+      await ctx.page.getByPlaceholder("비밀번호를 입력하세요").fill("wrongpassword");
+      await ctx.page.getByRole("button", { name: "로그인" }).click();
+
+      const notification = ctx.page.getByRole("alert");
+      await notification.waitFor({ timeout: 1000 });
+      await expect(notification.textContent()).resolves.toContain(
+        "이메일 또는 비밀번호가 올바르지 않습니다",
+      );
+    });
+
+    it("올바른 자격 증명으로 로그인 성공", async () => {
+      await ctx.page.goto(`${ctx.baseUrl}/#/login`);
+      await ctx.page.getByRole("button", { name: "로그인" }).waitFor({ timeout: 2000 });
+
+      await ctx.page.getByPlaceholder("이메일을 입력하세요").fill("admin@test.com");
+      await ctx.page.getByPlaceholder("비밀번호를 입력하세요").fill("test1234");
+      await ctx.page.getByRole("button", { name: "로그인" }).click({ timeout: 2000 });
+
+      await ctx.page.waitForURL(`${ctx.baseUrl}/#/home/main`, { timeout: 2000 });
+      const mainContent = ctx.page.locator("main").last();
+      await expect(mainContent.locator("h1").textContent()).resolves.toContain("테스트");
+    });
+
+    it("마지막 로그인 이메일 기억", async () => {
+      const lastLoginEmail = await ctx.page.evaluate(() =>
+        JSON.parse(localStorage.getItem("client-admin.last-login-email") ?? "null"),
+      );
+      expect(lastLoginEmail).toBe("admin@test.com");
+    });
+
+    it("페이지 새로고침 시 자동 로그인", async () => {
+      await ctx.page.reload();
+      await ctx.page.waitForURL(`${ctx.baseUrl}/#/home/main`, { timeout: 2000 });
+      const mainContent = ctx.page.locator("main").last();
+      await expect(mainContent.locator("h1").textContent()).resolves.toContain("테스트");
+    });
+  });
+}

package/templates/init/tests/e2e/vitest.setup.ts.hbs

@@ -0,0 +1,220 @@
+import { type ChildProcess, spawn, execSync } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+import { createDbConn, createOrm } from "@simplysm/orm-node";
+import { MainDbContext } from "@{{projectName}}/db-main";
+import bcrypt from "bcrypt";
+import { chromium } from "playwright";
+import type { TestProject } from "vitest/node";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.resolve(__dirname, "../..");
+
+const DB_CONFIG = {
+  dialect: "postgresql" as const,
+  host: "localhost",
+  port: 5432,
+  username: "postgres",
+  password: "1234",
+  database: "{{projectName}}-test",
+};
+
+const TEST_USER = {
+  name: "테스트",
+  email: "admin@test.com",
+  password: "test1234",
+};
+
+let devServerProcess: ChildProcess | undefined;
+
+function killProcessTree(proc: ChildProcess): void {
+  if (proc.pid == null) return;
+  try {
+    if (process.platform === "win32") {
+      execSync(`taskkill /T /F /PID ${proc.pid}`, { stdio: "ignore" });
+    } else {
+      process.kill(-proc.pid, "SIGTERM");
+    }
+  } catch {
+    /* 무시 */
+  }
+}
+
+function stripAnsi(str: string): string {
+  return str.replace(/\x1B\[[0-9;]*m/g, "");
+}
+
+function waitForServerUrl(process: ChildProcess, timeout: number): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let output = "";
+
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        reject(
+          new Error(`dev 서버 URL 대기 시간 초과 (${timeout}ms)\n출력:\n${output.slice(-2000)}`),
+        );
+      }
+    }, timeout);
+
+    function onData(data: Buffer) {
+      const text = stripAnsi(data.toString());
+      console.log(text);
+      output += text;
+
+      const urlMatch = text.match(/http:\/\/localhost:\d+\/client-admin\/?/);
+      if (urlMatch && !settled) {
+        settled = true;
+        clearTimeout(timer);
+        resolve(urlMatch[0].endsWith("/") ? urlMatch[0].slice(0, -1) : urlMatch[0]);
+      }
+    }
+
+    process.stdout?.on("data", onData);
+    process.stderr?.on("data", onData);
+
+    process.on("exit", (code) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        reject(
+          new Error(`dev 서버가 비정상 종료됨 (code: ${code})\n출력:\n${output.slice(-2000)}`),
+        );
+      }
+    });
+  });
+}
+
+async function warmup(baseUrl: string, timeout: number): Promise<void> {
+  const browser = await chromium.launch({ headless: true });
+  try {
+    const page = await browser.newPage();
+    await page.goto(baseUrl, { timeout });
+
+    const result = await Promise.race([
+      page
+        .locator(".app-loading")
+        .waitFor({ state: "detached", timeout })
+        .then(() => "ready" as const),
+      page
+        .locator("vite-error-overlay")
+        .waitFor({ state: "attached", timeout })
+        .then(async () => {
+          const errorText = await page
+            .locator("vite-error-overlay")
+            .evaluate((el) => el.shadowRoot?.textContent ?? "");
+          return `error:${errorText}` as const;
+        }),
+    ]);
+
+    if (result.startsWith("error:")) {
+      throw new Error(`Vite 빌드 에러:\n${result.slice(6).slice(0, 2000)}`);
+    }
+  } finally {
+    await browser.close();
+  }
+}
+
+export async function setup(project: TestProject) {
+  // 1. 테스트 DB 생성 (없으면)
+  console.log("[e2e] 테스트 DB 확인...");
+  const adminConn = await createDbConn({ ...DB_CONFIG, database: "postgres" });
+  await adminConn.connect();
+  try {
+    const result = await adminConn.executeParametrized(
+      `SELECT 1 FROM pg_database WHERE datname = $1`,
+      [DB_CONFIG.database],
+    );
+    if (result[0].length === 0) {
+      await adminConn.execute([`CREATE DATABASE "${DB_CONFIG.database}"`]);
+      console.log(`[e2e] DB "${DB_CONFIG.database}" 생성됨.`);
+    } else {
+      console.log(`[e2e] DB "${DB_CONFIG.database}" 이미 존재.`);
+    }
+  } finally {
+    await adminConn.close();
+  }
+
+  // 2. DB 초기화 및 시딩
+  const orm = createOrm(MainDbContext, DB_CONFIG);
+  await orm.connectWithoutTransaction(async (db) => {
+    await db.initialize({ force: true });
+
+    // 권한그룹 생성
+    await db.role().insert([{ name: "관리자" }]);
+    const role = (await db.role().first())!;
+
+    // 전체 권한 부여
+    await db.rolePermission().insert([
+      { roleId: role.id, code: "/home/base/employee/use", valueJson: "true" },
+      { roleId: role.id, code: "/home/base/employee/edit", valueJson: "true" },
+      { roleId: role.id, code: "/home/base/employee/auth/use", valueJson: "true" },
+      { roleId: role.id, code: "/home/base/employee/auth/edit", valueJson: "true" },
+      { roleId: role.id, code: "/home/base/employee/personal/use", valueJson: "true" },
+      { roleId: role.id, code: "/home/base/employee/personal/edit", valueJson: "true" },
+      { roleId: role.id, code: "/home/base/employee/payroll/use", valueJson: "true" },
+      { roleId: role.id, code: "/home/base/employee/payroll/edit", valueJson: "true" },
+    ]);
+
+    // 테스트 유저 생성 (roleId 포함)
+    const encryptedPassword = await bcrypt.hash(TEST_USER.password, 10);
+    await db.employee().insert([
+      {
+        name: TEST_USER.name,
+        email: TEST_USER.email,
+        encryptedPassword,
+        roleId: role.id,
+        isDeleted: false,
+      },
+    ]);
+  });
+  console.log("[e2e] DB 초기화 및 시딩 완료.");
+
+  // 3. dev 서버 시작
+  console.log("[e2e] dev 서버 시작...");
+  devServerProcess = spawn("node", ["node_modules/@simplysm/sd-cli/dist/sd-cli.js", "dev"], {
+    cwd: rootDir,
+    stdio: "pipe",
+    ...(process.platform !== "win32" ? { detached: true } : {}),
+    env: {
+      ...process.env,
+      DB_DATABASE: DB_CONFIG.database,
+      DB_PORT: String(DB_CONFIG.port),
+      NODE_ENV: undefined, // consola가 콘솔을 강제로 warn이상으로 설정하지 못하도록 하기 위함
+      TEST: undefined, // consola가 콘솔을 강제로 warn이상으로 설정하지 못하도록 하기 위함
+    },
+  });
+
+  let baseUrl: string;
+  try {
+    // 4. stdout에서 URL 파싱 (90초 타임아웃)
+    baseUrl = await waitForServerUrl(devServerProcess, 90_000);
+    console.log(`[e2e] dev 서버 URL 감지: ${baseUrl}`);
+
+    // 5. Playwright warmup — Vite 빌드 트리거 및 에러 감지 (60초 타임아웃)
+    console.log("[e2e] Vite 빌드 warmup...");
+    await warmup(baseUrl, 60_000);
+    console.log("[e2e] warmup 완료. 테스트 시작 준비됨.");
+
+    project.provide("baseUrl", baseUrl);
+  } catch (err) {
+    killProcessTree(devServerProcess);
+    devServerProcess = undefined;
+    throw err;
+  }
+}
+
+export function teardown() {
+  if (devServerProcess != null) {
+    console.log("[e2e] dev 서버 종료...");
+    killProcessTree(devServerProcess);
+    devServerProcess = undefined;
+  }
+}
+
+declare module "vitest" {
+  export interface ProvidedContext {
+    baseUrl: string;
+  }
+}

package/templates/init/tsconfig.json.hbs

@@ -1,16 +1,11 @@
 {
   "compilerOptions": {
-    // 출력
     "target": "ESNext",
     "module": "ESNext",
     "lib": ["ESNext", "DOM", "DOM.Iterable", "WebWorker"],
     "moduleResolution": "bundler",
-
-    // JSX (SolidJS)
     "jsx": "preserve",
     "jsxImportSource": "solid-js",
-
-    // Strict
     "strict": true,
     "noImplicitOverride": true,
     "noImplicitReturns": true,
@@ -20,19 +15,13 @@
     "noPropertyAccessFromIndexSignature": true,
     "forceConsistentCasingInFileNames": true,
     "useDefineForClassFields": true,
-
-    // 모듈
     "esModuleInterop": true,
     "verbatimModuleSyntax": true,
-
-    // 빌드
     "declaration": true,
     "declarationMap": true,
     "sourceMap": true,
     "skipLibCheck": true,
     "importHelpers": true,
-
-    // 경로
     "baseUrl": ".",
     "paths": {
       "@{{projectName}}/*": ["packages/*/src/index.ts"]

package/templates/init/{vitest.config.ts.hbs → vitest.config.ts}

@@ -1,6 +1,10 @@
+import path from "path";
+import { fileURLToPath } from "url";
 import { defineConfig } from "vitest/config";
 import tsconfigPaths from "vite-tsconfig-paths";
 
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
 export default defineConfig({
   plugins: [
     tsconfigPaths({
@@ -24,22 +28,22 @@ export default defineConfig({
       {
         extends: true,
         test: {
-          name: "unit",
-          include: ["packages/*/tests/**/*.spec.{ts,tsx}"],
+          name: "node",
+          include: ["packages/*/tests/**/*.spec.{ts,tsx,js}"],
           testTimeout: 30000,
         },
       },
       // E2E 테스트 (Docker + dev 서버 필요)
-      // {
-      //   extends: true,
-      //   test: {
-      //     name: "e2e",
-      //     include: ["tests/e2e/src/**/*.spec.ts"],
-      //     globalSetup: "./tests/e2e/vitest.setup.ts",
-      //     fileParallelism: false,
-      //     testTimeout: 30000,
-      //   },
-      // },
+      {
+        extends: true,
+        test: {
+          name: "e2e",
+          include: ["tests/e2e/src/**/*.spec.ts"],
+          globalSetup: "./tests/e2e/vitest.setup.ts",
+          fileParallelism: false,
+          testTimeout: 30000,
+        },
+      },
     ],
   },
 });

package/tests/infra/WorkerManager.spec.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { WorkerManager } from "../../src/infra/WorkerManager";
 
-// Worker 모킹
+// Mock Worker
 vi.mock("@simplysm/core-node", () => ({
   Worker: {
     create: vi.fn(() => ({

package/tests/replace-deps.spec.ts

@@ -258,12 +258,12 @@ describe("watchReplaceDeps", () => {
   beforeEach(async () => {
     tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "sd-watch-replace-"));
 
-    // 소스 패키지 (simplysm/packages/solid)
+    // Source package (simplysm/packages/solid)
     const sourceDir = path.join(tmpDir, "simplysm", "packages", "solid");
     await fs.promises.mkdir(sourceDir, { recursive: true });
     await fs.promises.writeFile(path.join(sourceDir, "index.js"), "export default 1;");
 
-    // 대상 프로젝트 (.pnpm 스토어 방식)
+    // Target project (.pnpm store style)
     const appRoot = path.join(tmpDir, "app");
     const pnpmStoreTarget = path.join(
       appRoot,

package/tests/run-lint.spec.ts

@@ -11,7 +11,7 @@ const { mockState, mockJitiImportFn } = vi.hoisted(() => ({
   mockJitiImportFn: vi.fn(),
 }));
 
-// 외부 의존성 모킹
+// Mock external dependencies
 
 vi.mock("eslint", () => {
   class MockESLint {
@@ -94,7 +94,7 @@ describe("runLint", () => {
     originalCwd = process.cwd;
     process.cwd = vi.fn().mockReturnValue("/project");
 
-    // 상태 초기화
+    // Reset state
     mockState.lintResults = [];
     mockState.lintedFiles = [];
     mockState.outputFixesCalled = false;
@@ -237,7 +237,7 @@ describe("runLint", () => {
 
     await runLint({ targets: [], fix: false, timing: false });
 
-    // ESLint가 호출되지 않으므로 lintedFiles는 빈 배열 유지
+    // ESLint is not called, so lintedFiles stays empty
     expect(mockState.lintedFiles).toHaveLength(0);
     expect(process.exitCode).toBeUndefined();
   });
@@ -293,7 +293,7 @@ describe("runLint", () => {
 
     await runLint({ targets: [], fix: false, timing: true });
 
-    // TIMING이 설정되었는지 확인 (함수 내에서 설정됨)
+    // Verify TIMING is set (set inside the function)
     expect(process.env["TIMING"]).toBe("1");
 
     // cleanup
@@ -350,12 +350,12 @@ describe("executeLint", () => {
     originalCwd = process.cwd;
     process.cwd = vi.fn().mockReturnValue("/project");
 
-    // 상태 초기화
+    // Reset state
     mockState.lintResults = [];
     mockState.lintedFiles = [];
     mockState.outputFixesCalled = false;
 
-    // 기본 ESLint 설정 mock
+    // Default ESLint config mock
     const cwd = "/project";
     vi.mocked(fsExists).mockImplementation((filePath: string) => {
       return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));

package/tests/run-typecheck.spec.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
 import "@simplysm/core-common"; // Import to use Map.getOrCreate extension method
 
-// 외부 의존성 모킹
+// Mock external dependencies
 vi.mock("typescript", () => {
   const DiagnosticCategory = {
     Error: 1,
@@ -194,7 +194,7 @@ describe("runTypecheck", () => {
       options: [],
     });
 
-    // Worker를 통해 실행되므로 exitCode가 설정되지 않아야 함
+    // Runs via Worker, so exitCode should not be set
     expect(process.exitCode).toBeUndefined();
   });
 
@@ -393,7 +393,7 @@ describe("runTypecheck", () => {
     vi.mocked(fsExists).mockResolvedValue(false);
     vi.mocked(fsReadJson).mockResolvedValue({ devDependencies: {} });
 
-    // Worker가 에러 결과를 반환하도록 모킹
+    // Mock Worker to return error results
     const { Worker } = await import("@simplysm/core-node");
     vi.mocked(Worker.create).mockReturnValue({
       build: vi.fn(() =>

package/tests/sd-cli.spec.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
 import { consola, LogLevels } from "consola";
 
-// runLint, runTypecheck, runWatch, runCheck를 모킹
+// Mock runLint, runTypecheck, runWatch, runCheck
 vi.mock("../src/commands/lint", () => ({
   runLint: vi.fn(),
 }));