@simplysm/sd-cli 13.0.99 → 14.0.1

package/src/orchestrators/DevWatchOrchestrator.ts

@@ -0,0 +1,573 @@
+import path from "path";
+import { spawn, type ChildProcess } from "child_process";
+import { consola } from "consola";
+import { Worker, type WorkerProxy } from "@simplysm/core-node";
+import { FsWatcher } from "@simplysm/core-node";
+import { err as errNs } from "@simplysm/core-common";
+import type {
+  BuildTarget,
+  SdBuildPackageConfig,
+  SdClientPackageConfig,
+  SdConfig,
+  SdScriptsPackageConfig,
+  SdServerPackageConfig,
+} from "../sd-config.types";
+import { loadSdConfig } from "../utils/sd-config";
+import { filterPackagesByTargets, validateTargets } from "../utils/package-utils";
+import { getVersion } from "../utils/build-env";
+import { watchReplaceDeps, type WatchReplaceDepResult } from "../utils/replace-deps";
+import { printErrors, printServers } from "../utils/output-utils";
+import { RebuildManager } from "../utils/rebuild-manager";
+import { ResultCollector } from "../infra/ResultCollector";
+import { SignalHandler } from "../infra/SignalHandler";
+import { createBuildEngine, type BuildEngine, type BuildPackageInfo, type ClientPackageInfo, type ServerPackageInfo } from "../engines/index";
+import { watchCopySrcFiles } from "../utils/copy-src";
+import type * as ServerRuntimeWorkerModule from "../workers/server-runtime.worker";
+import type { ServerReadyEventData, ErrorEventData } from "../utils/worker-events";
+
+/**
+ * Orchestrator mode
+ */
+export type OrchestratorMode = "watch" | "dev";
+
+/**
+ * DevWatchOrchestrator options
+ */
+export interface DevWatchOrchestratorOptions {
+  mode: OrchestratorMode;
+  targets: string[];
+  options: string[];
+}
+
+/**
+ * Unified Orchestrator for watch and dev modes.
+ *
+ * - watch: Library(js+dts) + Scripts(watch hook) + copySrc + replaceDeps
+ * - dev: Server(js+runtime) + client-ready(skip) + replaceDeps
+ */
+export class DevWatchOrchestrator {
+  private readonly _cwd: string;
+  private readonly _options: DevWatchOrchestratorOptions;
+  private readonly _logger;
+
+  // Infrastructure
+  private _resultCollector!: ResultCollector;
+  private _signalHandler!: SignalHandler;
+  private _rebuildManager!: RebuildManager;
+
+  // Engines
+  private readonly _libraryEngines: BuildEngine[] = [];
+  private readonly _serverEngines = new Map<string, BuildEngine>();
+
+  // Package info
+  private readonly _libraryPackages: BuildPackageInfo[] = [];
+  private readonly _serverPackages: Array<{ name: string; dir: string; config: SdServerPackageConfig }> = [];
+  private readonly _watchHookPackages: Array<{ name: string; dir: string; config: SdScriptsPackageConfig | SdBuildPackageConfig }> = [];
+  private readonly _clientPackages: Array<{ name: string; dir: string; config: SdClientPackageConfig }> = [];
+  private readonly _clientEngines = new Map<string, BuildEngine>();
+  private readonly _serverClientsMap = new Map<string, string[]>();
+
+  // Dev mode: runtime workers
+  private _baseEnv: { VER: string; DEV: string } | undefined;
+  private readonly _serverRuntimeWorkers = new Map<string, WorkerProxy<typeof ServerRuntimeWorkerModule>>();
+  private _printServersTimer: ReturnType<typeof setTimeout> | undefined;
+
+  // Watchers
+  private _copySrcWatchers: FsWatcher[] = [];
+  private readonly _watchHookWatchers: FsWatcher[] = [];
+  private readonly _watchHookChildren = new Map<string, ChildProcess>();
+  private _replaceDepWatcher: WatchReplaceDepResult | undefined;
+
+  private _hasPackages = false;
+
+  constructor(options: DevWatchOrchestratorOptions) {
+    this._cwd = process.cwd();
+    this._options = options;
+    this._logger = consola.withTag(`sd:cli:${options.mode}`);
+  }
+
+  async initialize(): Promise<void> {
+    this._logger.debug(`${this._options.mode} start`, { targets: this._options.targets });
+
+    // Load sd.config.ts
+    let sdConfig: SdConfig;
+    try {
+      sdConfig = await loadSdConfig({
+        cwd: this._cwd,
+        dev: true,
+        options: this._options.options,
+      });
+      this._logger.debug("sd.config.ts loaded");
+    } catch (err) {
+      this._logger.error(`Failed to load sd.config.ts: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+      throw err;
+    }
+
+    // Validate targets
+    validateTargets(this._options.targets, sdConfig.packages);
+
+    // Start watch if replaceDeps config exists
+    if (sdConfig.replaceDeps != null) {
+      this._replaceDepWatcher = await watchReplaceDeps(this._cwd, sdConfig.replaceDeps);
+    }
+
+    // Prepare VER, DEV environment variables for dev mode
+    if (this._options.mode === "dev") {
+      const version = await getVersion(this._cwd);
+      this._baseEnv = { VER: version, DEV: "true" };
+    }
+
+    // Filter by targets
+    const allPackages = filterPackagesByTargets(sdConfig.packages, this._options.targets);
+
+    // Classify packages based on mode
+    const isLibraryTarget = (target: string): target is BuildTarget =>
+      target === "node" || target === "browser" || target === "neutral";
+
+    if (this._options.mode === "watch") {
+      this._classifyWatchPackages(allPackages, isLibraryTarget);
+    } else {
+      this._classifyDevPackages(allPackages);
+    }
+
+    // Check if there are packages to process
+    const totalPackages = this._libraryPackages.length + this._serverPackages.length + this._watchHookPackages.length + this._clientPackages.length;
+    if (totalPackages === 0) {
+      const modeLabel = this._options.mode === "watch" ? "watch" : "develop";
+      process.stdout.write(`⚠ No packages to ${modeLabel}.\n`);
+      return;
+    }
+
+    this._hasPackages = true;
+
+    // Initialize infrastructure
+    this._signalHandler = new SignalHandler();
+    this._resultCollector = new ResultCollector();
+    this._rebuildManager = new RebuildManager(this._logger);
+
+    // Batch complete handler
+    if (this._options.mode === "watch") {
+      this._rebuildManager.on("batchComplete", () => {
+        printErrors(this._resultCollector.toMap());
+      });
+    } else {
+      this._rebuildManager.on("batchComplete", () => {
+        this._onDevBatchComplete();
+      });
+    }
+
+    // Create BuildEngines for library packages (watch mode only)
+    for (const pkg of this._libraryPackages) {
+      const engine = createBuildEngine(pkg, {
+        cwd: this._cwd,
+        resultCollector: this._resultCollector,
+        rebuildManager: this._rebuildManager,
+      });
+      this._libraryEngines.push(engine);
+    }
+
+    // Create BuildEngines for server packages
+    for (const { name, dir, config } of this._serverPackages) {
+      const engineConfig = this._options.mode === "dev"
+        ? { ...config, env: { ...this._baseEnv, ...config.env } }
+        : config;
+
+      const engine = createBuildEngine(
+        { name, dir, config: engineConfig } as ServerPackageInfo,
+        {
+          cwd: this._cwd,
+          resultCollector: this._resultCollector,
+          rebuildManager: this._rebuildManager,
+        },
+      );
+      this._serverEngines.set(name, engine);
+    }
+
+    // Create BuildEngines for client packages (dev mode only, no env)
+    for (const { name, dir, config } of this._clientPackages) {
+      const engine = createBuildEngine(
+        { name, dir, config } as ClientPackageInfo,
+        {
+          cwd: this._cwd,
+          resultCollector: this._resultCollector,
+          rebuildManager: this._rebuildManager,
+        },
+      );
+      this._clientEngines.set(name, engine);
+    }
+  }
+
+  async start(): Promise<void> {
+    if (!this._hasPackages) {
+      return;
+    }
+
+    if (this._options.mode === "watch") {
+      await this._startWatchMode();
+    } else {
+      await this._startDevMode();
+    }
+  }
+
+  async awaitTermination(): Promise<void> {
+    if (!this._hasPackages) {
+      return;
+    }
+    await this._signalHandler.waitForTermination();
+  }
+
+  async shutdown(): Promise<void> {
+    if (!this._hasPackages) {
+      return;
+    }
+
+    process.stdout.write("⏳ Shutting down...\n");
+
+    const shutdownTasks: Array<Promise<void>> = [];
+
+    // Stop all engines
+    shutdownTasks.push(...this._libraryEngines.map((e) => e.stop()));
+    shutdownTasks.push(...[...this._serverEngines.values()].map((e) => e.stop()));
+    shutdownTasks.push(...[...this._clientEngines.values()].map((e) => e.stop()));
+
+    // Close watchers (watch mode)
+    shutdownTasks.push(...this._copySrcWatchers.map((w) => w.close()));
+    shutdownTasks.push(...this._watchHookWatchers.map((w) => w.close()));
+
+    // Kill hook child processes
+    for (const child of this._watchHookChildren.values()) {
+      if (child.exitCode == null) {
+        child.kill();
+      }
+    }
+    this._watchHookChildren.clear();
+
+    // Terminate runtime workers (dev mode)
+    shutdownTasks.push(...[...this._serverRuntimeWorkers.values()].map((w) => w.terminate()));
+
+    await Promise.all(shutdownTasks);
+    this._copySrcWatchers = [];
+    this._watchHookWatchers.length = 0;
+    this._replaceDepWatcher?.dispose();
+
+    process.stdout.write("✔ Done\n");
+  }
+
+  // --- Package classification ---
+
+  private _classifyWatchPackages(
+    allPackages: Record<string, any>,
+    isLibraryTarget: (target: string) => target is BuildTarget,
+  ): void {
+    for (const [name, config] of Object.entries(allPackages)) {
+      if (isLibraryTarget(config.target)) {
+        const pkgDir = path.join(this._cwd, "packages", name);
+        const buildConfig = config as SdBuildPackageConfig;
+        this._libraryPackages.push({ name, dir: pkgDir, config: buildConfig });
+        if (buildConfig.watch != null) {
+          this._watchHookPackages.push({ name, dir: pkgDir, config: buildConfig });
+        }
+      } else if (config.target === "scripts" && config.watch != null) {
+        this._watchHookPackages.push({
+          name,
+          dir: path.join(this._cwd, "packages", name),
+          config: config as SdScriptsPackageConfig,
+        });
+      }
+    }
+  }
+
+  private _classifyDevPackages(allPackages: Record<string, any>): void {
+    // First pass: collect server names
+    const serverNames = new Set<string>();
+    for (const [name, config] of Object.entries(allPackages)) {
+      if (config.target === "server") {
+        serverNames.add(name);
+      }
+    }
+
+    // Second pass: classify all packages
+    for (const [name, config] of Object.entries(allPackages)) {
+      if (config.target === "server") {
+        this._serverPackages.push({
+          name,
+          dir: path.join(this._cwd, "packages", name),
+          config: config as SdServerPackageConfig,
+        });
+      } else if (config.target === "client") {
+        this._clientPackages.push({
+          name,
+          dir: path.join(this._cwd, "packages", name),
+          config: config as SdClientPackageConfig,
+        });
+
+        // Build server-client mapping
+        if (typeof config.server === "string") {
+          if (serverNames.has(config.server)) {
+            const clients = this._serverClientsMap.get(config.server) ?? [];
+            clients.push(name);
+            this._serverClientsMap.set(config.server, clients);
+          } else {
+            process.stdout.write(
+              `⚠ Client "${name}" server "${config.server}" not in dev targets — running as standalone.\n`,
+            );
+          }
+        }
+      }
+      // Library and scripts packages are excluded from dev mode
+    }
+  }
+
+  // --- Watch mode ---
+
+  private async _startWatchMode(): Promise<void> {
+    // Start copySrc watchers for library packages
+    for (const pkg of this._libraryPackages) {
+      if (pkg.config.copySrc != null && pkg.config.copySrc.length > 0) {
+        const watcher = await watchCopySrcFiles(pkg.dir, pkg.config.copySrc);
+        this._copySrcWatchers.push(watcher);
+      }
+    }
+
+    // Start all engines
+    this._logger.start("Running initial build...");
+    const watchPromises: Array<Promise<void>> = [];
+    watchPromises.push(...this._libraryEngines.map((e) => e.startWatch({ js: true, dts: true })));
+
+    await Promise.allSettled(watchPromises);
+    this._logger.success("Initial build completed");
+
+    // Print initial build results
+    printErrors(this._resultCollector.toMap());
+
+    // Start watch hook watchers for scripts+watch packages
+    for (const pkg of this._watchHookPackages) {
+      const watchConfig = pkg.config.watch!;
+      const watchTargets = watchConfig.target.map((t) => path.resolve(pkg.dir, t));
+
+      // Run initial hook
+      this._runWatchHookCmd(pkg.name, pkg.dir, watchConfig.cmd, watchConfig.args);
+
+      // Start watching
+      const watcher = await FsWatcher.watch(watchTargets);
+      watcher.onChange({ delay: 300 }, () => {
+        this._runWatchHookCmd(pkg.name, pkg.dir, watchConfig.cmd, watchConfig.args);
+      });
+      this._watchHookWatchers.push(watcher);
+
+      this._logger.success(`Watch hook started: ${pkg.name}`);
+    }
+  }
+
+  private _runWatchHookCmd(pkgName: string, cwd: string, cmd: string, args?: string[]): void {
+    // Kill previous hook process if still running
+    const prev = this._watchHookChildren.get(pkgName);
+    if (prev != null && prev.exitCode == null) {
+      prev.kill();
+    }
+
+    const child = spawn(cmd, args ?? [], { cwd, stdio: "inherit", shell: true });
+    this._watchHookChildren.set(pkgName, child);
+
+    child.on("error", (err) => {
+      this._logger.error(`Watch hook error (${pkgName}): ${err.message}`);
+    });
+    child.on("close", (code) => {
+      if (code !== 0 && code !== null) {
+        this._logger.warn(`Watch hook (${pkgName}) exited with code ${String(code)}`);
+      }
+    });
+  }
+
+  // --- Dev mode ---
+
+  private async _startDevMode(): Promise<void> {
+    // Start client and server engines in parallel
+    this._logger.debug("Starting initial build (Promise.allSettled)");
+    const initialBuildPromises: Array<{ name: string; promise: Promise<void> }> = [];
+
+    for (const [name, engine] of this._clientEngines) {
+      initialBuildPromises.push({
+        name: `${name} (client)`,
+        promise: engine.startWatch({ js: true, dts: false }),
+      });
+    }
+
+    for (const [name, engine] of this._serverEngines) {
+      initialBuildPromises.push({
+        name: `${name} (server)`,
+        promise: engine.startWatch({ js: true, dts: false }),
+      });
+    }
+
+    const initialResults = await Promise.allSettled(
+      initialBuildPromises.map((item) => item.promise),
+    );
+
+    initialResults.forEach((result, index) => {
+      const taskName = initialBuildPromises[index].name;
+      if (result.status === "rejected") {
+        this._logger.debug(`[${taskName}] Initial build failed:`, result.reason);
+      } else {
+        this._logger.debug(`[${taskName}] Initial build completed`);
+      }
+    });
+
+    // Register standalone client results in ResultCollector
+    for (const { name } of this._clientPackages) {
+      const isServerConnected = [...this._serverClientsMap.values()].some(
+        (clients) => clients.includes(name),
+      );
+      if (!isServerConnected) {
+        const port = this._getClientPort(name);
+        if (port != null) {
+          this._resultCollector.add({
+            name,
+            target: "client",
+            type: "server",
+            status: "running",
+            port,
+          });
+        }
+      }
+    }
+
+    // Start runtimes for successful initial builds
+    for (const { name, config } of this._serverPackages) {
+      const buildResult = this._resultCollector.get(`${name}:build`);
+      if (buildResult?.status === "success") {
+        const mainJsPath = path.join(this._cwd, "packages", name, "dist", "main.js");
+        const clientPorts = this._collectClientPorts(name);
+        try {
+          await this._startServerRuntime(name, mainJsPath, { ...this._baseEnv, ...config.env }, clientPorts);
+        } catch (err) {
+          this._logger.error(`[${name}] Error starting Server Runtime:`, errNs.message(err));
+          this._resultCollector.add({
+            name,
+            target: "server",
+            type: "server",
+            status: "error",
+            message: errNs.message(err),
+          });
+        }
+      }
+    }
+
+    // Print initial results
+    printErrors(this._resultCollector.toMap());
+    printServers(this._resultCollector.toMap(), this._serverClientsMap);
+  }
+
+  private _onDevBatchComplete(): void {
+    const restartPromises: Array<Promise<void>> = [];
+    for (const { name, config } of this._serverPackages) {
+      const buildResult = this._resultCollector.get(`${name}:build`);
+      if (buildResult?.status === "success") {
+        const mainJsPath = path.join(this._cwd, "packages", name, "dist", "main.js");
+        const clientPorts = this._collectClientPorts(name);
+        restartPromises.push(
+          this._startServerRuntime(name, mainJsPath, { ...this._baseEnv, ...config.env }, clientPorts)
+            .catch((err: unknown) => {
+              this._logger.error(`[${name}] Error starting Server Runtime:`, errNs.message(err));
+              this._resultCollector.add({
+                name,
+                target: "server",
+                type: "server",
+                status: "error",
+                message: errNs.message(err),
+              });
+            }),
+        );
+      }
+    }
+    void Promise.all(restartPromises).then(() => {
+      printErrors(this._resultCollector.toMap());
+      this._schedulePrintServers();
+    });
+  }
+
+  private _schedulePrintServers(): void {
+    if (this._printServersTimer != null) clearTimeout(this._printServersTimer);
+    this._printServersTimer = setTimeout(() => {
+      printServers(this._resultCollector.toMap(), this._serverClientsMap);
+    }, 300);
+  }
+
+  /** Get port from a client engine (duck-typing for ViteEngine.port) */
+  private _getClientPort(name: string): number | undefined {
+    const engine = this._clientEngines.get(name) as { port?: number } | undefined;
+    return engine?.port;
+  }
+
+  /** Collect client ports for a server's connected clients */
+  private _collectClientPorts(serverName: string): Record<string, number> {
+    const clientPorts: Record<string, number> = {};
+    const connectedClients = this._serverClientsMap.get(serverName) ?? [];
+    for (const clientName of connectedClients) {
+      const port = this._getClientPort(clientName);
+      if (port != null) {
+        clientPorts[clientName] = port;
+      }
+    }
+    return clientPorts;
+  }
+
+  private async _startServerRuntime(
+    serverName: string,
+    mainJsPath: string,
+    env?: Record<string, string>,
+    clientPorts?: Record<string, number>,
+  ): Promise<void> {
+    this._logger.debug(`[${serverName}] _startServerRuntime: ${mainJsPath}`);
+
+    // Terminate existing runtime
+    const existingRuntime = this._serverRuntimeWorkers.get(serverName);
+    if (existingRuntime != null) {
+      this._logger.info(`[${serverName}] Restarting server...`);
+      await existingRuntime.terminate();
+    }
+
+    // Create and start new runtime worker
+    const runtimeWorkerPath = import.meta.resolve("../workers/server-runtime.worker");
+    const runtimeWorker = Worker.create<typeof ServerRuntimeWorkerModule>(runtimeWorkerPath);
+    this._serverRuntimeWorkers.set(serverName, runtimeWorker);
+
+    // Runtime event handlers
+    runtimeWorker.on("serverReady", (readyData) => {
+      const readyEvent = readyData as ServerReadyEventData;
+      this._resultCollector.add({
+        name: serverName,
+        target: "server",
+        type: "server",
+        status: "running",
+        port: readyEvent.port,
+      });
+      this._schedulePrintServers();
+    });
+
+    runtimeWorker.on("error", (errorData) => {
+      const errorEvent = errorData as ErrorEventData;
+      this._resultCollector.add({
+        name: serverName,
+        target: "server",
+        type: "server",
+        status: "error",
+        message: errorEvent.message,
+      });
+    });
+
+    runtimeWorker
+      .start({ mainJsPath, clientPorts, env })
+      .catch((err: unknown) => {
+        this._logger.error(`[${serverName}] Server Runtime Worker crashed:`, errNs.message(err));
+        this._resultCollector.add({
+          name: serverName,
+          target: "server",
+          type: "server",
+          status: "error",
+          message: errNs.message(err),
+        });
+      });
+  }
+}