@pipelab/core-node 1.0.1-beta.23

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,299 @@
+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: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";

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,70 @@
+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,
+        };
+        ws.send(JSON.stringify(response), (error) => {
+          if (error) {
+            logger().error("Failed to send WebSocket response:", error);
+          }
+        });
+        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";