@pipelab/core-node 1.0.0-beta.32 → 1.0.0-beta.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipelab/core-node",
-  "version": "1.0.0-beta.32",
+  "version": "1.0.0-beta.34",
   "private": false,
   "description": "The Pipelab automation engine for Node.js",
   "license": "FSL-1.1-MIT",
@@ -40,8 +40,8 @@
     "type-fest": "4.39.0",
     "ws": "8.18.3",
     "yauzl": "2.10.0",
-    "@pipelab/constants": "1.0.0-beta.28",
-    "@pipelab/shared": "1.0.0-beta.27"
+    "@pipelab/constants": "1.0.0-beta.30",
+    "@pipelab/shared": "1.0.0-beta.29"
   },
   "devDependencies": {
     "@types/adm-zip": "0.5.7",
@@ -56,7 +56,7 @@
     "tsdown": "0.21.2",
     "typescript": "^5.0.0",
     "vitest": "3.1.4",
-    "@pipelab/tsconfig": "1.0.0-beta.26"
+    "@pipelab/tsconfig": "1.0.0-beta.28"
   },
   "scripts": {
     "build": "tsdown",

package/src/handlers/index.ts

@@ -15,6 +15,7 @@ import { PipelabContext } from "../context";
 export const registerAllHandlers = async (options: {
   version: string;
   context: PipelabContext;
+  waitForPlugins?: boolean;
 }) => {
   const context = options.context;
 
@@ -31,9 +32,13 @@ export const registerAllHandlers = async (options: {
 
   const { registerPlugins } = usePlugins();
   // Execute in the background! The plugins will be dynamically registered and broadcasted to the UI.
-  builtInPlugins({
+  const pluginsPromise = builtInPlugins({
     context,
   });
+
+  if (options.waitForPlugins) {
+    await pluginsPromise;
+  }
 };
 
 export { registerShellHandlers } from "./shell";

package/src/handlers/plugins.ts

@@ -271,27 +271,12 @@ export const registerPluginsHandlers = (context: PipelabContext) => {
       });
 
       if (isRegistered) {
-        continue; // already loaded, nothing to do
+        loaded.push(packageName);
+        continue;
       }
 
-      try {
-        console.log(
-          `[Plugins] JIT loading plugin "${packageName}@${mappedVersion}" for pipeline...`,
-        );
-        const plugin = await loadCustomPlugin(packageName, mappedVersion, { context });
-        if (plugin) {
-          registerPlugins([plugin]);
-          webSocketServer.broadcast("plugin:loaded", { plugin });
-          loaded.push(packageName);
-          console.log(`[Plugins] JIT loaded "${packageName}" successfully.`);
-        } else {
-          console.warn(`[Plugins] JIT load for "${packageName}" returned no plugin.`);
-          failed.push(packageName);
-        }
-      } catch (e: any) {
-        console.error(`[Plugins] JIT load failed for "${packageName}":`, e);
-        failed.push(packageName);
-      }
+      console.warn(`[Plugins] Plugin "${packageName}" is required but not loaded at startup.`);
+      failed.push(packageName);
     }
 
     send({

package/src/plugins-registry.ts

@@ -80,12 +80,12 @@ export const loadPipelabPlugin = async (id: string, options: { context: PipelabC
     );
     const fetchDuration = Date.now() - fetchStart;
 
-    console.log(`[Plugins] [${id}] Attempting to import from: ${entryPoint}`);
+    console.debug(`[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);
+        console.debug(`[Plugins] [${id}] Directory contents:`, files);
       } catch (e) {}
     }
 
@@ -93,8 +93,7 @@ export const loadPipelabPlugin = async (id: string, options: { context: PipelabC
     const pluginModule = await import(pathToFileURL(entryPoint).href);
     const importDuration = Date.now() - importStart;
     const totalDuration = Date.now() - start;
-    console.log(
-      `[Plugins] [${id}] Successfully loaded from: ${packageDir} (fetch: ${fetchDuration}ms, import: ${importDuration}ms, total: ${totalDuration}ms)`,
+    console.debug(`[Plugins] [${id}] Successfully loaded from: ${packageDir} (fetch: ${fetchDuration}ms, import: ${importDuration}ms, total: ${totalDuration}ms)`,
     );
 
     const plugin = pluginModule.default;
@@ -125,8 +124,7 @@ export const loadCustomPlugin = async (
     });
     const fetchDuration = Date.now() - fetchStart;
 
-    console.log(
-      `[Plugins] [${packageName}] Attempting to import custom plugin from: ${entryPoint}`,
+    console.debug(`[Plugins] [${packageName}] Attempting to import custom plugin from: ${entryPoint}`,
     );
     if (!existsSync(entryPoint)) {
       console.error(
@@ -139,8 +137,7 @@ export const loadCustomPlugin = async (
     const pluginModule = await import(pathToFileURL(entryPoint).href);
     const importDuration = Date.now() - importStart;
     const totalDuration = Date.now() - start;
-    console.log(
-      `[Plugins] [${packageName}] Successfully loaded custom plugin from: ${packageDir} (fetch: ${fetchDuration}ms, import: ${importDuration}ms, total: ${totalDuration}ms)`,
+    console.debug(`[Plugins] [${packageName}] Successfully loaded custom plugin from: ${packageDir} (fetch: ${fetchDuration}ms, import: ${importDuration}ms, total: ${totalDuration}ms)`,
     );
 
     const plugin = pluginModule.default;
@@ -204,13 +201,13 @@ export async function findInstalledPlugins(
 }
 
 export const builtInPlugins = async (options: { context: PipelabContext }): Promise<void> => {
-  console.log("[Plugins] Starting background plugin loading...");
+  console.debug("[Plugins] Starting background plugin loading...");
 
   // Pre-ensure Node.js and PNPM once in parallel so plugins don't have to wait for them
   sendStartupProgress("Preparing environment...");
   const envStart = Date.now();
   await Promise.all([ensureNodeJS(options.context), ensurePNPM(options.context)]);
-  console.log(`[Plugins] Environment preparation took ${Date.now() - envStart}ms`);
+  console.debug(`[Plugins] Environment preparation took ${Date.now() - envStart}ms`);
 
   const { usePlugins } = await import("@pipelab/shared");
   const { registerPlugins } = usePlugins();
@@ -220,7 +217,7 @@ export const builtInPlugins = async (options: { context: PipelabContext }): Prom
   webSocketServer.broadcast("startup:progress", { type: "ready" });
 
   // Load plugins asynchronously in the background
-  (async () => {
+  return (async () => {
     const totalStart = Date.now();
     const pluginsToLoad = new Map<string, string>(); // packageName -> version
 
@@ -296,7 +293,10 @@ export const builtInPlugins = async (options: { context: PipelabContext }): Prom
       console.error(`[Plugins] Failed to load settings config on startup:`, e);
     }
 
-    console.log(`[Plugins] Total plugins to load on startup:`, Array.from(pluginsToLoad.entries()));
+    const pluginList = Array.from(pluginsToLoad.keys())
+      .map((p) => `  - ${p}`)
+      .join("\n");
+    console.log(`\n[Plugins] Loading plugins in background:\n${pluginList}\n`);
 
     // Now load all collected plugins in parallel
     const loadPromises = Array.from(pluginsToLoad.entries()).map(async ([packageName, version]) => {
@@ -307,8 +307,7 @@ export const builtInPlugins = async (options: { context: PipelabContext }): Prom
         if (plugin) {
           registerPlugins([plugin]);
           webSocketServer.broadcast("plugin:loaded", { plugin });
-          console.log(
-            `[Plugins] Loaded ${packageName}@${version} in ${Date.now() - pluginStart}ms`,
+          console.debug(`[Plugins] Loaded ${packageName}@${version} in ${Date.now() - pluginStart}ms`,
           );
         }
       } catch (err) {
@@ -317,7 +316,7 @@ export const builtInPlugins = async (options: { context: PipelabContext }): Prom
     });
     await Promise.all(loadPromises);
 
-    console.log(`[Plugins] All startup plugins loaded in ${Date.now() - totalStart}ms.`);
+    console.log(`\n[Plugins] All startup plugins loaded in ${Date.now() - totalStart}ms.\n`);
     sendStartupProgress("All plugins loaded.");
     setTimeout(() => {
       webSocketServer.broadcast("startup:progress", { type: "done" });

package/src/runner.ts

@@ -64,7 +64,7 @@ export async function runPipelineCommand(file: string, options: RunOptions, vers
     releaseTag,
   });
 
-  await registerAllHandlers({ version, context });
+  await registerAllHandlers({ version, context, waitForPlugins: true });
 
   const cachePath = context.getCachePath(CacheFolder.Pipelines, effectivePipelineId);
   await mkdir(cachePath, { recursive: true });

package/src/server.ts

@@ -21,7 +21,6 @@ export interface ServeOptions {
 }
 
 export const sendStartupProgress = (message: string) => {
-  console.log(`[Startup Progress] ${message}`);
   webSocketServer.broadcast("startup:progress", {
     type: "progress",
     data: { message },

package/src/utils/remote.ts

@@ -138,8 +138,7 @@ export async function fetchPackage(
       const localStart = Date.now();
       const local = await tryResolveMonorepoPackage(packageName);
       if (local) {
-        console.log(
-          `[Fetcher] ${packageName}: Resolved to local source at ${local.packageDir} (${Date.now() - localStart}ms)`,
+        console.debug(`[Fetcher] ${packageName}: Resolved to local source at ${local.packageDir} (${Date.now() - localStart}ms)`,
         );
         return {
           ...local,
@@ -159,7 +158,7 @@ export async function fetchPackage(
     resolvedVersionOrRange = "latest";
   }
 
-  console.log(`[Fetcher] Resolving ${packageName}@${resolvedVersionOrRange || "latest"}...`);
+  console.debug(`[Fetcher] Resolving ${packageName}@${resolvedVersionOrRange || "latest"}...`);
   const resolveStart = Date.now();
 
   const online = await isOnline();
@@ -177,8 +176,7 @@ export async function fetchPackage(
     );
     if (fallbackVersion) {
       resolvedVersion = fallbackVersion;
-      console.log(
-        `[Fetcher] ${packageName}: Resolved to local fallback ${resolvedVersion} (${Date.now() - fallbackStart}ms)`,
+      console.debug(`[Fetcher] ${packageName}: Resolved to local fallback ${resolvedVersion} (${Date.now() - fallbackStart}ms)`,
       );
     } else {
       throw new Error(`Offline and no local fallback version available for ${packageName}`);
@@ -212,8 +210,7 @@ export async function fetchPackage(
           if (
             semver.satisfies(releaseTagVersion, rewrittenRangeForCheck, { includePrerelease: true })
           ) {
-            console.log(
-              `[Fetcher] Using release tag "${ctx.releaseTag}" (${releaseTagVersion}) for ${packageName}@${range} because it satisfies the range`,
+            console.debug(`[Fetcher] Using release tag "${ctx.releaseTag}" (${releaseTagVersion}) for ${packageName}@${range} because it satisfies the range`,
             );
             foundVersion = releaseTagVersion;
           }
@@ -226,8 +223,7 @@ export async function fetchPackage(
         if (rewrittenRange !== range) {
           const matched = semver.maxSatisfying(versions, rewrittenRange, { includePrerelease });
           if (matched) {
-            console.log(
-              `[Fetcher] Resolved ${packageName}@${range} to ${matched} via rewritten range ${rewrittenRange}`,
+            console.debug(`[Fetcher] Resolved ${packageName}@${range} to ${matched} via rewritten range ${rewrittenRange}`,
             );
             foundVersion = matched;
           }
@@ -244,8 +240,7 @@ export async function fetchPackage(
             !foundVersion ||
             (semver.valid(foundVersion) && semver.gte(releaseTagVersion, foundVersion))
           ) {
-            console.log(
-              `[Fetcher] Using release tag "${ctx.releaseTag}" (${releaseTagVersion}) instead of "latest" (${foundVersion || "none"}) for ${packageName}`,
+            console.debug(`[Fetcher] Using release tag "${ctx.releaseTag}" (${releaseTagVersion}) instead of "latest" (${foundVersion || "none"}) for ${packageName}`,
             );
             foundVersion = releaseTagVersion;
           } else if (foundVersion) {
@@ -262,8 +257,7 @@ export async function fetchPackage(
         );
       }
       resolvedVersion = foundVersion;
-      console.log(
-        `[Fetcher] ${packageName}: Resolved to v${resolvedVersion} via npm (${Date.now() - resolveStart}ms)`,
+      console.debug(`[Fetcher] ${packageName}: Resolved to v${resolvedVersion} via npm (${Date.now() - resolveStart}ms)`,
       );
     } catch (error) {
       console.warn(
@@ -279,8 +273,7 @@ export async function fetchPackage(
       );
       if (fallbackVersion) {
         resolvedVersion = fallbackVersion;
-        console.log(
-          `[Fetcher] ${packageName}: Resolved to local fallback ${resolvedVersion} (${Date.now() - fallbackStart}ms)`,
+        console.debug(`[Fetcher] ${packageName}: Resolved to local fallback ${resolvedVersion} (${Date.now() - fallbackStart}ms)`,
         );
       } else {
         throw error;
@@ -299,8 +292,7 @@ export async function fetchPackage(
   const checkDuration = Date.now() - checkStart;
 
   if (isInstalled) {
-    console.log(
-      `[Fetcher] ${packageName}@${resolvedVersion}: Already installed (check took ${checkDuration}ms, fetchPackage took ${Date.now() - start}ms)`,
+    console.debug(`[Fetcher] ${packageName}@${resolvedVersion}: Already installed (check took ${checkDuration}ms, fetchPackage took ${Date.now() - start}ms)`,
     );
     return { packageDir, resolvedVersion };
   }
@@ -308,7 +300,7 @@ export async function fetchPackage(
   const lockKey = `package:${packageName}:${resolvedVersion}`;
   return withLock(lockKey, async () => {
     if (!isPackageComplete(packageDir)) {
-      console.log(`[Fetcher] ${packageName}@${resolvedVersion}: Downloading to ${packageDir}...`);
+      console.debug(`[Fetcher] ${packageName}@${resolvedVersion}: Downloading to ${packageDir}...`);
       const downloadStart = Date.now();
 
       const tempDir = join(
@@ -334,13 +326,12 @@ export async function fetchPackage(
           await rename(tempDir, packageDir);
         } catch (err: any) {
           if (isPackageComplete(packageDir)) {
-            console.log(`[Fetcher] Destination ${packageDir} already exists and is valid.`);
+            console.debug(`[Fetcher] Destination ${packageDir} already exists and is valid.`);
           } else {
             throw err;
           }
         }
-        console.log(
-          `[Fetcher] ${packageName}@${resolvedVersion}: Downloaded and extracted in ${Date.now() - downloadStart}ms`,
+        console.debug(`[Fetcher] ${packageName}@${resolvedVersion}: Downloaded and extracted in ${Date.now() - downloadStart}ms`,
         );
       } catch (err) {
         await rm(tempDir, { recursive: true, force: true }).catch(() => {});
@@ -351,20 +342,17 @@ export async function fetchPackage(
     // 2. Resolve entry point from package.json for downloaded package
     const entryStart = Date.now();
     const entryPoint = await resolveEntryPoint(packageDir, packageName);
-    console.log(
-      `[Fetcher] ${packageName}@${resolvedVersion}: Resolved entry point in ${Date.now() - entryStart}ms`,
+    console.debug(`[Fetcher] ${packageName}@${resolvedVersion}: Resolved entry point in ${Date.now() - entryStart}ms`,
     );
 
     if (options?.installDeps) {
       const depsStart = Date.now();
       await installDependencies(packageDir, packageName, options);
-      console.log(
-        `[Fetcher] ${packageName}@${resolvedVersion}: Installed dependencies in ${Date.now() - depsStart}ms`,
+      console.debug(`[Fetcher] ${packageName}@${resolvedVersion}: Installed dependencies in ${Date.now() - depsStart}ms`,
       );
     }
 
-    console.log(
-      `[Fetcher] ${packageName}@${resolvedVersion}: FetchPackage complete in ${Date.now() - start}ms`,
+    console.debug(`[Fetcher] ${packageName}@${resolvedVersion}: FetchPackage complete in ${Date.now() - start}ms`,
     );
     return { packageDir, resolvedVersion, entryPoint };
   });
@@ -429,8 +417,7 @@ export async function ensureNodeJS(context: PipelabContext, version = DEFAULT_NO
   const finalNodePath = join(nodeDir, isWindows ? "node.exe" : "bin/node");
 
   if (isNodeJSComplete(finalNodePath)) {
-    console.log(
-      `[Environment] Node.js check took ${Date.now() - checkStart}ms (found at ${finalNodePath})`,
+    console.debug(`[Environment] Node.js check took ${Date.now() - checkStart}ms (found at ${finalNodePath})`,
     );
     return finalNodePath;
   }
@@ -453,7 +440,7 @@ export async function ensureNodeJS(context: PipelabContext, version = DEFAULT_NO
     console.log(`Downloading Node.js from ${downloadUrl}...`);
     const dlStart = Date.now();
     await downloadFile(downloadUrl, archivePath);
-    console.log(`[Environment] Node.js download took ${Date.now() - dlStart}ms`);
+    console.debug(`[Environment] Node.js download took ${Date.now() - dlStart}ms`);
 
     sendStartupProgress(`Extracting Node.js v${version}...`);
     console.log(`Extracting Node.js to ${tempDir}...`);
@@ -496,18 +483,18 @@ export async function ensureNodeJS(context: PipelabContext, version = DEFAULT_NO
         await rename(tempNodeDir, nodeDir);
       } catch (err: any) {
         if (isNodeJSComplete(finalNodePath)) {
-          console.log(`[Fetcher] Node.js directory already exists and is valid.`);
+          console.debug(`[Fetcher] Node.js directory already exists and is valid.`);
         } else {
           throw err;
         }
       }
-      console.log(`[Environment] Node.js extraction took ${Date.now() - extStart}ms`);
+      console.debug(`[Environment] Node.js extraction took ${Date.now() - extStart}ms`);
     } finally {
       await rm(tempNodeDir, { recursive: true, force: true }).catch(() => {});
       await rm(tempDir, { recursive: true, force: true }).catch(() => {});
     }
 
-    console.log(`[Environment] Node.js set up complete in ${Date.now() - checkStart}ms`);
+    console.debug(`[Environment] Node.js set up complete in ${Date.now() - checkStart}ms`);
     return finalNodePath;
   });
 }
@@ -521,8 +508,7 @@ export async function ensurePNPM(context: PipelabContext, version = DEFAULT_PNPM
   const pnpmPath = join(pnpmDir, "bin", "pnpm.cjs");
 
   if (existsSync(pnpmPath)) {
-    console.log(
-      `[Environment] PNPM check took ${Date.now() - checkStart}ms (found at ${pnpmPath})`,
+    console.debug(`[Environment] PNPM check took ${Date.now() - checkStart}ms (found at ${pnpmPath})`,
     );
     return pnpmPath;
   }
@@ -534,7 +520,7 @@ export async function ensurePNPM(context: PipelabContext, version = DEFAULT_PNPM
     const { packageDir } = await fetchPackage("pnpm", version, {
       context,
     });
-    console.log(`[Environment] PNPM set up complete in ${Date.now() - checkStart}ms`);
+    console.debug(`[Environment] PNPM set up complete in ${Date.now() - checkStart}ms`);
     return join(packageDir, "bin", "pnpm.cjs");
   });
 }
@@ -544,23 +530,22 @@ async function installDependencies(packageDir: string, packageName: string, opti
   const nodeModulesPath = join(packageDir, "node_modules");
 
   if (isDependenciesInstalledSync(packageDir)) {
-    console.log(`[Fetcher] ${packageName}: Dependencies already installed, skipping.`);
+    console.debug(`[Fetcher] ${packageName}: Dependencies already installed, skipping.`);
     return;
   }
 
   try {
-    console.log(`[Fetcher] ${packageName}: Ensuring dependencies are installed...`);
+    console.debug(`[Fetcher] ${packageName}: Ensuring dependencies are installed...`);
     const pnpmStart = Date.now();
     const { all } = await runPnpm(packageDir, {
       signal: options.signal,
       context: options.context,
     });
-    console.log(`[Fetcher] ${packageName}: pnpm install command took ${Date.now() - pnpmStart}ms`);
+    console.debug(`[Fetcher] ${packageName}: pnpm install command took ${Date.now() - pnpmStart}ms`);
 
-    if (all) console.log(`[Fetcher] ${packageName}: Installation trace:\n${all}`);
+    if (all) console.debug(`[Fetcher] ${packageName}: Installation trace:\n${all}`);
 
-    console.log(
-      `[Fetcher] ${packageName}: Dependencies installed successfully (total installDependencies took ${Date.now() - start}ms).`,
+    console.debug(`[Fetcher] ${packageName}: Dependencies installed successfully (total installDependencies took ${Date.now() - start}ms).`,
     );
   } catch (err: any) {
     console.error(

package/src/utils.ts

@@ -129,25 +129,26 @@ export const executeGraphWithHistory = async ({
 
   // Ensure all plugins used in the graph are downloaded and registered
   const { registerPlugins, plugins: registeredPlugins } = usePlugins();
+  // JIT loading is intentionally removed here so plugins must be loaded at app startup.
+  // Fail-fast if any required plugin is not loaded
   const pluginIds = new Set(
     graph.map((node: any) => node.origin?.pluginId).filter(Boolean),
   ) as Set<string>;
 
+  const missingPlugins: string[] = [];
   for (const pluginId of pluginIds) {
     const isRegistered = registeredPlugins.value.some((p) => p.id === pluginId);
     if (!isRegistered) {
-      logger().info(`[Runner] Plugin "${pluginId}" not found, attempting to load...`);
-      const pluginDefinition = await loadPipelabPlugin(pluginId, { context: ctx });
-
-      if (pluginDefinition) {
-        registerPlugins([pluginDefinition]);
-        logger().info(`[Runner] Plugin "${pluginId}" loaded and registered successfully`);
-      } else {
-        logger().error(`[Runner] Failed to load or register plugin "${pluginId}"`);
-      }
+      missingPlugins.push(pluginId);
     }
   }
 
+  if (missingPlugins.length > 0) {
+    const errorMsg = `Fail-fast: The following required plugins are not loaded: ${missingPlugins.join(", ")}. Please ensure they are installed and enabled in settings.`;
+    logger().error(`[Runner] ${errorMsg}`);
+    throw new Error(errorMsg);
+  }
+
   logger().info(`[Sandbox] Execution sandbox created at: ${sandboxPath}`);
   const settingsFile = await setupSettingsConfigFile(ctx);
   const config = await settingsFile.getConfig();

package/scratch/simulate-updates.ts

@@ -1,120 +0,0 @@
-import pacote from "pacote";
-import semver from "semver";
-import { fetchLatestDesktopRelease } from "../src/utils/github.js";
-
-const PACKAGES = [
-  // Apps & Core
-  "@pipelab/cli",
-  "@pipelab/ui",
-  "@pipelab/shared",
-  "@pipelab/core-node",
-  "@pipelab/constants",
-  "@pipelab/migration",
-
-  // Plugins
-  "@pipelab/plugin-construct",
-  "@pipelab/plugin-core",
-  "@pipelab/plugin-discord",
-  "@pipelab/plugin-electron",
-  "@pipelab/plugin-filesystem",
-  "@pipelab/plugin-itch",
-  "@pipelab/plugin-minify",
-  "@pipelab/plugin-netlify",
-  "@pipelab/plugin-nvpatch",
-  "@pipelab/plugin-poki",
-  "@pipelab/plugin-steam",
-  "@pipelab/plugin-system",
-  "@pipelab/plugin-tauri",
-
-  // Assets
-  "@pipelab/asset-discord",
-  "@pipelab/asset-electron",
-  "@pipelab/asset-netlify",
-  "@pipelab/asset-tauri",
-];
-
-async function simulate() {
-  console.log("==========================================");
-  console.log("     PIPELAB UPDATE FLOW SIMULATOR        ");
-  console.log("==========================================\n");
-
-  // 1. Simulate Desktop GitHub Release Update
-  console.log("--- 1. Simulating Desktop Application (GitHub Releases) ---");
-  try {
-    const stableApp = await fetchLatestDesktopRelease({ allowPrerelease: false });
-    const betaApp = await fetchLatestDesktopRelease({ allowPrerelease: true });
-
-    console.log(
-      `[STABLE] Resolved version: ${stableApp ? stableApp.tag_name : "None (Stable users protected)"}`,
-    );
-    console.log(`[BETA]   Resolved version: ${betaApp ? betaApp.tag_name : "None"}`);
-  } catch (error) {
-    console.error("Failed to fetch desktop releases from GitHub:", error);
-  }
-
-  console.log("\n--- 2. Simulating NPM Packages (CLI, UI, Plugins, Assets) ---");
-  console.log("Fetching data from NPM registry. Please wait...\n");
-
-  const results: Array<{
-    package: string;
-    stable: string;
-    beta: string;
-    notes: string;
-  }> = [];
-
-  for (const pkg of PACKAGES) {
-    try {
-      const packument = await pacote.packument(pkg);
-      const stableVersion = packument["dist-tags"]?.latest || "N/A";
-      const betaVersion = packument["dist-tags"]?.beta || "N/A";
-
-      let notes = "";
-      if (stableVersion === "N/A" && betaVersion === "N/A") {
-        notes = "⚠️ Package not published on NPM";
-      } else if (betaVersion !== "N/A" && stableVersion !== "N/A") {
-        if (betaVersion === stableVersion) {
-          notes = "Stable and Beta are in sync";
-        } else {
-          // Attempt semver comparison
-          const cleanStable = semver.coerce(stableVersion);
-          const cleanBeta = semver.coerce(betaVersion);
-          if (cleanStable && cleanBeta) {
-            const comp = semver.compare(stableVersion, betaVersion);
-            if (comp < 0) {
-              notes = "🚀 Beta is ahead";
-            } else if (comp > 0) {
-              notes = "Stable is ahead";
-            } else {
-              notes = "Stable and Beta are in sync (coerced)";
-            }
-          } else {
-            notes = "Different versions (non-semver)";
-          }
-        }
-      } else if (betaVersion !== "N/A" && stableVersion === "N/A") {
-        notes = "Only Beta version exists";
-      } else if (stableVersion !== "N/A" && betaVersion === "N/A") {
-        notes = "No Beta tag published";
-      }
-
-      results.push({
-        package: pkg,
-        stable: stableVersion,
-        beta: betaVersion,
-        notes,
-      });
-    } catch (error: any) {
-      results.push({
-        package: pkg,
-        stable: "ERROR",
-        beta: "ERROR",
-        notes: `Failed to fetch: ${error.message}`,
-      });
-    }
-  }
-
-  console.table(results);
-  console.log("\n==========================================\n");
-}
-
-simulate().catch(console.error);