@pipelab/core-node 1.0.1-beta.29 → 1.0.1-latest.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipelab/core-node",
-  "version": "1.0.1-beta.29",
+  "version": "1.0.1-latest.33",
   "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-beta.25",
-    "@pipelab/shared": "2.0.1-beta.26"
+    "@pipelab/constants": "1.0.1-latest.29",
+    "@pipelab/shared": "2.0.1-latest.30"
   },
   "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-beta.25"
+    "@pipelab/tsconfig": "1.0.1-latest.29"
   },
   "scripts": {
     "build": "tsdown",

package/src/plugins-registry.ts

@@ -20,39 +20,41 @@ const DEFAULT_PLUGIN_IDS = [
   "netlify",
 ];
 
-export const builtInPlugins = async (options: { context: PipelabContext }) => {
-  console.log("[Plugins] Finalizing default plugins list...");
-  const promises = DEFAULT_PLUGIN_IDS.map(async (id) => {
-    try {
-      const packageName = `@pipelab/plugin-${id}`;
-      // console.log(`[Plugins] [${id}] Attempting to resolve...`);
+export const loadPipelabPlugin = async (id: string, options: { context: PipelabContext }) => {
+  try {
+    const packageName = `@pipelab/plugin-${id}`;
+    const { packageDir, entryPoint } = await fetchPipelabPlugin(packageName, "latest", {
+      context: options.context,
+      installDeps: true,
+    });
 
-      const { packageDir, entryPoint } = await fetchPipelabPlugin(packageName, "latest", {
-        context: options.context,
-      });
-
-      console.log(`[Plugins] [${id}] Attempting to import from: ${entryPoint}`);
-      if (!existsSync(entryPoint)) {
-        console.error(`[Plugins] [${id}] CRITICAL: Plugin entry point not found at ${entryPoint}`);
-        // Optionally list files in the directory to see what's there
-        try {
-          const files = await readdir(packageDir, { recursive: true });
-          console.log(`[Plugins] [${id}] Directory contents:`, files);
-        } catch (e) {}
-      }
+    console.log(`[Plugins] [${id}] Attempting to import from: ${entryPoint}`);
+    if (!existsSync(entryPoint)) {
+      console.error(`[Plugins] [${id}] CRITICAL: Plugin entry point not found at ${entryPoint}`);
+      try {
+        const files = await readdir(packageDir, { recursive: true });
+        console.log(`[Plugins] [${id}] Directory contents:`, files);
+      } catch (e) { }
+    }
 
-      const pluginModule = await import(pathToFileURL(entryPoint).href);
-      console.log(`[Plugins] [${id}] Successfully loaded from: ${packageDir}`);
-      return pluginModule.default;
-    } catch (e: any) {
-      console.error(`[Plugins] [${id}] CRITICAL: Failed to load:`, e);
-      if (e.code === "ERR_MODULE_NOT_FOUND") {
-        console.error(
-          `[Plugins] [${id}] This usually means a dependency is missing in the plugin's node_modules.`,
-        );
-      }
-      return null;
+    const pluginModule = await import(pathToFileURL(entryPoint).href);
+    console.log(`[Plugins] [${id}] Successfully loaded from: ${packageDir}`);
+    return pluginModule.default;
+  } catch (e: any) {
+    console.error(`[Plugins] [${id}] CRITICAL: Failed to load:`, e);
+    if (e.code === "ERR_MODULE_NOT_FOUND") {
+      console.error(
+        `[Plugins] [${id}] This usually means a dependency is missing in the plugin's node_modules.`,
+      );
     }
+    return null;
+  }
+};
+
+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 = await Promise.all(promises);

package/src/utils/remote.ts

@@ -53,10 +53,12 @@ export async function fetchPackage(
     const packument = await pacote.packument(packageName);
     const versions = Object.keys(packument.versions);
     const range = versionOrRange || "latest";
-    const foundVersion = semver.maxSatisfying(versions, range) || packument["dist-tags"]?.[range];
+
+    // Prioritize tags (like 'latest', 'beta', etc.) over semver ranges
+    const foundVersion = packument["dist-tags"]?.[range] || semver.maxSatisfying(versions, range);
 
     if (!foundVersion) {
-      throw new Error(`Package ${packageName}@${range} not found on npm`);
+      throw new Error(`Package ${packageName}@${range} not found on npm (available tags: ${Object.keys(packument["dist-tags"] || {}).join(", ")})`);
     }
     resolvedVersion = foundVersion;
     console.log(`[Fetcher] ${packageName}: Resolved to v${resolvedVersion} via npm`);
@@ -77,11 +79,29 @@ export async function fetchPackage(
     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);
+      }
+    }
+  } catch (e) {
+    console.warn(`[Fetcher] ${packageName}: Failed to parse package.json for entry point resolution:`, e);
+  }
+
   if (options?.installDeps) {
     await installDependencies(packageDir, packageName, options);
   }
 
-  return { packageDir, resolvedVersion };
+  return { packageDir, resolvedVersion, entryPoint };
 }
 
 /**
@@ -190,18 +210,18 @@ export async function ensurePNPM(version = "10.12.0", options: { context: Pipela
 async function installDependencies(packageDir: string, packageName: string, options: FetchOptions) {
   const nodeModulesPath = join(packageDir, "node_modules");
 
-  // Check if node_modules already exists and has content
   if (existsSync(nodeModulesPath)) {
     try {
       const files = await readdir(nodeModulesPath);
-      if (files.length > 0) return;
-      console.warn(`[Fetcher] ${packageName}: node_modules exists but is empty. Re-installing...`);
+      if (files.length === 0) {
+        console.warn(`[Fetcher] ${packageName}: node_modules exists but is empty. Re-installing...`);
+      }
     } catch (e) {
       // Continue to install if readdir fails
     }
   }
 
-  console.log(`[Fetcher] ${packageName}: Installing dependencies...`);
+  console.log(`[Fetcher] ${packageName}: Ensuring dependencies are installed...`);
   try {
     const { all } = await runPnpm(packageDir, {
       signal: options.signal,
@@ -244,7 +264,14 @@ export async function fetchPipelabPlugin(
   });
 
   // Default entry point if not provided by fetchPackage
-  const finalEntryPoint = entryPoint || join(packageDir, "dist", "index.mjs");
+  let finalEntryPoint = entryPoint;
+  if (!finalEntryPoint) {
+    const patterns = [
+      join(packageDir, "dist", "index.mjs"),
+      join(packageDir, "index.mjs"),
+    ];
+    finalEntryPoint = patterns.find((p) => existsSync(p)) || patterns[0];
+  }
 
   return { packageDir, entryPoint: finalEntryPoint, isLocal: !!isLocal };
 }
@@ -260,7 +287,14 @@ export async function fetchPipelabCli(
   );
 
   // Default entry point for CLI if not provided
-  const finalEntryPoint = entryPoint || join(packageDir, "dist", "index.mjs");
+  let finalEntryPoint = entryPoint;
+  if (!finalEntryPoint) {
+    const patterns = [
+      join(packageDir, "dist", "index.mjs"),
+      join(packageDir, "index.mjs"),
+    ];
+    finalEntryPoint = patterns.find((p) => existsSync(p)) || patterns[0];
+  }
 
   return { packageDir, entryPoint: finalEntryPoint, isLocal: !!isLocal };
 }

package/src/utils.ts

@@ -15,7 +15,8 @@ import type { BuildHistoryEntry } from "@pipelab/shared";
 import type { Variable } from "@pipelab/shared";
 
 import { ensure, generateTempFolder, extractTarGz, extractZip, zipFolder } from "./utils/fs-extras";
-import { fetchPipelabAsset, fetchPipelabPlugin } from "./utils/remote";
+import { fetchPipelabAsset } from "./utils/remote";
+import { loadPipelabPlugin } from "./plugins-registry";
 import { setupConfigFile } from "./config";
 import { AppConfig } from "@pipelab/shared";
 
@@ -139,19 +140,13 @@ export const executeGraphWithHistory = async ({
     const isRegistered = registeredPlugins.value.some((p) => p.id === pluginId);
     if (!isRegistered) {
       logger().info(`[Runner] Plugin "${pluginId}" not found, attempting to load...`);
-      try {
-        const packageName = `@pipelab/plugin-${pluginId}`;
-
-        const { packageDir, entryPoint } = await fetchPipelabPlugin(packageName, "latest", {
-          context: ctx,
-        });
-        const pluginModule = await import(pathToFileURL(entryPoint).href);
-        const pluginDefinition = pluginModule.default;
+      const pluginDefinition = await loadPipelabPlugin(pluginId, { context: ctx });
 
+      if (pluginDefinition) {
         registerPlugins([pluginDefinition]);
         logger().info(`[Runner] Plugin "${pluginId}" loaded and registered successfully`);
-      } catch (e) {
-        logger().error(`[Runner] Failed to load or register plugin "${pluginId}":`, e);
+      } else {
+        logger().error(`[Runner] Failed to load or register plugin "${pluginId}"`);
       }
     }
   }