@pipelab/core-node 1.0.0-beta.0

package/src/handlers/shell.ts

@@ -0,0 +1,57 @@
+import { useAPI } from "../ipc-core";
+import { useLogger } from "@pipelab/shared";
+import { PipelabContext } from "../context";
+import { homedir } from "node:os";
+
+export const registerShellHandlers = (_context: PipelabContext) => {
+  const { handle } = useAPI();
+  const { logger } = useLogger();
+
+  handle("dialog:showOpenDialog", async (event, { value, send }) => {
+    logger().info("value", value);
+    logger().info("dialog:showOpenDialog");
+
+    // Since we are in a standalone server, we cannot show Electron dialogs.
+    // In the future, this could be handled by the UI or a separate GUI process.
+    send({
+      type: "end",
+      data: {
+        type: "success",
+        result: {
+          filePaths: [],
+          canceled: true,
+        },
+      },
+    });
+  });
+
+  handle("dialog:showSaveDialog", async (event, { value, send }) => {
+    const { logger } = useLogger();
+
+    logger().info("value", value);
+    logger().info("dialog:showSaveDialog");
+
+    send({
+      type: "end",
+      data: {
+        type: "success",
+        result: {
+          filePath: undefined,
+          canceled: true,
+        },
+      },
+    });
+  });
+
+  handle("fs:getHomeDirectory", async (event, { send }) => {
+    send({
+      type: "end",
+      data: {
+        type: "success",
+        result: {
+          path: homedir(),
+        },
+      },
+    });
+  });
+};

package/src/handlers/system.ts

@@ -0,0 +1,18 @@
+import { useAPI } from "../ipc-core";
+import { PipelabContext } from "../context";
+
+export const registerSystemHandlers = (options: { version: string; context: PipelabContext }) => {
+  const { handle } = useAPI();
+
+  handle("agent:version:get", async (_, { send }) => {
+    send({
+      type: "end",
+      data: {
+        type: "success",
+        result: {
+          version: options.version,
+        },
+      },
+    });
+  });
+};

package/src/handlers.ts

@@ -0,0 +1,2 @@
+export * from "./ipc-core";
+export * from "./handlers/index";

package/src/heavy.ts

@@ -0,0 +1,4 @@
+export * from "./websocket-server";
+export * from "./handler-func";
+export * from "./utils";
+export * from "./handlers/index";

package/src/index.ts

@@ -0,0 +1,16 @@
+export * from "./context";
+export * from "./websocket-server";
+export * from "./ipc-core";
+export * from "./handlers/index";
+export * from "./config";
+export * from "./paths";
+export * from "./api";
+export * from "./heavy";
+export * from "./plugins-registry";
+export * from "./utils/remote";
+export * from "./utils/fs-extras";
+export * from "./types/runner";
+export * from "./runner";
+export * from "./migrations";
+export * from "./server";
+export * from "./utils";

package/src/ipc-core.ts

@@ -0,0 +1,77 @@
+import { Channels, IpcMessage } from "@pipelab/shared";
+import { WebSocket as WSWebSocket } from "ws";
+import { useLogger } from "@pipelab/shared";
+import { WebSocketEvent, WebSocketHandler, WebSocketSendFunction } from "@pipelab/shared";
+
+export type HandleListenerSendFn<KEY extends Channels> = WebSocketSendFunction<KEY>;
+
+export type WsEvent = WebSocketEvent;
+
+export type HandleListener<KEY extends Channels> = WebSocketHandler<KEY>;
+
+const handlers: Record<string, WebSocketHandler<any>> = {};
+
+export const useAPI = () => {
+  const { logger } = useLogger();
+
+  const handle = <KEY extends Channels>(channel: KEY, listener: WebSocketHandler<KEY>) => {
+    handlers[channel] = listener;
+
+    return {
+      channel,
+      listener,
+    };
+  };
+
+  const processWebSocketMessage = (ws: WSWebSocket, channel: string, message: IpcMessage) => {
+    const { data, requestId } = message;
+
+    if (handlers[channel]) {
+      logger().debug("Executing handler for channel:", channel, "with data:", JSON.stringify(data));
+      const event: WsEvent = {
+        sender: ws.url || "websocket-client",
+      };
+
+      const send: HandleListenerSendFn<any> = (events) => {
+        const serialized = JSON.stringify(events);
+        logger().debug(
+          "sending response to",
+          requestId,
+          ":",
+          serialized.length > 500 ? serialized.substring(0, 500) + "..." : serialized,
+        );
+        const response = {
+          type: "response",
+          requestId,
+          events,
+        };
+
+        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();
+      };
+
+      return handlers[channel](event, {
+        send,
+        value: data,
+      });
+    } else {
+      logger().warn("No handler found for channel:", channel);
+    }
+  };
+
+  return {
+    handle,
+    processWebSocketMessage,
+    handlers,
+  };
+};

package/src/migrations.ts

@@ -0,0 +1,72 @@
+import { useAPI } from "./ipc-core";
+import { PipelabContext } from "./context";
+import { setupConfigFile } from "./config";
+import {
+  savedFileMigrator,
+  fileRepoMigrations,
+  appSettingsMigrator,
+  useLogger,
+} from "@pipelab/shared";
+
+/**
+ * Registers migration handlers for the CLI/Standalone server.
+ * This overrides the default handlers from @pipelab/core-node to include
+ * pipeline and file repo migrations directly in the backend.
+ */
+export function registerMigrationHandlers(context: PipelabContext) {
+  const { handle } = useAPI();
+  const { logger } = useLogger();
+
+  handle("config:load", async (_, { send, value }) => {
+    const { config: name } = value;
+    logger().info("[CLI Migration] config:load", name);
+
+    try {
+      // Determine which migrator to use
+      let migrator: any = null;
+      if (name === "projects") {
+        migrator = fileRepoMigrations;
+      } else if (name === "settings") {
+        migrator = appSettingsMigrator;
+      } else if (name.startsWith("pipeline-") || name.endsWith(".plb")) {
+        migrator = savedFileMigrator;
+      }
+
+      if (!migrator) {
+        throw new Error(
+          `No migrator found for configuration: ${name}. All files loaded via config:load MUST have a migration schema.`,
+        );
+      }
+
+      // We use a custom loading logic that applies the migrator
+      // Since setupConfigFile in core-node expects the migrator to be in the configRegistry,
+      // and we want to keep migrations in the CLI package, we'll manually apply them here.
+
+      const manager = await setupConfigFile(name, { context, migrator });
+      const json = await manager.getConfig();
+
+      send({
+        type: "end",
+        data: {
+          type: "success",
+          result: {
+            result: json,
+          },
+        },
+      });
+    } catch (e) {
+      logger().error(`[CLI Migration] config:load error for ${name}:`, e);
+      send({
+        type: "end",
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : `Unable to load config ${name}`,
+        },
+      });
+    }
+  });
+
+  // We also need to override config:save if we want to ensure consistency,
+  // although mostly we just care about migrations on load.
+  // The default config:save from core-node will work fine as it uses the same setupConfigFile logic.
+}

package/src/paths.ts

@@ -0,0 +1 @@
+export * from "./context";

package/src/plugins-registry.ts

@@ -0,0 +1,78 @@
+import { ensureNodeJS, ensurePNPM, fetchPipelabPlugin } from "./utils/remote";
+import { pathToFileURL } from "node:url";
+import { readdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { PipelabContext } from "./context";
+import { sendStartupProgress } from "./server";
+
+const DEFAULT_PLUGIN_IDS = [
+  "construct",
+  "filesystem",
+  "system",
+  "steam",
+  "itch",
+  "electron",
+  "discord",
+  "poki",
+  "nvpatch",
+  "tauri",
+  "minify",
+  "netlify",
+];
+
+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,
+    });
+
+    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;
+  }
+};
+
+export const builtInPlugins = async (options: { context: PipelabContext }) => {
+  console.log("[Plugins] Finalizing default plugins list...");
+
+  // Pre-ensure Node.js and PNPM once in parallel so plugins don't have to wait for them
+  sendStartupProgress("Preparing environment...");
+  await Promise.all([
+    ensureNodeJS(options.context),
+    ensurePNPM(options.context),
+  ]);
+
+  const results = await Promise.allSettled(
+    DEFAULT_PLUGIN_IDS.map(async (id) => {
+      sendStartupProgress(`Loading plugin: ${id}`);
+      return loadPipelabPlugin(id, options);
+    }),
+  );
+
+  const plugins = results
+    .filter((r) => r.status === "fulfilled")
+    .map((r) => (r as PromiseFulfilledResult<any>).value);
+
+  const filtered = plugins.filter(Boolean).flat();
+  console.log(`[Plugins] Successfully loaded ${filtered.length} default plugins`);
+  return filtered;
+};

package/src/presets/c3toSteam.ts

@@ -0,0 +1,272 @@
+import { PresetFn, SavedFile } from "@pipelab/shared";
+
+export const c3toSteamPreset: PresetFn = async () => {
+  const startId = "manual-start";
+
+  const data: SavedFile = {
+    version: "3.0.0",
+    name: "Construct 3 to Steam",
+    description: "A basic project to get you started with Construct 3 and Steam",
+    variables: [],
+    canvas: {
+      triggers: [
+        {
+          type: "event",
+          origin: {
+            pluginId: "system",
+            nodeId: "manual",
+          },
+          uid: startId,
+          params: {},
+        },
+      ],
+      blocks: [
+        {
+          uid: "3oHbOKmCXo6NSjmrn0tHG",
+          type: "action",
+          origin: {
+            nodeId: "export-construct-project",
+            pluginId: "construct",
+          },
+          params: {
+            file: {
+              editor: "simple",
+              value: "",
+            },
+            username: {
+              editor: "simple",
+              value: '""',
+            },
+            password: {
+              editor: "simple",
+              value: '""',
+            },
+            version: {
+              editor: "simple",
+              value: "",
+            },
+            headless: {
+              editor: "simple",
+              value: "true",
+            },
+            timeout: {
+              editor: "simple",
+              value: "120",
+            },
+            customProfile: {
+              editor: "simple",
+              value: "",
+            },
+          },
+        },
+        {
+          uid: "6s1uYWDi2XbRriBpvQSBS",
+          type: "action",
+          origin: {
+            nodeId: "unzip-file-node",
+            pluginId: "filesystem",
+          },
+          params: {
+            file: {
+              editor: "editor",
+              value: "steps['3oHbOKmCXo6NSjmrn0tHG']['outputs']['zipFile']",
+            },
+          },
+        },
+        {
+          uid: "cvxzwBfXPZhH1RbmmxBdG",
+          type: "action",
+          origin: {
+            nodeId: "electron:package:v2",
+            pluginId: "electron",
+          },
+          params: {
+            arch: {
+              editor: "simple",
+              value: "",
+            },
+            platform: {
+              editor: "simple",
+              value: "",
+            },
+            "input-folder": {
+              editor: "editor",
+              value: "steps['6s1uYWDi2XbRriBpvQSBS']['outputs']['output']",
+            },
+            name: {
+              editor: "simple",
+              value: '"Pipelab"',
+            },
+            appBundleId: {
+              editor: "simple",
+              value: '"com.pipelab.app"',
+            },
+            appCopyright: {
+              editor: "simple",
+              value: '"Copyright © 2024 Pipelab"',
+            },
+            appVersion: {
+              editor: "simple",
+              value: '"1.0.0"',
+            },
+            icon: {
+              editor: "simple",
+              value: "",
+            },
+            author: {
+              editor: "simple",
+              value: '"Pipelab"',
+            },
+            description: {
+              editor: "simple",
+              value: '"A sample application"',
+            },
+            appCategoryType: {
+              editor: "simple",
+              value: '"public.app-category.developer-tools"',
+            },
+            width: {
+              editor: "simple",
+              value: 800,
+            },
+            height: {
+              editor: "simple",
+              value: 600,
+            },
+            fullscreen: {
+              editor: "simple",
+              value: "false",
+            },
+            frame: {
+              editor: "simple",
+              value: "true",
+            },
+            transparent: {
+              editor: "simple",
+              value: "false",
+            },
+            toolbar: {
+              editor: "simple",
+              value: "true",
+            },
+            alwaysOnTop: {
+              editor: "simple",
+              value: "false",
+            },
+            electronVersion: {
+              editor: "simple",
+              value: '""',
+            },
+            customMainCode: {
+              editor: "simple",
+              value: "",
+            },
+            disableAsarPackaging: {
+              editor: "simple",
+              value: "true",
+            },
+            enableExtraLogging: {
+              editor: "simple",
+              value: "false",
+            },
+            clearServiceWorkerOnBoot: {
+              editor: "simple",
+              value: "false",
+            },
+            enableInProcessGPU: {
+              editor: "simple",
+              value: "false",
+            },
+            enableDisableRendererBackgrounding: {
+              editor: "simple",
+              value: "false",
+            },
+            forceHighPerformanceGpu: {
+              editor: "simple",
+              value: "false",
+            },
+            websocketApi: {
+              editor: "simple",
+              value: "[]",
+            },
+            ignore: {
+              editor: "simple",
+              value: "[\n  // use 'src/app/' as starting point\n]",
+            },
+            enableSteamSupport: {
+              editor: "simple",
+              value: "true",
+            },
+            steamGameId: {
+              editor: "simple",
+              value: "480",
+            },
+          },
+        },
+        {
+          uid: "1pJrNARroFnuY9DfiC56r",
+          type: "action",
+          origin: {
+            nodeId: "steam-upload",
+            pluginId: "steam",
+          },
+          params: {
+            sdk: {
+              editor: "simple",
+              value: "",
+            },
+            username: {
+              editor: "simple",
+              value: "",
+            },
+            appId: {
+              editor: "simple",
+              value: "",
+            },
+            depotId: {
+              editor: "simple",
+              value: "",
+            },
+            description: {
+              editor: "simple",
+              value: "",
+            },
+            folder: {
+              editor: "editor",
+              value: "steps['cvxzwBfXPZhH1RbmmxBdG']['outputs']['output']",
+            },
+            enableDRM: {
+              editor: "simple",
+              value: "false",
+            },
+            binaryToPatch: {
+              editor: "simple",
+              value: "",
+            },
+          },
+          disabled: false,
+        },
+        {
+          uid: "gnTsA6oO49ySfetxUf-0K",
+          type: "action",
+          origin: {
+            nodeId: "fs:open-in-explorer",
+            pluginId: "filesystem",
+          },
+          params: {
+            path: {
+              editor: "editor",
+              value: "steps['cvxzwBfXPZhH1RbmmxBdG']['outputs']['output']",
+            },
+          },
+          disabled: false,
+        },
+      ],
+    },
+  };
+
+  return {
+    data,
+    hightlight: true,
+  };
+};