@pipelab/core-node 1.0.1-latest.35 → 1.0.1-latest.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipelab/core-node",
-  "version": "1.0.1-latest.35",
+  "version": "1.0.1-latest.37",
   "private": false,
   "description": "The Pipelab automation engine for Node.js",
   "license": "FSL-1.1-MIT",
@@ -39,8 +39,8 @@
     "type-fest": "4.39.0",
     "ws": "8.18.3",
     "yauzl": "2.10.0",
-    "@pipelab/constants": "1.0.1-latest.31",
-    "@pipelab/shared": "2.0.1-latest.32"
+    "@pipelab/constants": "1.0.1-latest.33",
+    "@pipelab/shared": "2.0.1-latest.34"
   },
   "devDependencies": {
     "@types/adm-zip": "0.5.7",
@@ -53,7 +53,7 @@
     "@types/yauzl": "2.10.3",
     "tsdown": "0.21.2",
     "typescript": "^5.0.0",
-    "@pipelab/tsconfig": "1.0.1-latest.31"
+    "@pipelab/tsconfig": "1.0.1-latest.33"
   },
   "scripts": {
     "build": "tsdown",

package/src/ipc-core.ts

@@ -45,11 +45,18 @@ export const useAPI = () => {
           requestId,
           events,
         };
-        ws.send(JSON.stringify(response), (error) => {
-          if (error) {
-            logger().error("Failed to send WebSocket response:", error);
-          }
-        });
+
+        if (ws.readyState === WSWebSocket.OPEN) {
+          ws.send(JSON.stringify(response), (error) => {
+            if (error) {
+              logger().error("Failed to send WebSocket response:", error);
+            }
+          });
+        } else {
+          logger().debug(
+            `Cannot send response to ${requestId}: WebSocket is not open (state: ${ws.readyState})`,
+          );
+        }
         return Promise.resolve();
       };
 

package/src/plugins-registry.ts

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { readdir } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { isDev, projectRoot, PipelabContext } from "./context";
+import { sendStartupProgress } from "./server";
 
 const DEFAULT_PLUGIN_IDS = [
   "construct",
@@ -53,11 +54,15 @@ export const loadPipelabPlugin = async (id: string, options: { context: PipelabC
 
 export const builtInPlugins = async (options: { context: PipelabContext }) => {
   console.log("[Plugins] Finalizing default plugins list...");
-  const promises = DEFAULT_PLUGIN_IDS.map(async (id) => {
-    return loadPipelabPlugin(id, options);
-  });
+  const plugins = [];
+  for (const id of DEFAULT_PLUGIN_IDS) {
+    sendStartupProgress(`Loading plugin: ${id}`);
+    const plugin = await loadPipelabPlugin(id, options);
+    if (plugin) {
+      plugins.push(plugin);
+    }
+  }
 
-  const plugins = await Promise.all(promises);
   const filtered = plugins.filter(Boolean).flat();
   console.log(`[Plugins] Successfully loaded ${filtered.length} default plugins`);
   return filtered;

package/src/server.ts

@@ -21,6 +21,14 @@ export interface ServeOptions {
   pnpmPath?: string;
 }
 
+export const sendStartupProgress = (message: string) => {
+  console.log(`[Startup Progress] ${message}`);
+  webSocketServer.broadcast("startup:progress", {
+    type: "progress",
+    data: { message },
+  });
+};
+
 export async function serveCommand(options: ServeOptions, version: string, _dirname: string) {
   if (!options.userData) throw new Error("userDataPath is required for serveCommand");
   const context = new PipelabContext({
@@ -69,12 +77,18 @@ export async function serveCommand(options: ServeOptions, version: string, _dirn
     console.log(`UI available at http://localhost:${options.port}`);
   }
 
+  // Start the server EARLY so the UI can connect and receive progress updates
+  await webSocketServer.start(Number(options.port), server);
+
   await registerAllHandlers({
     version,
     context,
   });
   registerMigrationHandlers(context);
 
-  await webSocketServer.start(Number(options.port), server);
+  if (process.send) {
+    process.send({ type: "ready" });
+  }
+
   return server;
 }

package/src/utils/remote.ts

@@ -6,8 +6,33 @@ import pacote from "pacote";
 import semver from "semver";
 import { isDev, projectRoot, PipelabContext } from "../context";
 import { execa } from "execa";
+import { sendStartupProgress } from "../server";
 import { downloadFile, extractZip, extractTarGz, generateTempFolder } from "./fs-extras";
 
+/**
+ * In-memory lock to prevent concurrent operations on the same resource (e.g., downloading Node.js).
+ */
+const activeOperations = new Map<string, Promise<any>>();
+
+async function withLock<T>(key: string, fn: () => Promise<T>): Promise<T> {
+  const existing = activeOperations.get(key);
+  if (existing) {
+    console.log(`[Lock] Waiting for concurrent operation on: ${key}`);
+    return existing;
+  }
+
+  const promise = (async () => {
+    try {
+      return await fn();
+    } finally {
+      activeOperations.delete(key);
+    }
+  })();
+
+  activeOperations.set(key, promise);
+  return promise;
+}
+
 export type FetchOptions = {
   installDeps?: boolean;
   signal?: AbortSignal;
@@ -72,36 +97,39 @@ export async function fetchPackage(
     }
   }
 
-  const packageDir = join(baseDir, resolvedVersion);
-  if (!existsSync(packageDir)) {
-    console.log(`[Fetcher] ${packageName}@${resolvedVersion}: Downloading to ${packageDir}...`);
-    await mkdir(packageDir, { recursive: true });
-    await pacote.extract(`${packageName}@${resolvedVersion}`, packageDir);
-  }
+  const lockKey = `package:${packageName}:${resolvedVersion}`;
+  return withLock(lockKey, async () => {
+    const packageDir = join(baseDir, resolvedVersion);
+    if (!existsSync(packageDir)) {
+      console.log(`[Fetcher] ${packageName}@${resolvedVersion}: Downloading to ${packageDir}...`);
+      await mkdir(packageDir, { recursive: true });
+      await pacote.extract(`${packageName}@${resolvedVersion}`, packageDir);
+    }
 
-  // 2. Resolve entry point from package.json for downloaded package
-  let entryPoint: string | undefined;
-  try {
-    const pkgPath = join(packageDir, "package.json");
-    if (existsSync(pkgPath)) {
-      const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
-      const main = pkg.module || pkg.main || pkg.publishConfig?.module || pkg.publishConfig?.main;
-      if (main) {
-        entryPoint = join(packageDir, main);
-      } else if (pkg.bin) {
-        const binFile = typeof pkg.bin === "string" ? pkg.bin : Object.values(pkg.bin)[0];
-        if (binFile) entryPoint = join(packageDir, binFile as string);
+    // 2. Resolve entry point from package.json for downloaded package
+    let entryPoint: string | undefined;
+    try {
+      const pkgPath = join(packageDir, "package.json");
+      if (existsSync(pkgPath)) {
+        const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+        const main = pkg.module || pkg.main || pkg.publishConfig?.module || pkg.publishConfig?.main;
+        if (main) {
+          entryPoint = join(packageDir, main);
+        } else if (pkg.bin) {
+          const binFile = typeof pkg.bin === "string" ? pkg.bin : Object.values(pkg.bin)[0];
+          if (binFile) entryPoint = join(packageDir, binFile as string);
+        }
       }
+    } catch (e) {
+      console.warn(`[Fetcher] ${packageName}: Failed to parse package.json for entry point resolution:`, e);
     }
-  } catch (e) {
-    console.warn(`[Fetcher] ${packageName}: Failed to parse package.json for entry point resolution:`, e);
-  }
 
-  if (options?.installDeps) {
-    await installDependencies(packageDir, packageName, options);
-  }
+    if (options?.installDeps) {
+      await installDependencies(packageDir, packageName, options);
+    }
 
-  return { packageDir, resolvedVersion, entryPoint };
+    return { packageDir, resolvedVersion, entryPoint };
+  });
 }
 
 /**
@@ -148,63 +176,72 @@ export async function runPnpm(
  * Installs a specific version of Node.js if not already present.
  */
 export async function ensureNodeJS(version: string, options: { context: PipelabContext }) {
-  const ctx = options.context;
-  const nodeDir = ctx.getThirdPartyPath("node", version);
-  const isWindows = process.platform === "win32";
-  const executableName = isWindows ? "node.exe" : "bin/node";
-  const finalNodePath = join(nodeDir, executableName);
+  const lockKey = `node:${version}`;
+  return withLock(lockKey, async () => {
+    const ctx = options.context;
+    const nodeDir = ctx.getThirdPartyPath("node", version);
+    const isWindows = process.platform === "win32";
+    const executableName = isWindows ? "node.exe" : "bin/node";
+    const finalNodePath = join(nodeDir, executableName);
 
-  try {
-    await access(finalNodePath, constants.X_OK);
-    return finalNodePath;
-  } catch (e) {}
+    try {
+      await access(finalNodePath, constants.X_OK);
+      return finalNodePath;
+    } catch (e) {}
 
-  const arch = process.arch === "x64" ? "x64" : process.arch === "arm64" ? "arm64" : "x86";
-  const platform = isWindows ? "win" : process.platform === "darwin" ? "osx" : "linux";
-  const extension = isWindows ? "zip" : "tar.gz";
-  const downloadPlatform = platform === "osx" ? "darwin" : platform;
+    const arch = process.arch === "x64" ? "x64" : process.arch === "arm64" ? "arm64" : "x86";
+    const platform = isWindows ? "win" : process.platform === "darwin" ? "osx" : "linux";
+    const extension = isWindows ? "zip" : "tar.gz";
+    const downloadPlatform = platform === "osx" ? "darwin" : platform;
 
-  const fileName = `node-v${version}-${downloadPlatform}-${arch}.${extension}`;
-  const downloadUrl = `https://nodejs.org/dist/v${version}/${fileName}`;
-  const tempDir = await generateTempFolder(tmpdir());
-  const archivePath = join(tempDir, fileName);
+    const fileName = `node-v${version}-${downloadPlatform}-${arch}.${extension}`;
+    const downloadUrl = `https://nodejs.org/dist/v${version}/${fileName}`;
+    const tempDir = await generateTempFolder(tmpdir());
+    const archivePath = join(tempDir, fileName);
 
-  console.log(`Downloading Node.js from ${downloadUrl}...`);
-  await downloadFile(downloadUrl, archivePath);
+    sendStartupProgress(`Downloading Node.js v${version}...`);
+    console.log(`Downloading Node.js from ${downloadUrl}...`);
+    await downloadFile(downloadUrl, archivePath);
 
-  console.log(`Extracting Node.js to ${tempDir}...`);
-  const extractTempDir = join(tempDir, "extracted");
-  await mkdir(extractTempDir, { recursive: true });
+    sendStartupProgress(`Extracting Node.js v${version}...`);
+    console.log(`Extracting Node.js to ${tempDir}...`);
+    const extractTempDir = join(tempDir, "extracted");
+    await mkdir(extractTempDir, { recursive: true });
 
-  if (extension === "zip") {
-    await extractZip(archivePath, extractTempDir);
-  } else {
-    await extractTarGz(archivePath, extractTempDir);
-  }
+    if (extension === "zip") {
+      await extractZip(archivePath, extractTempDir);
+    } else {
+      await extractTarGz(archivePath, extractTempDir);
+    }
 
-  const extractedEntries = await readdir(extractTempDir);
-  const nodeSubDir = extractedEntries.find((entry) => entry.startsWith(`node-v${version}`));
-  if (!nodeSubDir) throw new Error(`Could not find extracted Node.js directory`);
+    const extractedEntries = await readdir(extractTempDir);
+    const nodeSubDir = extractedEntries.find((entry) => entry.startsWith(`node-v${version}`));
+    if (!nodeSubDir) throw new Error(`Could not find extracted Node.js directory`);
 
-  const sourceDir = join(extractTempDir, nodeSubDir);
-  await mkdir(dirname(nodeDir), { recursive: true });
-  await rm(nodeDir, { recursive: true, force: true });
-  await cp(sourceDir, nodeDir, { recursive: true });
-  await rm(tempDir, { recursive: true, force: true });
+    const sourceDir = join(extractTempDir, nodeSubDir);
+    await mkdir(dirname(nodeDir), { recursive: true });
+    await rm(nodeDir, { recursive: true, force: true });
+    await cp(sourceDir, nodeDir, { recursive: true });
+    await rm(tempDir, { recursive: true, force: true });
 
-  if (!isWindows) await chmod(finalNodePath, 0o755).catch(() => {});
-  return finalNodePath;
+    if (!isWindows) await chmod(finalNodePath, 0o755).catch(() => {});
+    return finalNodePath;
+  });
 }
 
 /**
  * Installs the PNPM package from npm if not already present.
  */
 export async function ensurePNPM(version = "10.12.0", options: { context: PipelabContext }) {
-  const ctx = options.context;
-  const { packageDir } = await fetchPackage("pnpm", version, {
-    context: ctx,
+  const lockKey = `pnpm:${version}`;
+  return withLock(lockKey, async () => {
+    sendStartupProgress(`Checking PNPM v${version}...`);
+    const ctx = options.context;
+    const { packageDir } = await fetchPackage("pnpm", version, {
+      context: ctx,
+    });
+    return join(packageDir, "bin", "pnpm.cjs");
   });
-  return join(packageDir, "bin", "pnpm.cjs");
 }
 
 async function installDependencies(packageDir: string, packageName: string, options: FetchOptions) {