@simplysm/sd-cli 13.0.100 → 14.0.1

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

@@ -1,4 +1,3 @@
-import proxy from "@fastify/http-proxy";
 import { createWorker } from "@simplysm/core-node";
 import { err as errNs } from "@simplysm/core-common";
 import { consola } from "consola";
@@ -13,7 +12,8 @@ import { registerCleanupHandlers, applyDebugLevel } from "../utils/worker-utils"
  */
 export interface ServerRuntimeStartInfo {
   mainJsPath: string;
-  clientPorts: Record<string, number>;
+  /** Client Vite dev server ports for @fastify/http-proxy registration */
+  clientPorts?: Record<string, number>;
   env?: Record<string, string>;
 }
 
@@ -108,7 +108,7 @@ async function findAvailablePort(startPort: number, maxRetries = 20): Promise<nu
 
 /**
  * Start Server Runtime
- * Import main.js, configure Vite proxy, then listen
+ * Import main.js, then listen
  */
 async function start(info: ServerRuntimeStartInfo): Promise<void> {
   try {
@@ -135,6 +135,20 @@ async function start(info: ServerRuntimeStartInfo): Promise<void> {
     // Save server instance (for cleanup)
     serverInstance = server;
 
+    // Register client proxies (before listen)
+    if (info.clientPorts != null && Object.keys(info.clientPorts).length > 0) {
+      const { default: proxy } = await import("@fastify/http-proxy");
+      for (const [name, port] of Object.entries(info.clientPorts)) {
+        logger.debug(`[start] Registering proxy: /${name} -> http://127.0.0.1:${String(port)}`);
+        await server.fastify.register(proxy, {
+          prefix: `/${name}`,
+          upstream: `http://127.0.0.1:${port}`,
+          rewritePrefix: `/${name}`,
+          websocket: true,
+        });
+      }
+    }
+
     // Find available port (auto-increment on port conflict)
     logger.debug("[start] Finding available port...");
     stepStart = performance.now();
@@ -148,29 +162,6 @@ async function start(info: ServerRuntimeStartInfo): Promise<void> {
       `[start] Port ${String(availablePort)} available (${Math.round(performance.now() - stepStart)}ms)`,
     );
 
-    // Configure Vite proxy (only if clientPorts exists)
-    const clientEntries = Object.entries(info.clientPorts);
-    if (clientEntries.length > 0) {
-      logger.debug(
-        `[start] Configuring ${String(clientEntries.length)} Vite proxy(s)...`,
-      );
-      stepStart = performance.now();
-    }
-    for (const [name, port] of clientEntries) {
-      logger.debug(`[start] Registering proxy: /${name} -> http://127.0.0.1:${String(port)}`);
-      await server.fastify.register(proxy, {
-        prefix: `/${name}`,
-        upstream: `http://127.0.0.1:${port}`,
-        rewritePrefix: `/${name}`,
-        websocket: true,
-      });
-    }
-    if (clientEntries.length > 0) {
-      logger.debug(
-        `[start] Proxies configured (${Math.round(performance.now() - stepStart)}ms)`,
-      );
-    }
-
     // Start server
     logger.debug("[start] Starting server listen...");
     stepStart = performance.now();

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

@@ -0,0 +1,252 @@
+import path from "path";
+import fs from "node:fs";
+import { createWorker } from "@simplysm/core-node";
+import { err as errNs } from "@simplysm/core-common";
+import { consola } from "consola";
+import { registerCleanupHandlers, applyDebugLevel } from "../utils/worker-utils";
+import {
+  buildApplicationInternal,
+  createAngularBuilderContext,
+  normalizeDevServerOptions,
+  ResultKind,
+  serveWithVite,
+  type ApplicationBuilderOptions,
+  type ResultFile,
+} from "../utils/angular-build";
+import type { BuildOutput } from "../engines/types";
+
+applyDebugLevel();
+
+//#region Types (re-export for worker interface)
+
+export interface ViteBuildInfo {
+  name: string;
+  cwd: string;
+  pkgDir: string;
+  output: BuildOutput;
+  /** Vite dev server port (standalone clients with server: number) */
+  port?: number;
+}
+
+export interface ViteBuildResult {
+  js: { success: boolean; errors?: string[]; warnings?: string[] };
+  dts: { success: boolean; errors?: string[]; diagnostics: never[] };
+}
+
+export interface ViteCombinedBuildEvent {
+  js: { success: boolean; errors?: string[]; warnings?: string[] };
+  dts: { success: boolean; errors?: string[] };
+}
+
+export interface ViteBuildWorkerEvents extends Record<string, unknown> {
+  buildStart: Record<string, never>;
+  build: ViteCombinedBuildEvent;
+  error: { message: string };
+  serverReady: { port: number };
+}
+
+//#endregion
+
+//#region Resource Management
+
+const logger = consola.withTag("sd:cli:vite-build:worker");
+
+let abortController: AbortController | undefined;
+
+function cleanup(): void {
+  abortController?.abort();
+  abortController = undefined;
+}
+
+registerCleanupHandlers(cleanup, logger);
+
+//#endregion
+
+//#region Helpers
+
+function formatResultMessage(msg: {
+  text: string;
+  location?: { file: string; line: number; column: number } | null;
+}): string {
+  if (msg.location != null) {
+    return `${msg.location.file}:${String(msg.location.line)}:${String(msg.location.column)} - ${msg.text}`;
+  }
+  return msg.text;
+}
+
+function createBuildOptions(info: ViteBuildInfo): ApplicationBuilderOptions {
+  return {
+    tsConfig: path.join(info.pkgDir, "tsconfig.json"),
+    browser: "src/main.ts",
+    index: "src/index.html",
+    outputPath: path.join(info.pkgDir, "dist"),
+    aot: true,
+  };
+}
+
+async function writeResultFiles(
+  files: Record<string, ResultFile>,
+  outputPath: string,
+): Promise<void> {
+  await fs.promises.rm(outputPath, { recursive: true, force: true });
+
+  for (const [filePath, file] of Object.entries(files)) {
+    const fullPath = path.join(outputPath, filePath);
+    await fs.promises.mkdir(path.dirname(fullPath), { recursive: true });
+
+    if (file.origin === "memory") {
+      await fs.promises.writeFile(fullPath, (file as any).contents);
+    } else {
+      await fs.promises.copyFile((file as any).inputPath, fullPath);
+    }
+  }
+}
+
+//#endregion
+
+//#region build (one-time production build)
+
+async function build(info: ViteBuildInfo): Promise<ViteBuildResult> {
+  const buildOptions = createBuildOptions(info);
+  const projectRoot = path.relative(info.cwd, info.pkgDir);
+  const outputPath = path.join(info.pkgDir, "dist");
+
+  const context = createAngularBuilderContext({
+    workspaceRoot: info.cwd,
+    projectName: info.name,
+    projectRoot,
+    buildOptions: buildOptions as unknown as Record<string, unknown>,
+  });
+
+  try {
+    for await (const result of buildApplicationInternal(
+      buildOptions,
+      context as any,
+    )) {
+      if (result.kind === ResultKind.Failure) {
+        const errors = result.errors.map(formatResultMessage);
+        const warnings = result.warnings?.map(formatResultMessage);
+        return {
+          js: { success: false, errors, warnings },
+          dts: { success: true, diagnostics: [] as never[] },
+        };
+      }
+
+      if (result.kind === ResultKind.Full) {
+        await writeResultFiles(result.files, outputPath);
+
+        const warnings = result.warnings?.map(formatResultMessage);
+        return {
+          js: { success: true, warnings },
+          dts: { success: true, diagnostics: [] as never[] },
+        };
+      }
+    }
+
+    return {
+      js: { success: false, errors: ["No build result received from buildApplicationInternal"] },
+      dts: { success: true, diagnostics: [] as never[] },
+    };
+  } catch (err) {
+    return {
+      js: { success: false, errors: [errNs.message(err)] },
+      dts: { success: true, diagnostics: [] as never[] },
+    };
+  } finally {
+    await context.disposeTeardowns();
+  }
+}
+
+//#endregion
+
+//#region startWatch / stopWatch
+
+const guardStartWatch = (() => {
+  let called = false;
+  return () => {
+    if (called) throw new Error("startWatch() already called");
+    called = true;
+  };
+})();
+
+async function startWatch(info: ViteBuildInfo): Promise<void> {
+  guardStartWatch();
+
+  abortController = new AbortController();
+  const buildOptions = createBuildOptions(info);
+  const projectRoot = path.relative(info.cwd, info.pkgDir);
+
+  const context = createAngularBuilderContext({
+    workspaceRoot: info.cwd,
+    projectName: info.name,
+    projectRoot,
+    buildOptions: buildOptions as unknown as Record<string, unknown>,
+  });
+
+  try {
+    const serverOptions = await normalizeDevServerOptions(
+      context as any,
+      info.name,
+      {
+        buildTarget: `${info.name}:build`,
+        hmr: true,
+        liveReload: true,
+        ...(info.port != null ? { port: info.port } : {}),
+      } as any,
+    );
+
+    let isInitialBuild = true;
+
+    for await (const output of serveWithVite(
+      serverOptions,
+      "@angular/build:application",
+      buildApplicationInternal as any,
+      context as any,
+    )) {
+      if (isInitialBuild) {
+        isInitialBuild = false;
+
+        // Extract port from dev server output
+        try {
+          const url = new URL(output.baseUrl);
+          const port = parseInt(url.port, 10);
+          if (!isNaN(port)) {
+            sender.send("serverReady", { port });
+          }
+        } catch {
+          // URL parsing failed — skip port reporting
+        }
+
+        sender.send("build", {
+          js: { success: output.success },
+          dts: { success: true },
+        });
+      } else {
+        sender.send("buildStart", {});
+        sender.send("build", {
+          js: { success: output.success },
+          dts: { success: true },
+        });
+      }
+    }
+  } catch (err) {
+    // AbortError is expected when stopWatch is called
+    if (!(err instanceof Error && err.name === "AbortError")) {
+      sender.send("error", { message: errNs.message(err) });
+    }
+  } finally {
+    await context.disposeTeardowns();
+  }
+}
+
+function stopWatch(): void {
+  cleanup();
+}
+
+//#endregion
+
+const sender = createWorker<
+  { build: typeof build; startWatch: typeof startWatch; stopWatch: typeof stopWatch },
+  ViteBuildWorkerEvents
+>({ build, startWatch, stopWatch });
+export default sender;

package/tests/commands/check.spec.ts

@@ -0,0 +1,276 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  executeTypecheck: vi.fn(),
+  lintWorkerLint: vi.fn(),
+  lintWorkerTerminate: vi.fn(async () => {}),
+  workerCreate: vi.fn(),
+  execa: vi.fn(),
+  loadSdConfig: vi.fn(),
+}));
+
+vi.mock("../../src/commands/typecheck", () => ({
+  executeTypecheck: mocks.executeTypecheck,
+}));
+
+vi.mock("@simplysm/core-node", () => ({
+  Worker: {
+    create: mocks.workerCreate,
+  },
+}));
+
+vi.mock("@simplysm/core-common", () => ({
+  err: { message: (e: unknown) => (e instanceof Error ? e.message : String(e)) },
+  SdError: class SdError extends Error {
+    constructor(message: string) {
+      super(message);
+      this.name = "SdError";
+    }
+  },
+}));
+
+vi.mock("../../src/utils/sd-config", () => ({
+  loadSdConfig: mocks.loadSdConfig,
+}));
+
+vi.mock("execa", () => ({
+  execa: mocks.execa,
+}));
+
+vi.mock("consola", () => {
+  const fns = (): Record<string, unknown> => ({
+    debug: vi.fn(), start: vi.fn(), success: vi.fn(),
+    info: vi.fn(), error: vi.fn(), warn: vi.fn(), log: vi.fn(),
+    withTag: vi.fn(() => fns()),
+    level: 0,
+  });
+  const c = fns();
+  return { consola: c, default: c, LogLevels: {} };
+});
+
+const { runCheck } = await import("../../src/commands/check");
+
+describe("runCheck", () => {
+  let savedExitCode: string | number | undefined;
+  let writeSpy: ReturnType<typeof vi.spyOn>;
+  let stdoutOutput: string;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    savedExitCode = process.exitCode;
+    process.exitCode = undefined;
+    stdoutOutput = "";
+    writeSpy = vi.spyOn(process.stdout, "write").mockImplementation((chunk: unknown) => {
+      stdoutOutput += String(chunk);
+      return true;
+    });
+
+    // Default: sdConfig with 3 packages
+    mocks.loadSdConfig.mockResolvedValue({
+      packages: {
+        "core-node": { target: "node" },
+        "core-common": { target: "neutral" },
+        "storage": { target: "node" },
+      },
+    });
+
+    // Default: all pass
+    mocks.executeTypecheck.mockResolvedValue({
+      success: true, errorCount: 0, warningCount: 0, formattedOutput: "",
+    });
+    mocks.workerCreate.mockReturnValue({
+      lint: vi.fn().mockResolvedValue({
+        success: true, errorCount: 0, warningCount: 0, formattedOutput: "",
+      }),
+      terminate: mocks.lintWorkerTerminate,
+    });
+    mocks.execa.mockResolvedValue({
+      stdout: "Tests  1 passed", stderr: "", exitCode: 0,
+    });
+  });
+
+  afterEach(() => {
+    process.exitCode = savedExitCode;
+    writeSpy.mockRestore();
+  });
+
+  it("runs typecheck, lint, and test in parallel and outputs ALL PASSED", async () => {
+    await runCheck({ targets: [], types: ["typecheck", "lint", "test"], fix: false });
+
+    expect(mocks.executeTypecheck).toHaveBeenCalled();
+    expect(mocks.workerCreate).toHaveBeenCalled();
+    expect(mocks.execa).toHaveBeenCalled();
+    expect(stdoutOutput).toContain("ALL PASSED");
+  });
+
+  it("outputs results in TYPECHECK → LINT → TEST → SUMMARY 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");
+
+    expect(tcIdx).toBeLessThan(lintIdx);
+    expect(lintIdx).toBeLessThan(testIdx);
+    expect(testIdx).toBeLessThan(summaryIdx);
+  });
+
+  it("runs only specified check types", async () => {
+    await runCheck({ targets: [], types: ["lint", "test"], fix: false });
+
+    expect(mocks.executeTypecheck).not.toHaveBeenCalled();
+    expect(mocks.workerCreate).toHaveBeenCalled();
+    expect(mocks.execa).toHaveBeenCalled();
+  });
+
+  it("outputs FAILED with failing check names when some fail", async () => {
+    mocks.executeTypecheck.mockResolvedValue({
+      success: false, errorCount: 2, warningCount: 0, formattedOutput: "type errors",
+    });
+
+    await runCheck({ targets: [], types: ["typecheck", "lint", "test"], fix: false });
+
+    expect(stdoutOutput).toContain("FAILED");
+    expect(stdoutOutput).toContain("typecheck");
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("sets exitCode to 1 when any check fails", async () => {
+    mocks.workerCreate.mockReturnValue({
+      lint: vi.fn().mockResolvedValue({
+        success: false, errorCount: 1, warningCount: 0, formattedOutput: "lint errors",
+      }),
+      terminate: mocks.lintWorkerTerminate,
+    });
+
+    await runCheck({ targets: [], types: ["lint"], fix: false });
+
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("passes targets to vitest subprocess", async () => {
+    await runCheck({ targets: ["core-common"], types: ["test"], fix: false });
+
+    expect(mocks.execa).toHaveBeenCalledWith(
+      "pnpm",
+      ["vitest", "packages/core-common", "--run"],
+      expect.any(Object),
+    );
+  });
+
+  it("parses test failure count from vitest output", 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);
+  });
+
+  it("handles vitest execution error gracefully", async () => {
+    mocks.execa.mockRejectedValue(new Error("vitest not found"));
+
+    await runCheck({ targets: [], types: ["test"], fix: false });
+
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("passes fix option to lint worker", async () => {
+    const lintMock = vi.fn().mockResolvedValue({
+      success: true, errorCount: 0, warningCount: 0, formattedOutput: "",
+    });
+    mocks.workerCreate.mockReturnValue({
+      lint: lintMock,
+      terminate: mocks.lintWorkerTerminate,
+    });
+
+    await runCheck({ targets: [], types: ["lint"], fix: true });
+
+    expect(lintMock).toHaveBeenCalledWith(
+      expect.objectContaining({ fix: true }),
+    );
+  });
+
+  it("defaults fix to false when not specified", async () => {
+    const lintMock = vi.fn().mockResolvedValue({
+      success: true, errorCount: 0, warningCount: 0, formattedOutput: "",
+    });
+    mocks.workerCreate.mockReturnValue({
+      lint: lintMock,
+      terminate: mocks.lintWorkerTerminate,
+    });
+
+    await runCheck({ targets: [], types: ["lint"], fix: false });
+
+    expect(lintMock).toHaveBeenCalledWith(
+      expect.objectContaining({ fix: false }),
+    );
+  });
+
+  // --- Feature 1.1: target validation ---
+
+  it("normalizes package name target to path for typecheck", async () => {
+    await runCheck({ targets: ["core-node"], types: ["typecheck"], fix: false });
+
+    expect(mocks.executeTypecheck).toHaveBeenCalledWith(
+      expect.objectContaining({ targets: ["packages/core-node"] }),
+    );
+  });
+
+  it("normalizes multiple package name targets to paths for typecheck", async () => {
+    await runCheck({ targets: ["core-node", "core-common"], types: ["typecheck"], fix: false });
+
+    expect(mocks.executeTypecheck).toHaveBeenCalledWith(
+      expect.objectContaining({ targets: ["packages/core-node", "packages/core-common"] }),
+    );
+  });
+
+  it("normalizes package name target to path for lint", async () => {
+    const lintMock = vi.fn().mockResolvedValue({
+      success: true, errorCount: 0, warningCount: 0, formattedOutput: "",
+    });
+    mocks.workerCreate.mockReturnValue({
+      lint: lintMock,
+      terminate: mocks.lintWorkerTerminate,
+    });
+
+    await runCheck({ targets: ["core-node"], types: ["lint"], fix: false });
+
+    expect(lintMock).toHaveBeenCalledWith(
+      expect.objectContaining({ targets: ["packages/core-node"] }),
+    );
+  });
+
+  it("normalizes package name target to path for test", async () => {
+    await runCheck({ targets: ["core-node"], types: ["test"], fix: false });
+
+    expect(mocks.execa).toHaveBeenCalledWith(
+      "pnpm",
+      ["vitest", "packages/core-node", "--run"],
+      expect.any(Object),
+    );
+  });
+
+  it("throws error for unknown target", async () => {
+    await expect(
+      runCheck({ targets: ["nonexistent"], types: ["typecheck"], fix: false }),
+    ).rejects.toThrow("Unknown target: nonexistent");
+  });
+
+  it("throws error listing all unknown targets when some are invalid", async () => {
+    await expect(
+      runCheck({ targets: ["core-node", "nonexistent"], types: ["typecheck"], fix: false }),
+    ).rejects.toThrow("Unknown target: nonexistent");
+  });
+
+  it("runs all packages when targets is empty", async () => {
+    await runCheck({ targets: [], types: ["typecheck"], fix: false });
+
+    expect(mocks.executeTypecheck).toHaveBeenCalledWith(
+      expect.objectContaining({ targets: [] }),
+    );
+  });
+});

package/tests/commands/dev.spec.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  initialize: vi.fn(async () => {}),
+  start: vi.fn(async () => {}),
+  awaitTermination: vi.fn(async () => {}),
+  shutdown: vi.fn(async () => {}),
+  ctor: vi.fn(),
+}));
+
+vi.mock("../../src/orchestrators/DevWatchOrchestrator", () => ({
+  DevWatchOrchestrator: vi.fn().mockImplementation(function (this: any, options: any) {
+    mocks.ctor(options);
+    this.initialize = mocks.initialize;
+    this.start = mocks.start;
+    this.awaitTermination = mocks.awaitTermination;
+    this.shutdown = mocks.shutdown;
+  }),
+}));
+
+const { runDev } = await import("../../src/commands/dev");
+
+describe("runDev", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.initialize.mockResolvedValue(undefined);
+    mocks.start.mockResolvedValue(undefined);
+    mocks.awaitTermination.mockResolvedValue(undefined);
+    mocks.shutdown.mockResolvedValue(undefined);
+  });
+
+  it("creates DevWatchOrchestrator with mode:dev and runs lifecycle", async () => {
+    await runDev({ targets: ["service-server"], options: [] });
+
+    expect(mocks.ctor).toHaveBeenCalledWith({
+      mode: "dev",
+      targets: ["service-server"],
+      options: [],
+    });
+
+    expect(mocks.initialize).toHaveBeenCalledOnce();
+    expect(mocks.start).toHaveBeenCalledOnce();
+    expect(mocks.awaitTermination).toHaveBeenCalledOnce();
+    expect(mocks.shutdown).toHaveBeenCalledOnce();
+  });
+
+  it("calls shutdown even when start throws", async () => {
+    mocks.start.mockRejectedValueOnce(new Error("build error"));
+
+    await expect(runDev({ targets: [], options: [] })).rejects.toThrow("build error");
+    expect(mocks.shutdown).toHaveBeenCalledOnce();
+  });
+});