@pipelab/core-node 0.0.1

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@pipelab/core-node",
+  "version": "0.0.1",
+  "private": false,
+  "description": "The Pipelab automation engine for Node.js",
+  "license": "FSL-1.1-MIT",
+  "author": "CynToolkit",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CynToolkit/pipelab.git",
+    "directory": "packages/core-node"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "2.99.3",
+    "adm-zip": "0.5.16",
+    "archiver": "7.0.1",
+    "check-disk-space": "3.4.0",
+    "es-toolkit": "1.25.2",
+    "execa": "9.5.2",
+    "nanoid": "5.0.7",
+    "pacote": "21.5.0",
+    "semver": "^7.7.4",
+    "slash": "3.0.0",
+    "tar": "6.2.1",
+    "type-fest": "4.39.0",
+    "ws": "8.18.3",
+    "yauzl": "2.10.0",
+    "@pipelab/constants": "0.0.1",
+    "@pipelab/shared": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/adm-zip": "0.5.7",
+    "@types/archiver": "7.0.0",
+    "@types/node": "24.12.2",
+    "@types/pacote": "11.1.8",
+    "@types/semver": "^7.7.1",
+    "@types/tar": "7.0.87",
+    "@types/ws": "8.18.1",
+    "@types/yauzl": "2.10.3",
+    "tsdown": "0.21.2",
+    "typescript": "^5.0.0",
+    "@pipelab/tsconfig": "0.0.1"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "format": "oxfmt .",
+    "lint": "oxlint ."
+  }
+}

package/scratch/simulate-updates.ts

@@ -0,0 +1,118 @@
+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);

package/src/api.ts

@@ -0,0 +1,115 @@
+import { nanoid } from "nanoid";
+import { klona } from "klona";
+import { toRaw } from "vue";
+
+import type { Tagged } from "type-fest";
+import { ILogObjMeta } from "tslog";
+import { useLogger } from "@pipelab/shared";
+
+import {
+  UpdateStatus,
+  RendererChannels,
+  RendererData,
+  RendererEvents,
+  RendererEnd,
+  RendererMessage,
+  RequestId,
+  HandleListenerRendererSendFn,
+  HandleListenerRenderer as BaseHandleListenerRenderer,
+} from "@pipelab/shared";
+
+export type {
+  UpdateStatus,
+  RendererChannels,
+  RendererData,
+  RendererEvents,
+  RendererEnd,
+  RendererMessage,
+  RequestId,
+  HandleListenerRendererSendFn,
+};
+
+export type HandleListenerRenderer<KEY extends RendererChannels> = (
+  event: Electron.IpcMainInvokeEvent,
+  data: { value: RendererData<KEY>; send: HandleListenerRendererSendFn<KEY> },
+) => Promise<void>;
+
+export type ListenerMain<KEY extends RendererChannels> = (
+  event: Electron.IpcMainEvent,
+  data: RendererEvents<KEY>,
+) => Promise<void>;
+
+export const usePluginAPI = (browserWindow: any) => {
+  const { logger } = useLogger();
+  /**
+   * Send an order
+   */
+  const send = <KEY extends RendererChannels>(channel: KEY, args?: RendererData<KEY>) => {
+    if (!browserWindow || browserWindow.isDestroyed()) return;
+    browserWindow.webContents.send(channel, args);
+  };
+
+  const on = <KEY extends RendererChannels>(
+    channel: KEY | string,
+    listener: (event: any, data: RendererEvents<KEY>) => void,
+  ) => {
+    if (!browserWindow || browserWindow.isDestroyed()) return () => {};
+    const ipcMain = browserWindow.webContents.ipc.on(channel, listener);
+
+    const cancel = () => {
+      if (browserWindow.isDestroyed()) return;
+      ipcMain.removeListener(channel, listener);
+    };
+
+    return cancel;
+  };
+
+  /**
+   * Send an order and wait for it's execution
+   */
+  const execute = async <KEY extends RendererChannels>(
+    channel: KEY,
+    data?: RendererData<KEY>,
+    listener?: ListenerMain<KEY>,
+  ) => {
+    const newId = nanoid() as RequestId;
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise<RendererEnd<KEY>>(async (resolve, reject) => {
+      const message: RendererMessage = {
+        requestId: newId,
+        data: toRaw(klona(data)),
+      };
+
+      if (!browserWindow || browserWindow.isDestroyed()) {
+        return reject(new Error("Browser window is destroyed"));
+      }
+
+      const cancel = on(newId, async (event, data) => {
+        // console.log('receiving event', event, data)
+        if (data.type === "end") {
+          cancel();
+          return resolve(data.data);
+        } else {
+          await listener?.(event, data);
+        }
+      });
+
+      // send the message
+      try {
+        browserWindow.webContents.send(channel, message);
+      } catch (e) {
+        logger().error(e);
+        logger().error(channel, message);
+        reject(e);
+      }
+    });
+  };
+
+  return {
+    send,
+    on,
+    execute,
+  };
+};
+
+export type UseMainAPI = ReturnType<typeof usePluginAPI>;

package/src/config.ts

@@ -0,0 +1,100 @@
+import { PipelabContext } from "./context";
+import path from "node:path";
+import { ensure } from "./utils/fs-extras";
+import fs from "node:fs/promises";
+import { useLogger } from "@pipelab/shared";
+import { configRegistry, Migrator } from "@pipelab/shared";
+
+export const getMigrator = <T>(name: string) => {
+  if (configRegistry[name]) {
+    return configRegistry[name] as Migrator<T>;
+  }
+
+  if (name.startsWith("pipeline-")) {
+    return configRegistry["pipeline"] as Migrator<T>;
+  }
+
+  return undefined;
+};
+
+export const setupConfigFile = async <T>(
+  name: string,
+  options: { context: PipelabContext; migrator?: Migrator<T> },
+) => {
+  const ctx = options.context;
+  const migrator = options.migrator || getMigrator<T>(name);
+
+  if (!migrator) {
+    throw new Error(
+      `No migrator found for configuration: ${name}. All managed files must have a migration schema.`,
+    );
+  }
+
+  const isAbsolutePath = path.isAbsolute(name);
+  const filesPath = isAbsolutePath ? name : ctx.getConfigPath(`${name}.json`);
+
+  await ensure(filesPath, JSON.stringify(migrator.defaultValue));
+
+  return {
+    setConfig: async (config: T) => {
+      const { logger } = useLogger();
+      try {
+        await fs.writeFile(filesPath, JSON.stringify(config));
+        return true;
+      } catch (e) {
+        logger().error(`Error saving config ${name}:`, e);
+        return false;
+      }
+    },
+    getConfig: async () => {
+      const { logger } = useLogger();
+      let content = undefined;
+      let originalJson: any = undefined;
+
+      try {
+        content = await fs.readFile(filesPath, "utf8");
+        if (content !== undefined) {
+          originalJson = JSON.parse(content);
+        }
+      } catch (e) {
+        logger().error(`Error reading or parsing config ${name}:`, e);
+      }
+
+      // console.log("content", content);
+
+      let json: any = undefined;
+      try {
+        json = await migrator.migrate(originalJson, {
+          debug: false,
+          onStep: async (state: any, version: string) => {
+            const parsedPath = path.parse(filesPath);
+            const versionedPath = path.join(parsedPath.dir, `${parsedPath.name}.v${version}.json`);
+            try {
+              await fs.writeFile(versionedPath, JSON.stringify(state));
+              logger().info(`Intermediate backup created for ${name} at ${versionedPath}`);
+            } catch (e) {
+              logger().error(`Failed to create intermediate backup for ${name} at v${version}:`, e);
+            }
+          },
+        });
+      } catch (e) {
+        logger().error(`Error migrating config ${name}:`, e);
+        json = migrator.defaultValue;
+      }
+
+      const originalVersion = originalJson?.version;
+      const newVersion = json?.version;
+
+      // Save back migrated config if changed or if it's a new file
+      if (originalVersion !== newVersion || content === undefined) {
+        try {
+          await fs.writeFile(filesPath, JSON.stringify(json));
+        } catch (e) {
+          logger().error(`Error saving migrated config ${name}:`, e);
+        }
+      }
+
+      return json as T;
+    },
+  };
+};

package/src/context.ts

@@ -0,0 +1,74 @@
+import { join, dirname, resolve } from "node:path";
+import { homedir, platform } from "node:os";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+
+const _dirname =
+  typeof __dirname !== "undefined"
+    ? __dirname
+    : typeof import.meta !== "undefined" && import.meta.url
+      ? dirname(fileURLToPath(import.meta.url))
+      : process.cwd();
+
+export const isDev = process.env.NODE_ENV === "development";
+
+export const getDefaultUserDataPath = (env?: "dev" | "beta" | "prod") => {
+  const base = (() => {
+    switch (platform()) {
+      case "win32":
+        return process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+      case "darwin":
+        return join(homedir(), "Library", "Application Support");
+      default:
+        return process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+    }
+  })();
+
+  const mode = env ?? (isDev ? "dev" : "prod");
+  const folder = mode === "dev" ? "app-dev" : mode === "beta" ? "app-beta" : "app";
+
+  return join(base, "@pipelab", folder);
+};
+
+/**
+ * Finds the monorepo root by looking for pnpm-workspace.yaml.
+ */
+function findProjectRoot(startDir: string): string | null {
+  let curr = startDir;
+  while (curr !== dirname(curr)) {
+    if (existsSync(join(curr, "pnpm-workspace.yaml"))) {
+      return curr;
+    }
+    curr = dirname(curr);
+  }
+  return null;
+}
+
+export const projectRoot = findProjectRoot(_dirname);
+
+export interface PipelabContextOptions {
+  userDataPath: string;
+  releaseTag?: string;
+}
+
+export class PipelabContext {
+  public readonly userDataPath: string;
+  public readonly releaseTag: string;
+
+  constructor(options: PipelabContextOptions) {
+    this.userDataPath = options.userDataPath;
+    this.releaseTag = options.releaseTag || "latest";
+  }
+
+  getPackagesPath(...subpaths: string[]) {
+    return join(this.userDataPath, "packages", ...subpaths);
+  }
+
+  getThirdPartyPath(...subpaths: string[]) {
+    return join(this.userDataPath, "thirdparty", ...subpaths);
+  }
+
+  getConfigPath(...subpaths: string[]) {
+    return join(this.userDataPath, "config", ...subpaths);
+  }
+}

package/src/handler-func.ts

@@ -0,0 +1,234 @@
+import { End } from "@pipelab/shared";
+import { ensureNodeJS, ensurePNPM } from "./utils/remote";
+import { Action, ActionRunner, Condition, ConditionRunner } from "./types/runner";
+import { InputsDefinition } from "@pipelab/shared";
+import { usePlugins } from "@pipelab/shared";
+import { isRequired } from "@pipelab/shared";
+import { mkdir, stat } from "node:fs/promises";
+import { PipelabContext } from "./context";
+import { useLogger } from "@pipelab/shared";
+import { BlockCondition } from "@pipelab/shared";
+import { HandleListenerSendFn } from "./handlers";
+import path from "node:path";
+const { join } = path;
+
+const checkParams = (definitionParams: InputsDefinition, elementParams: Record<string, string>) => {
+  // get a list of all required params
+  let expected = Object.keys(definitionParams);
+
+  const found: string[] = [];
+  // for each param in elementParams
+  for (const param of Object.keys(elementParams)) {
+    // if the param is in the expected list
+    if (expected.includes(param)) {
+      // add to found
+      found.push(param);
+      // remove from expected
+      expected = expected.filter((x) => x !== param);
+    } else {
+      // throw new Error('Unexpected param "' + param + '"')
+      console.warn('Unexpected param "' + param + '"');
+    }
+  }
+
+  for (const param of expected) {
+    if (isRequired(definitionParams[param])) {
+      throw new Error('Missing param "' + param + '"');
+    }
+  }
+};
+
+export const handleConditionExecute = async (
+  nodeId: string,
+  pluginId: string,
+  params: BlockCondition["params"],
+  cwd: string,
+  context: PipelabContext,
+): Promise<End<"condition:execute">> => {
+  const ctx = context;
+  const { plugins } = usePlugins();
+  const { logger } = useLogger();
+
+  const node = plugins.value
+    .find((plugin) => plugin.id === pluginId)
+    ?.nodes.find((node: any) => node.node.id === nodeId) as
+    | {
+        node: Condition;
+        runner: ConditionRunner<any>;
+      }
+    | undefined;
+
+  if (!node) {
+    return {
+      type: "error",
+      ipcError: "Node not found",
+    };
+  }
+
+  try {
+    const s = await stat(cwd);
+    if (!s.isDirectory()) {
+      throw new Error(`Execution directory "${cwd}" exists but is not a directory.`);
+    }
+  } catch (e: any) {
+    if (e.code === "ENOENT") {
+      await mkdir(cwd, { recursive: true });
+    } else {
+      throw e;
+    }
+  }
+
+  try {
+    checkParams(node.node.params, params);
+    const resolvedInputs = params; // await resolveConditionInputs(params, node.node, steps)
+
+    const result = await node.runner({
+      inputs: resolvedInputs,
+      log: (...args) => {
+        logger().info(`[${node.node.name}]`, ...args);
+      },
+      meta: {
+        definition: "",
+      },
+      setMeta: () => {
+        logger().info("set meta defined here");
+      },
+      cwd,
+      context: ctx,
+    });
+
+    return {
+      type: "success",
+      result: {
+        outputs: {},
+        value: result,
+      },
+    };
+  } catch (e) {
+    logger().error("Error in condition execution:", e);
+    return {
+      type: "error",
+      ipcError: String(e),
+    };
+  }
+};
+
+export const handleActionExecute = async (
+  nodeId: string,
+  pluginId: string,
+  params: Record<string, string>,
+  mainWindow: any | undefined,
+  send: HandleListenerSendFn<"action:execute">,
+  abortSignal: AbortSignal,
+  cwd: string,
+  cachePath: string,
+  context: PipelabContext,
+): Promise<End<"action:execute">> => {
+  const ctx = context;
+  const { plugins } = usePlugins();
+  const { logger } = useLogger();
+
+  mainWindow?.setProgressBar(1, {
+    mode: "indeterminate",
+  });
+
+  const node = plugins.value
+    .find((plugin) => plugin.id === pluginId)
+    ?.nodes.find((node: any) => node.node.id === nodeId) as
+    | {
+        node: Action;
+        runner: ActionRunner<any>;
+      }
+    | undefined;
+
+  if (!node) {
+    mainWindow?.setProgressBar(1, { mode: "normal" });
+    return {
+      type: "error",
+      ipcError: "Node not found",
+    };
+  }
+
+  const nodePath = await ensureNodeJS(ctx);
+  const pnpm = await ensurePNPM(ctx);
+
+  const outputs: Record<string, unknown> = {};
+
+  try {
+    try {
+      const s = await stat(cwd);
+      if (!s.isDirectory()) {
+        throw new Error(`Execution directory "${cwd}" exists but is not a directory.`);
+      }
+    } catch (e: any) {
+      if (e.code === "ENOENT") {
+        await mkdir(cwd, { recursive: true });
+      } else {
+        throw e;
+      }
+    }
+    checkParams(node.node.params, params);
+    const resolvedInputs = params; // await resolveActionInputs(params, node.node, steps)
+    logger().info("resolvedInputs", resolvedInputs);
+
+    await node.runner({
+      inputs: resolvedInputs,
+      log: (...args) => {
+        const decorator = `[${node.node.name}]`;
+        const logArgs = [decorator, ...args];
+        logger().info(...logArgs);
+        send({
+          type: "log",
+          data: {
+            decorator,
+            time: Date.now(),
+            message: args,
+          },
+        });
+      },
+      setOutput: (key: any, value: unknown) => {
+        outputs[key] = value;
+      },
+      meta: {
+        definition: "",
+      },
+      setMeta: () => {
+        logger().info("set meta defined here");
+      },
+      cwd: cwd,
+      paths: {
+        cache: cachePath,
+        node: nodePath,
+        pnpm,
+        modules: "",
+        userData: ctx.userDataPath,
+        thirdparty: ctx.getThirdPartyPath(),
+      },
+      browserWindow: mainWindow,
+      abortSignal,
+      context: ctx,
+    });
+
+    mainWindow?.setProgressBar(1, { mode: "normal" });
+
+    return {
+      type: "success",
+      result: { outputs, tmp: cwd },
+    };
+  } catch (e) {
+    logger().error("Error in action execution:", e);
+    mainWindow?.setProgressBar(1, { mode: "normal" });
+
+    // If aborted, throw AbortError to distinguish from actual errors
+    if (abortSignal.aborted) {
+      const abortError = new Error("Aborted");
+      abortError.name = "AbortError";
+      throw abortError;
+    }
+
+    return {
+      type: "error",
+      ipcError: String(e),
+    };
+  }
+};