@simplysm/sd-cli 13.0.100 → 14.0.1

package/src/index.ts

@@ -1,5 +1,2 @@
 // Config
 export * from "./sd-config.types";
-
-// Vite
-export * from "./utils/vite-config";

package/src/infra/ResultCollector.ts

@@ -4,7 +4,7 @@
 export interface BuildResult {
   name: string;
   target: string;
-  type: "build" | "dts" | "server" | "capacitor";
+  type: "build" | "dts" | "server";
   status: "pending" | "building" | "success" | "error" | "running";
   message?: string;
   port?: number;

package/src/orchestrators/BuildOrchestrator.ts

@@ -1,7 +1,6 @@
 import path from "path";
 import ts from "typescript";
-import { Worker, type WorkerProxy, fsx } from "@simplysm/core-node";
-import { err as errNs } from "@simplysm/core-common";
+import { Worker, fsx } from "@simplysm/core-node";
 import { consola } from "consola";
 import type {
   SdConfig,
@@ -11,18 +10,14 @@ import type {
 } from "../sd-config.types";
 import { loadSdConfig } from "../utils/sd-config";
 import { getVersion } from "../utils/build-env";
-import type { TypecheckEnv } from "../utils/tsconfig";
 import { deserializeDiagnostic } from "../utils/typecheck-serialization";
 import type { LintOptions } from "../commands/lint";
 import type * as LintWorkerModule from "../workers/lint.worker";
-import type * as LibraryWorkerModule from "../workers/library.worker";
-import type * as ServerWorkerModule from "../workers/server.worker";
-import type * as ClientWorkerModule from "../workers/client.worker";
-import type * as DtsWorkerModule from "../workers/dts.worker";
-import { Capacitor } from "../capacitor/capacitor";
-import { Electron } from "../electron/electron";
 import { copySrcFiles } from "../utils/copy-src";
 import { formatBuildMessages } from "../utils/output-utils";
+import { createBuildEngine } from "../engines/index";
+import { runWithConcurrency, getMaxConcurrency } from "../utils/concurrency";
+import { validateTargets } from "../utils/package-utils";
 
 //#region Types
 
@@ -42,7 +37,7 @@ export interface BuildOrchestratorOptions {
 interface BuildStepResult {
   name: string;
   target: string;
-  type: "js" | "dts" | "vite" | "capacitor" | "electron";
+  type: "js" | "dts";
   success: boolean;
   errors?: string[];
   warnings?: string[];
@@ -55,10 +50,10 @@ interface BuildStepResult {
 interface ClassifiedPackages {
   /** node/browser/neutral target (JS + dts) */
   buildPackages: Array<{ name: string; config: SdBuildPackageConfig }>;
-  /** client target (Vite build + typecheck) */
-  clientPackages: Array<{ name: string; config: SdClientPackageConfig }>;
   /** server target (JS build, no dts) */
   serverPackages: Array<{ name: string; config: SdServerPackageConfig }>;
+  /** client target (Vite production build, no dts) */
+  clientPackages: Array<{ name: string; config: SdClientPackageConfig }>;
 }
 
 //#endregion
@@ -68,11 +63,11 @@ interface ClassifiedPackages {
 /**
  * Classify packages by target
  * - node/browser/neutral: buildPackages (JS + dts)
- * - client: clientPackages (Vite build + typecheck)
  * - server: serverPackages (JS build, no dts)
+ * - client: clientPackages (Vite production build, no dts)
  * - scripts: excluded
  */
-function classifyPackages(
+export function classifyPackages(
   packages: Record<
     string,
     | SdBuildPackageConfig
@@ -84,8 +79,8 @@ function classifyPackages(
   targets: string[],
 ): ClassifiedPackages {
   const buildPackages: ClassifiedPackages["buildPackages"] = [];
-  const clientPackages: ClassifiedPackages["clientPackages"] = [];
   const serverPackages: ClassifiedPackages["serverPackages"] = [];
+  const clientPackages: ClassifiedPackages["clientPackages"] = [];
 
   for (const [name, config] of Object.entries(packages)) {
     if (config == null) continue;
@@ -103,7 +98,7 @@ function classifyPackages(
     }
   }
 
-  return { buildPackages, clientPackages, serverPackages };
+  return { buildPackages, serverPackages, clientPackages };
 }
 
 /**
@@ -124,8 +119,8 @@ async function cleanDistFolders(cwd: string, packageNames: string[]): Promise<vo
  * - Clean dist folders (clean build)
  * - Run lint + build concurrently
  * - node/browser/neutral targets: esbuild JS build + dts generation
- * - client targets: Vite production build + typecheck + Capacitor/Electron builds
  * - server targets: esbuild JS build
+ * - client targets: Vite production build
  */
 export class BuildOrchestrator {
   private readonly _cwd: string;
@@ -166,6 +161,9 @@ export class BuildOrchestrator {
       throw err;
     }
 
+    // Validate targets
+    validateTargets(this._options.targets, this._sdConfig.packages);
+
     // Prepare VER and DEV environment variables
     const version = await getVersion(this._cwd);
     this._baseEnv = { VER: version, DEV: "false" };
@@ -174,8 +172,8 @@ export class BuildOrchestrator {
     this._classified = classifyPackages(this._sdConfig.packages, this._options.targets);
     this._allPackageNames = [
       ...this._classified.buildPackages.map((p) => p.name),
-      ...this._classified.clientPackages.map((p) => p.name),
       ...this._classified.serverPackages.map((p) => p.name),
+      ...this._classified.clientPackages.map((p) => p.name),
     ];
 
     if (this._allPackageNames.length === 0) {
@@ -185,8 +183,8 @@ export class BuildOrchestrator {
 
     this._logger.debug("package classification complete", {
       buildPackages: this._classified.buildPackages.map((p) => p.name),
-      clientPackages: this._classified.clientPackages.map((p) => p.name),
       serverPackages: this._classified.serverPackages.map((p) => p.name),
+      clientPackages: this._classified.clientPackages.map((p) => p.name),
     });
   }
 
@@ -211,11 +209,7 @@ export class BuildOrchestrator {
     // Track errors (wrapped in object to allow mutation tracking in callbacks)
     const state = { hasError: false };
 
-    // Worker paths
-    const libraryWorkerPath = import.meta.resolve("../workers/library.worker");
-    const serverWorkerPath = import.meta.resolve("../workers/server.worker");
-    const clientWorkerPath = import.meta.resolve("../workers/client.worker");
-    const dtsWorkerPath = import.meta.resolve("../workers/dts.worker");
+    // Worker path (lint only — library/server are handled by BuildEngine)
     const lintWorkerPath = import.meta.resolve("../workers/lint.worker");
 
     // File cache (for diagnostics output)
@@ -246,51 +240,44 @@ export class BuildOrchestrator {
     // Create list of build tasks
     const buildTasks: Array<() => Promise<void>> = [];
 
-    // buildPackages: JS build + dts generation
+    // buildPackages: JS build + dts generation via BuildEngine
     for (const { name, config } of classified.buildPackages) {
       const pkgDir = path.join(this._cwd, "packages", name);
-      const env: TypecheckEnv = config.target === "node" ? "node" : "browser";
 
       buildTasks.push(async () => {
         this._logger.debug(`${name} (${config.target}) started`);
-        // Run JS build and DTS generation in parallel
-        const libraryWorker: WorkerProxy<typeof LibraryWorkerModule> =
-          Worker.create<typeof LibraryWorkerModule>(libraryWorkerPath);
-        const dtsWorker: WorkerProxy<typeof DtsWorkerModule> =
-          Worker.create<typeof DtsWorkerModule>(dtsWorkerPath);
+        const engine = createBuildEngine(
+          { name, dir: pkgDir, config },
+          { cwd: this._cwd },
+        );
 
         try {
-          const [buildResult, dtsResult] = await Promise.all([
-            // JS build
-            libraryWorker.build({ name, config, cwd: this._cwd, pkgDir }),
-            // DTS generation
-            dtsWorker.build({ name, cwd: this._cwd, pkgDir, env, emit: true }),
-          ]);
+          const engineResult = await engine.run({ js: true, dts: true });
 
           // Handle JS build results
           results.push({
             name,
             target: config.target,
             type: "js",
-            success: buildResult.success,
-            errors: buildResult.errors,
-            warnings: buildResult.warnings,
+            success: engineResult.js.success,
+            errors: engineResult.js.errors.length > 0 ? engineResult.js.errors : undefined,
+            warnings: engineResult.js.warnings.length > 0 ? engineResult.js.warnings : undefined,
           });
-          if (!buildResult.success) state.hasError = true;
+          if (!engineResult.js.success) state.hasError = true;
 
           // Handle DTS results
-          const diagnostics = dtsResult.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
+          const diagnostics = engineResult.dts.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
           results.push({
             name,
             target: config.target,
             type: "dts",
-            success: dtsResult.success,
-            errors: dtsResult.errors,
+            success: engineResult.dts.success,
+            errors: engineResult.dts.errors.length > 0 ? engineResult.dts.errors : undefined,
             diagnostics,
           });
-          if (!dtsResult.success) state.hasError = true;
+          if (!engineResult.dts.success) state.hasError = true;
         } finally {
-          await Promise.all([libraryWorker.terminate(), dtsWorker.terminate()]);
+          await engine.stop();
         }
 
         // Copy copySrc files
@@ -301,152 +288,94 @@ export class BuildOrchestrator {
       });
     }
 
-    // clientPackages: Vite build + typecheck + Capacitor build
-    for (const { name, config } of classified.clientPackages) {
+    // serverPackages: JS build + typecheck via BuildEngine
+    for (const { name, config } of classified.serverPackages) {
       const pkgDir = path.join(this._cwd, "packages", name);
 
       buildTasks.push(async () => {
-        this._logger.debug(`${name} (client) started`);
-        // Run Vite build and typecheck in parallel
-        const clientWorker: WorkerProxy<typeof ClientWorkerModule> =
-          Worker.create<typeof ClientWorkerModule>(clientWorkerPath);
-        const dtsWorker: WorkerProxy<typeof DtsWorkerModule> =
-          Worker.create<typeof DtsWorkerModule>(dtsWorkerPath);
+        this._logger.debug(`${name} (server) started`);
+        const engine = createBuildEngine(
+          { name, dir: pkgDir, config: { ...config, env: { ...baseEnv, ...config.env } } },
+          { cwd: this._cwd },
+        );
 
         try {
-          const clientConfig: SdClientPackageConfig = {
-            ...config,
-            env: { ...baseEnv, ...config.env },
-          };
-          const [clientResult, dtsResult] = await Promise.all([
-            // Vite production build
-            clientWorker.build({ name, config: clientConfig, cwd: this._cwd, pkgDir }),
-            // typecheck (without dts)
-            dtsWorker.build({
-              name,
-              cwd: this._cwd,
-              pkgDir,
-              env: "browser",
-              emit: false,
-            }),
-          ]);
-
-          // Handle Vite build results
+          const engineResult = await engine.run({ js: true, dts: false });
+
+          // Handle JS build results
           results.push({
             name,
-            target: "client",
-            type: "vite",
-            success: clientResult.success,
-            errors: clientResult.errors,
+            target: "server",
+            type: "js",
+            success: engineResult.js.success,
+            errors: engineResult.js.errors.length > 0 ? engineResult.js.errors : undefined,
+            warnings: engineResult.js.warnings.length > 0 ? engineResult.js.warnings : undefined,
           });
-          if (!clientResult.success) state.hasError = true;
+          if (!engineResult.js.success) state.hasError = true;
 
-          // Handle typecheck results
-          const diagnostics = dtsResult.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
+          // Handle DTS/typecheck results
+          const diagnostics = engineResult.dts.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
           results.push({
             name,
-            target: "client",
+            target: "server",
             type: "dts",
-            success: dtsResult.success,
-            errors: dtsResult.errors,
+            success: engineResult.dts.success,
+            errors: engineResult.dts.errors.length > 0 ? engineResult.dts.errors : undefined,
             diagnostics,
           });
-          if (!dtsResult.success) state.hasError = true;
+          if (!engineResult.dts.success) state.hasError = true;
         } finally {
-          await Promise.all([clientWorker.terminate(), dtsWorker.terminate()]);
-        }
-
-        // Capacitor build (only if configured)
-        if (config.capacitor != null) {
-          const outPath = path.join(pkgDir, "dist");
-          try {
-            const cap = await Capacitor.create(pkgDir, config.capacitor, config.exclude);
-            await cap.initialize();
-            await cap.build(outPath);
-            results.push({
-              name,
-              target: "client",
-              type: "capacitor",
-              success: true,
-            });
-          } catch (err) {
-            results.push({
-              name,
-              target: "client",
-              type: "capacitor",
-              success: false,
-              errors: [errNs.message(err)],
-            });
-            state.hasError = true;
-          }
-        }
-
-        // Electron build (only if configured)
-        if (config.electron != null) {
-          const outPath = path.join(pkgDir, "dist");
-          try {
-            const electron = await Electron.create(pkgDir, config.electron, config.exclude);
-            await electron.initialize();
-            await electron.build(outPath);
-            results.push({
-              name,
-              target: "client",
-              type: "electron",
-              success: true,
-            });
-          } catch (err) {
-            results.push({
-              name,
-              target: "client",
-              type: "electron",
-              success: false,
-              errors: [errNs.message(err)],
-            });
-            state.hasError = true;
-          }
+          await engine.stop();
         }
-        this._logger.debug(`${name} (client) completed`);
+        this._logger.debug(`${name} (server) completed`);
       });
     }
 
-    // serverPackages: JS build only (dts generation excluded)
-    for (const { name, config } of classified.serverPackages) {
+    // clientPackages: Vite production build via ViteEngine (no dts, no env injection)
+    for (const { name, config } of classified.clientPackages) {
       const pkgDir = path.join(this._cwd, "packages", name);
 
       buildTasks.push(async () => {
-        this._logger.debug(`${name} (server) started`);
-        const serverWorker: WorkerProxy<typeof ServerWorkerModule> =
-          Worker.create<typeof ServerWorkerModule>(serverWorkerPath);
+        this._logger.debug(`${name} (client) started`);
+        const engine = createBuildEngine(
+          { name, dir: pkgDir, config },
+          { cwd: this._cwd },
+        );
 
         try {
-          const buildResult = await serverWorker.build({
+          const engineResult = await engine.run({ js: true, dts: false });
+
+          // Handle JS build results
+          results.push({
             name,
-            cwd: this._cwd,
-            pkgDir,
-            env: { ...baseEnv, ...config.env },
-            configs: config.configs,
-            externals: config.externals,
-            pm2: config.pm2,
-            packageManager: config.packageManager,
+            target: "client",
+            type: "js",
+            success: engineResult.js.success,
+            errors: engineResult.js.errors.length > 0 ? engineResult.js.errors : undefined,
+            warnings: engineResult.js.warnings.length > 0 ? engineResult.js.warnings : undefined,
           });
+          if (!engineResult.js.success) state.hasError = true;
 
+          // Handle DTS results (always success for client)
+          const diagnostics = engineResult.dts.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
           results.push({
             name,
-            target: "server",
-            type: "js",
-            success: buildResult.success,
-            errors: buildResult.errors,
-            warnings: buildResult.warnings,
+            target: "client",
+            type: "dts",
+            success: engineResult.dts.success,
+            errors: engineResult.dts.errors.length > 0 ? engineResult.dts.errors : undefined,
+            diagnostics,
           });
-          if (!buildResult.success) state.hasError = true;
+          if (!engineResult.dts.success) state.hasError = true;
         } finally {
-          await serverWorker.terminate();
+          await engine.stop();
         }
-        this._logger.debug(`${name} (server) completed`);
+        this._logger.debug(`${name} (client) completed`);
       });
     }
 
     // Run Lint + all builds in parallel
+    // Lint runs independently; build tasks use concurrency limit (PERF-001)
     const lintWorker = Worker.create<typeof LintWorkerModule>(lintWorkerPath);
     const lintTask = async (): Promise<void> => {
       try {
@@ -456,7 +385,8 @@ export class BuildOrchestrator {
         await lintWorker.terminate();
       }
     };
-    await Promise.allSettled([lintTask(), ...buildTasks.map((task) => task())]);
+    const buildPromise = runWithConcurrency(buildTasks, getMaxConcurrency());
+    await Promise.allSettled([lintTask(), buildPromise]);
     this._logger.success("Lint + Build");
 
     // Output results