@pipelab/core-node 1.0.0-beta.0

package/src/handlers/engine.ts

@@ -0,0 +1,229 @@
+import { useAPI, HandleListenerSendFn } from "../ipc-core";
+import { PipelabContext } from "../context";
+import { useLogger } from "@pipelab/shared";
+import { getFinalPlugins, executeGraphWithHistory } from "../utils";
+import { presets } from "../presets/list";
+import { handleActionExecute, handleConditionExecute } from "../handler-func";
+import { generateTempFolder } from "../utils/fs-extras";
+import { tmpdir } from "node:os";
+import { setupConfigFile } from "../config";
+import { AppConfig } from "@pipelab/shared";
+
+export const registerEngineHandlers = (context: PipelabContext) => {
+  const { handle } = useAPI();
+  const { logger } = useLogger();
+
+  handle("nodes:get", async (_, { send }) => {
+    const finalPlugins = getFinalPlugins();
+    send({
+      type: "end",
+      data: {
+        type: "success",
+        result: {
+          nodes: finalPlugins,
+        },
+      },
+    });
+  });
+
+  handle("presets:get", async (_, { send }) => {
+    const presetData = await presets();
+    send({
+      type: "end",
+      data: {
+        type: "success",
+        result: presetData,
+      },
+    });
+  });
+
+  handle("condition:execute", async (_, { value }) => {
+    const { nodeId, params, pluginId } = value;
+    const cwd = await generateTempFolder(tmpdir());
+    await handleConditionExecute(nodeId, pluginId, params, cwd, context);
+  });
+
+  let abortControllerGraph: undefined | AbortController = undefined;
+
+  const effectiveActionExecute = async (
+    nodeId: string,
+    pluginId: string,
+    params: Record<string, string>,
+    mainWindow: any | undefined,
+    send: HandleListenerSendFn<"action:execute">,
+    cwd: string,
+    cachePath: string,
+  ) => {
+    try {
+      const result = await handleActionExecute(
+        nodeId,
+        pluginId,
+        params,
+        mainWindow,
+        send,
+        abortControllerGraph!.signal,
+        cwd,
+        cachePath,
+        context,
+      );
+
+      await send({
+        data: result,
+        type: "end",
+      });
+    } catch (e) {
+      console.error("Error during action execution:", e);
+      await send({
+        type: "end",
+        data: {
+          ipcError: e instanceof Error ? e.message : "Unknown error",
+          type: "error",
+        },
+      });
+    }
+  };
+
+  handle("action:execute", async (event, { send, value }) => {
+    const { nodeId, params, pluginId } = value;
+    const settings = await setupConfigFile<AppConfig>("settings", { context });
+    const config = await settings.getConfig();
+
+    const cachePath = config?.cacheFolder || tmpdir();
+    const cwd = await generateTempFolder(cachePath);
+
+    const mainWindow = undefined;
+    abortControllerGraph = new AbortController();
+
+    const signalPromise = new Promise((resolve, reject) => {
+      abortControllerGraph!.signal.addEventListener("abort", async () => {
+        await send({
+          type: "end",
+          data: {
+            ipcError: "Action aborted",
+            type: "error",
+          },
+        });
+        return reject(new Error("Action interrupted"));
+      });
+    });
+
+    await Promise.race([
+      signalPromise,
+      effectiveActionExecute(nodeId, pluginId, params, mainWindow, send, cwd, cachePath),
+    ]);
+  });
+
+  handle("constants:get", async (_, { send }) => {
+    const userData = context.userDataPath;
+    send({
+      type: "end",
+      data: {
+        type: "success",
+        result: {
+          result: {
+            userData,
+          },
+        },
+      },
+    });
+  });
+
+  handle("action:cancel", async (_, { send }) => {
+    if (abortControllerGraph) {
+      abortControllerGraph.abort("Interrupted by user");
+    }
+    send({
+      type: "end",
+      data: {
+        type: "success",
+        result: {
+          result: "ok",
+        },
+      },
+    });
+  });
+
+  handle("graph:execute", async (event, { send, value }) => {
+    const { graph, variables, projectName, projectPath, pipelineId } = value;
+    const settings = await setupConfigFile<AppConfig>("settings", { context });
+    const config = await settings.getConfig();
+
+    const effectiveProjectName = projectName || "Unnamed Project";
+    const effectiveProjectPath = projectPath || "";
+    const effectivePipelineId = pipelineId || "unknown";
+    const effectiveCachePath = config?.cacheFolder || tmpdir();
+
+    const mainWindow = undefined;
+    abortControllerGraph = new AbortController();
+
+    try {
+      const { result, buildId } = await executeGraphWithHistory({
+        graph,
+        variables,
+        projectName: effectiveProjectName,
+        projectPath: effectiveProjectPath,
+        pipelineId: effectivePipelineId,
+        mainWindow,
+        onNodeEnter: (node) => {
+          send({
+            type: "node-enter",
+            data: {
+              nodeUid: node.uid,
+              nodeName: node.name,
+            },
+          });
+        },
+        onNodeExit: (node) => {
+          send({
+            type: "node-exit",
+            data: {
+              nodeUid: node.uid,
+              nodeName: node.name,
+            },
+          });
+        },
+        onLog: (data, node) => {
+          if (data.type === "log") {
+            const sanitizedData = {
+              message: data.data.message,
+              timestamp: data.data.time,
+            };
+            send({
+              type: "node-log",
+              data: {
+                nodeUid: node?.uid || "unknown",
+                logData: sanitizedData,
+              },
+            });
+          }
+        },
+        abortSignal: abortControllerGraph!.signal,
+        cachePath: effectiveCachePath,
+        context,
+      });
+
+      send({
+        type: "end",
+        data: {
+          type: "success",
+          result: {
+            result,
+            buildId,
+          },
+        },
+      });
+    } catch (e) {
+      console.error("Graph execution failed:", e);
+      logger().error("Graph execution failed:", e);
+      const isCanceled = e instanceof Error && e.name === "AbortError";
+      send({
+        type: "end",
+        data: {
+          type: "error",
+          code: isCanceled ? "canceled" : "error",
+          ipcError: e instanceof Error ? e.message : "Unknown error",
+        },
+      });
+    }
+  });
+};

package/src/handlers/fs.ts

@@ -0,0 +1,97 @@
+import { useAPI } from "../ipc-core";
+import { useLogger } from "@pipelab/shared";
+import { writeFile, readFile, readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+
+import { PipelabContext } from "../context";
+
+export const registerFsHandlers = (_context: PipelabContext) => {
+  const { handle } = useAPI();
+  const { logger } = useLogger();
+
+  handle("fs:read", async (event, { value, send }) => {
+    logger().info("fs:read", value.path);
+
+    try {
+      const data = await readFile(value.path, "utf-8");
+      logger().info("fs:read success, content length:", data.length);
+
+      send({
+        type: "end",
+        data: {
+          type: "success",
+          result: {
+            content: data,
+          },
+        },
+      });
+    } catch (e) {
+      logger().error("fs:read error for path:", value.path, e);
+      send({
+        type: "end",
+        data: {
+          type: "error",
+          ipcError: "Unable to read file",
+        },
+      });
+    }
+  });
+
+  handle("fs:write", async (event, { value, send }) => {
+    await writeFile(value.path, value.content, "utf-8");
+
+    send({
+      type: "end",
+      data: {
+        type: "success",
+        result: {
+          ok: true,
+        },
+      },
+    });
+  });
+
+  handle("fs:listDirectory", async (event, { value, send }) => {
+    try {
+      const entries = await readdir(value.path, { withFileTypes: true });
+      const files = await Promise.all(
+        entries.map(async (entry) => {
+          const fullPath = join(value.path, entry.name);
+          let stats: any = {};
+          try {
+            stats = await stat(fullPath);
+          } catch (e) {
+            // Might happen for broken symlinks etc
+          }
+
+          return {
+            name: entry.name,
+            isDirectory: entry.isDirectory(),
+            isSymbolicLink: entry.isSymbolicLink(),
+            size: stats.size || 0,
+            mtime: stats.mtime?.getTime() || 0,
+          };
+        }),
+      );
+
+      send({
+        type: "end",
+        data: {
+          type: "success",
+          result: {
+            files,
+          },
+        },
+      });
+    } catch (error) {
+      logger().error("Failed to list directory:", error);
+      send({
+        type: "end",
+        data: {
+          type: "error",
+          ipcError: error instanceof Error ? error.message : "Unable to list directory",
+        },
+      });
+    }
+  });
+};

package/src/handlers/history.ts

@@ -0,0 +1,329 @@
+import { useAPI, WsEvent } from "../ipc-core";
+import { useLogger, AppConfig } from "@pipelab/shared";
+import { BuildHistoryStorage } from "./build-history";
+import { SubscriptionRequiredError } from "@pipelab/shared";
+import { PipelabContext } from "../context";
+import { setupConfigFile } from "../config";
+
+// Helper function to check build history authorization
+const checkBuildHistoryAuthorization = async (event: WsEvent): Promise<boolean> => {
+  const { logger } = useLogger();
+  logger().info("AUTH BYPASS: Skipping auth verification for build history access");
+
+  // Always authorize for now - relying on frontend auth checks only
+  const isAuthorized = true;
+
+  if (!isAuthorized) {
+    throw new SubscriptionRequiredError("build-history");
+  }
+
+  return true;
+};
+
+export const registerHistoryHandlers = (context: PipelabContext) => {
+  const { handle } = useAPI();
+  const { logger } = useLogger();
+  const buildHistoryStorage = new BuildHistoryStorage(context);
+
+  // Build History Handlers
+  handle("build-history:save", async (event, { send, value }) => {
+    try {
+      // Check authorization before allowing save
+      logger().info("AUTH BYPASS: Processing build-history:save request");
+      await checkBuildHistoryAuthorization(event);
+
+      await buildHistoryStorage.save(value.entry);
+      send({
+        type: "end",
+        data: {
+          type: "success",
+          result: { result: "ok" },
+        },
+      });
+    } catch (error) {
+      logger().error("Failed to save build history entry:", error);
+
+      if (error instanceof SubscriptionRequiredError) {
+        send({
+          type: "end",
+          data: { type: "error", ipcError: error.userMessage, code: error.code },
+        });
+        return;
+      }
+
+      send({
+        type: "end",
+        data: {
+          type: "error",
+          ipcError: error instanceof Error ? error.message : "Failed to save build history entry",
+        },
+      });
+    }
+  });
+
+  handle("build-history:get", async (event, { send, value }) => {
+    try {
+      logger().info("AUTH BYPASS: Processing build-history:get request");
+      await checkBuildHistoryAuthorization(event);
+
+      const entry = await buildHistoryStorage.get(value.id, value.pipelineId);
+      send({
+        type: "end",
+        data: { type: "success", result: { entry } },
+      });
+    } catch (error) {
+      logger().error("Failed to get build history entry:", error);
+
+      if (error instanceof SubscriptionRequiredError) {
+        send({
+          type: "end",
+          data: { type: "error", ipcError: error.userMessage, code: error.code },
+        });
+        return;
+      }
+
+      send({
+        type: "end",
+        data: {
+          type: "error",
+          ipcError: error instanceof Error ? error.message : "Failed to get build history entry",
+        },
+      });
+    }
+  });
+
+  handle("build-history:get-all", async (event, { send, value }) => {
+    try {
+      logger().info("AUTH BYPASS: Processing build-history:get-all request");
+      await checkBuildHistoryAuthorization(event);
+
+      const allEntries = await buildHistoryStorage.getAll();
+      const filteredEntries = value?.query?.pipelineId
+        ? allEntries.filter((entry) => entry.pipelineId === value?.query?.pipelineId)
+        : allEntries;
+
+      send({
+        type: "end",
+        data: {
+          type: "success",
+          result: {
+            entries: filteredEntries,
+            total: filteredEntries.length,
+          },
+        },
+      });
+    } catch (error) {
+      logger().error("Failed to get build history entries:", error);
+
+      if (error instanceof SubscriptionRequiredError) {
+        send({
+          type: "end",
+          data: { type: "error", ipcError: error.userMessage, code: error.code },
+        });
+        return;
+      }
+
+      send({
+        type: "end",
+        data: {
+          type: "error",
+          ipcError:
+            error instanceof Error ? error.message : "Failed to get build history entries",
+        },
+      });
+    }
+  });
+
+  handle("build-history:update", async (event, { send, value }) => {
+    try {
+      await checkBuildHistoryAuthorization(event);
+
+      await buildHistoryStorage.update(value.id, value.updates, value.pipelineId);
+      send({
+        type: "end",
+        data: { type: "success", result: { result: "ok" } },
+      });
+    } catch (error) {
+      logger().error("Failed to update build history entry:", error);
+
+      if (error instanceof SubscriptionRequiredError) {
+        send({
+          type: "end",
+          data: { type: "error", ipcError: error.userMessage, code: error.code },
+        });
+        return;
+      }
+
+      send({
+        type: "end",
+        data: {
+          type: "error",
+          ipcError:
+            error instanceof Error ? error.message : "Failed to update build history entry",
+        },
+      });
+    }
+  });
+
+  handle("build-history:delete", async (event, { send, value }) => {
+    try {
+      await checkBuildHistoryAuthorization(event);
+
+      await buildHistoryStorage.delete(value.id, value.pipelineId);
+      send({
+        type: "end",
+        data: { type: "success", result: { result: "ok" } },
+      });
+    } catch (error) {
+      logger().error("Failed to delete build history entry:", error);
+
+      if (error instanceof SubscriptionRequiredError) {
+        send({
+          type: "end",
+          data: { type: "error", ipcError: error.userMessage, code: error.code },
+        });
+        return;
+      }
+
+      send({
+        type: "end",
+        data: {
+          type: "error",
+          ipcError:
+            error instanceof Error ? error.message : "Failed to delete build history entry",
+        },
+      });
+    }
+  });
+
+  handle("build-history:clear", async (event, { send }) => {
+    try {
+      await checkBuildHistoryAuthorization(event);
+
+      await buildHistoryStorage.clear();
+      send({
+        type: "end",
+        data: { type: "success", result: { result: "ok" } },
+      });
+    } catch (error) {
+      logger().error("Failed to clear build history:", error);
+
+      if (error instanceof SubscriptionRequiredError) {
+        send({
+          type: "end",
+          data: { type: "error", ipcError: error.userMessage, code: error.code },
+        });
+        return;
+      }
+
+      send({
+        type: "end",
+        data: {
+          type: "error",
+          ipcError: error instanceof Error ? error.message : "Failed to clear build history",
+        },
+      });
+    }
+  });
+
+  handle("build-history:clear-by-pipeline", async (event, { send, value }) => {
+    try {
+      await checkBuildHistoryAuthorization(event);
+
+      await buildHistoryStorage.clearByPipeline(value.pipelineId);
+      send({
+        type: "end",
+        data: { type: "success", result: { result: "ok" } },
+      });
+    } catch (error) {
+      logger().error(`Failed to clear build history for pipeline ${value.pipelineId}:`, error);
+
+      if (error instanceof SubscriptionRequiredError) {
+        send({
+          type: "end",
+          data: { type: "error", ipcError: error.userMessage, code: error.code },
+        });
+        return;
+      }
+
+      send({
+        type: "end",
+        data: {
+          type: "error",
+          ipcError: error instanceof Error ? error.message : "Failed to clear build history for pipeline",
+        },
+      });
+    }
+  });
+
+  handle("build-history:get-storage-info", async (event, { send }) => {
+    try {
+      await checkBuildHistoryAuthorization(event);
+
+      const info = await buildHistoryStorage.getStorageInfo();
+      send({
+        type: "end",
+        data: { type: "success", result: info },
+      });
+    } catch (error) {
+      logger().error("Failed to get build history storage info:", error);
+
+      if (error instanceof SubscriptionRequiredError) {
+        send({
+          type: "end",
+          data: { type: "error", ipcError: error.userMessage, code: error.code },
+        });
+        return;
+      }
+
+      send({
+        type: "end",
+        data: {
+          type: "error",
+          ipcError:
+            error instanceof Error ? error.message : "Failed to get build history storage info",
+        },
+      });
+    }
+  });
+
+  handle("build-history:configure", async (_, { send, value }) => {
+    try {
+      logger().info("Updating build history configuration:", value.config);
+      
+      const settings = await setupConfigFile<AppConfig>("settings", { context });
+      const currentConfig = await settings.getConfig();
+
+      // Deep merge the new config with the existing one
+      const newConfig = {
+        ...currentConfig,
+        buildHistory: {
+          ...currentConfig?.buildHistory,
+          retentionPolicy: {
+            ...currentConfig?.buildHistory?.retentionPolicy,
+            ...value.config.retentionPolicy,
+          },
+        },
+      };
+
+      await settings.saveConfig(newConfig);
+
+      send({
+        type: "end",
+        data: {
+          type: "success",
+          result: { result: "ok" },
+        },
+      });
+    } catch (error) {
+      logger().error("Failed to configure build history:", error);
+      send({
+        type: "end",
+        data: {
+          type: "error",
+          ipcError: error instanceof Error ? error.message : "Failed to configure build history",
+        },
+      });
+    }
+  });
+};

package/src/handlers/index.ts

@@ -0,0 +1,41 @@
+import { registerShellHandlers } from "./shell";
+import { registerFsHandlers } from "./fs";
+import { registerConfigHandlers } from "./config";
+import { registerHistoryHandlers } from "./history";
+import { registerEngineHandlers } from "./engine";
+import { registerAgentsHandlers } from "./agents";
+import { registerAuthHandlers } from "./auth";
+import { registerSystemHandlers } from "./system";
+import { builtInPlugins } from "../plugins-registry";
+import { usePlugins } from "@pipelab/shared";
+import { PipelabContext } from "../context";
+
+export const registerAllHandlers = async (options: {
+  version: string;
+  context: PipelabContext;
+}) => {
+  const context = options.context;
+
+  registerShellHandlers(context);
+  registerFsHandlers(context);
+  registerConfigHandlers(context);
+  registerHistoryHandlers(context);
+  registerEngineHandlers(context);
+  registerAgentsHandlers(context);
+  registerAuthHandlers(context);
+  registerSystemHandlers(options);
+
+  const { registerPlugins } = usePlugins();
+  const plugins = await builtInPlugins({
+    context,
+  });
+  registerPlugins(plugins as any);
+};
+
+export { registerShellHandlers } from "./shell";
+export { registerFsHandlers } from "./fs";
+export { registerConfigHandlers } from "./config";
+export { registerHistoryHandlers } from "./history";
+export { registerEngineHandlers } from "./engine";
+export { registerAgentsHandlers } from "./agents";
+export { BuildHistoryStorage } from "./build-history";