@pipelab/core-node 1.0.0-beta.2 → 1.0.0-beta.22

package/src/handlers/config.ts

@@ -1,108 +1,318 @@
 import { useAPI } from "../ipc-core";
-import { useLogger, configRegistry } from "@pipelab/shared";
-import { setupConfigFile, getMigrator } from "../config";
+import {
+  useLogger,
+  appSettingsMigrator,
+  connectionsMigrator,
+  fileRepoMigrations,
+} from "@pipelab/shared";
+import {
+  setupSettingsConfigFile,
+  setupConnectionsConfigFile,
+  setupProjectsConfigFile,
+  setupPipelineConfigFileByName,
+  setupPipelineConfigFileByPath,
+  deletePipelineConfigFileByName,
+  deletePipelineConfigFileByPath,
+} from "../config";
 import { PipelabContext } from "../context";
 
 export const registerConfigHandlers = (context: PipelabContext) => {
   const { handle } = useAPI();
   const { logger } = useLogger();
 
-  handle("config:load", async (_, { send, value }) => {
-    const { config: name } = value;
-    logger().info("config:load", name);
-
+  // Settings
+  handle("settings:load", async (_, { send }) => {
+    logger().info("settings:load");
     try {
-      const manager = await setupConfigFile(name, { context });
+      const manager = await setupSettingsConfigFile(context);
       const json = await manager.getConfig();
-
       send({
         type: "end",
-        data: {
-          type: "success",
-          result: {
-            result: json,
-          },
-        },
+        data: { type: "success", result: json },
       });
     } catch (e) {
-      logger().error(`config:load error for ${name}:`, e);
+      logger().error("settings:load error:", e);
       send({
         type: "end",
-        data: {
-          type: "error",
-          ipcError: e instanceof Error ? e.message : `Unable to load config ${name}`,
-        },
+        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to load settings" },
       });
     }
   });
 
-  handle("config:save", async (_, { send, value }) => {
-    const { data, config: name } = value;
-
+  handle("settings:save", async (_, { send, value }) => {
+    const { data } = value;
     try {
-      const manager = await setupConfigFile(name, { context });
+      const manager = await setupSettingsConfigFile(context);
       const json = typeof data === "string" ? JSON.parse(data) : data;
       await manager.setConfig(json);
+      send({
+        type: "end",
+        data: { type: "success", result: "ok" },
+      });
+    } catch (e) {
+      logger().error("settings:save error:", e);
+      send({
+        type: "end",
+        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to save settings" },
+      });
+    }
+  });
 
+  handle("settings:reset", async (_, { send, value }) => {
+    const { key } = value;
+    try {
+      const manager = await setupSettingsConfigFile(context);
+      const currentConfig = await manager.getConfig();
+      const defaultValue = (appSettingsMigrator.defaultValue as any)[key];
+      await manager.setConfig({
+        ...(currentConfig ? (currentConfig as any) : {}),
+        [key]: defaultValue,
+      } as any);
       send({
         type: "end",
-        data: {
-          type: "success",
-          result: {
-            result: "ok",
-          },
-        },
+        data: { type: "success", result: "ok" },
       });
     } catch (e) {
-      logger().error(`config:save error for ${name}:`, e);
+      logger().error("settings:reset error:", e);
       send({
         type: "end",
-        data: {
-          type: "error",
-          ipcError: e instanceof Error ? e.message : `Unable to save config ${name}`,
-        },
+        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to reset settings" },
       });
     }
   });
 
-  handle("config:reset", async (event, { value, send }) => {
-    const { config: name, key } = value;
-    logger().info("config:reset", name, key);
+  // Connections
+  handle("connections:load", async (_, { send }) => {
+    logger().info("connections:load");
+    try {
+      const manager = await setupConnectionsConfigFile(context);
+      const json = await manager.getConfig();
+      send({
+        type: "end",
+        data: { type: "success", result: json },
+      });
+    } catch (e) {
+      logger().error("connections:load error:", e);
+      send({
+        type: "end",
+        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to load connections" },
+      });
+    }
+  });
 
+  handle("connections:save", async (_, { send, value }) => {
+    const { data } = value;
     try {
-      const manager = await setupConfigFile(name, { context });
-      const currentConfig = await manager.getConfig();
+      const manager = await setupConnectionsConfigFile(context);
+      const json = typeof data === "string" ? JSON.parse(data) : data;
+      await manager.setConfig(json);
+      send({
+        type: "end",
+        data: { type: "success", result: "ok" },
+      });
+    } catch (e) {
+      logger().error("connections:save error:", e);
+      send({
+        type: "end",
+        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to save connections" },
+      });
+    }
+  });
 
-      const migrator = getMigrator(name);
+  handle("connections:reset", async (_, { send, value }) => {
+    const { key } = value;
+    try {
+      const manager = await setupConnectionsConfigFile(context);
+      const currentConfig = await manager.getConfig();
+      const defaultValue = (connectionsMigrator.defaultValue as any)[key];
+      await manager.setConfig({
+        ...(currentConfig ? (currentConfig as any) : {}),
+        [key]: defaultValue,
+      } as any);
+      send({
+        type: "end",
+        data: { type: "success", result: "ok" },
+      });
+    } catch (e) {
+      logger().error("connections:reset error:", e);
+      send({
+        type: "end",
+        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to reset connections" },
+      });
+    }
+  });
 
-      if (!migrator) {
-        throw new Error(`No migrator found for configuration: ${name}`);
-      }
+  // Projects
+  handle("projects:load", async (_, { send }) => {
+    logger().info("projects:load");
+    try {
+      const manager = await setupProjectsConfigFile(context);
+      const json = await manager.getConfig();
+      send({
+        type: "end",
+        data: { type: "success", result: json },
+      });
+    } catch (e) {
+      logger().error("projects:load error:", e);
+      send({
+        type: "end",
+        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to load projects" },
+      });
+    }
+  });
 
-      const defaultValue = (migrator.defaultValue as any)[key];
+  handle("projects:save", async (_, { send, value }) => {
+    const { data } = value;
+    try {
+      const manager = await setupProjectsConfigFile(context);
+      const json = typeof data === "string" ? JSON.parse(data) : data;
+      await manager.setConfig(json);
+      send({
+        type: "end",
+        data: { type: "success", result: "ok" },
+      });
+    } catch (e) {
+      logger().error("projects:save error:", e);
+      send({
+        type: "end",
+        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to save projects" },
+      });
+    }
+  });
 
+  handle("projects:reset", async (_, { send, value }) => {
+    const { key } = value;
+    try {
+      const manager = await setupProjectsConfigFile(context);
+      const currentConfig = await manager.getConfig();
+      const defaultValue = (fileRepoMigrations.defaultValue as any)[key];
       await manager.setConfig({
         ...(currentConfig ? (currentConfig as any) : {}),
         [key]: defaultValue,
       } as any);
+      send({
+        type: "end",
+        data: { type: "success", result: "ok" },
+      });
+    } catch (e) {
+      logger().error("projects:reset error:", e);
+      send({
+        type: "end",
+        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to reset projects" },
+      });
+    }
+  });
+
+  // Pipeline (ByName)
+  handle("pipeline:load-by-name", async (_, { send, value }) => {
+    const { name } = value;
+    logger().info("pipeline:load-by-name", name);
+    try {
+      const manager = await setupPipelineConfigFileByName(name, context);
+      const json = await manager.getConfig();
+      send({
+        type: "end",
+        data: { type: "success", result: json },
+      });
+    } catch (e) {
+      logger().error(`pipeline:load-by-name error for ${name}:`, e);
+      send({
+        type: "end",
+        data: { type: "error", ipcError: e instanceof Error ? e.message : `Unable to load pipeline ${name}` },
+      });
+    }
+  });
+
+  // Pipeline (ByPath)
+  handle("pipeline:load-by-path", async (_, { send, value }) => {
+    const { path: absolutePath } = value;
+    logger().info("pipeline:load-by-path", absolutePath);
+    try {
+      const manager = await setupPipelineConfigFileByPath(absolutePath, context);
+      const json = await manager.getConfig();
+      send({
+        type: "end",
+        data: { type: "success", result: json },
+      });
+    } catch (e) {
+      logger().error(`pipeline:load-by-path error for ${absolutePath}:`, e);
+      send({
+        type: "end",
+        data: { type: "error", ipcError: e instanceof Error ? e.message : `Unable to load pipeline ${absolutePath}` },
+      });
+    }
+  });
 
+  handle("pipeline:save-by-name", async (_, { send, value }) => {
+    const { data, name } = value;
+    try {
+      const manager = await setupPipelineConfigFileByName(name, context);
+      const json = typeof data === "string" ? JSON.parse(data) : data;
+      await manager.setConfig(json);
+      send({
+        type: "end",
+        data: { type: "success", result: "ok" },
+      });
+    } catch (e) {
+      logger().error(`pipeline:save-by-name error for ${name}:`, e);
+      send({
+        type: "end",
+        data: { type: "error", ipcError: e instanceof Error ? e.message : `Unable to save pipeline ${name}` },
+      });
+    }
+  });
+
+  handle("pipeline:save-by-path", async (_, { send, value }) => {
+    const { data, path: absolutePath } = value;
+    try {
+      const manager = await setupPipelineConfigFileByPath(absolutePath, context);
+      const json = typeof data === "string" ? JSON.parse(data) : data;
+      await manager.setConfig(json);
+      send({
+        type: "end",
+        data: { type: "success", result: "ok" },
+      });
+    } catch (e) {
+      logger().error(`pipeline:save-by-path error for ${absolutePath}:`, e);
+      send({
+        type: "end",
+        data: { type: "error", ipcError: e instanceof Error ? e.message : `Unable to save pipeline ${absolutePath}` },
+      });
+    }
+  });
+
+  handle("pipeline:delete-by-name", async (_, { send, value }) => {
+    const { name } = value;
+    logger().info("pipeline:delete-by-name", name);
+    try {
+      await deletePipelineConfigFileByName(name, context);
+      send({
+        type: "end",
+        data: { type: "success", result: "ok" },
+      });
+    } catch (e) {
+      logger().error(`pipeline:delete-by-name error for ${name}:`, e);
+      send({
+        type: "end",
+        data: { type: "error", ipcError: e instanceof Error ? e.message : `Unable to delete pipeline ${name}` },
+      });
+    }
+  });
+
+  handle("pipeline:delete-by-path", async (_, { send, value }) => {
+    const { path: absolutePath } = value;
+    logger().info("pipeline:delete-by-path", absolutePath);
+    try {
+      await deletePipelineConfigFileByPath(absolutePath, context);
       send({
         type: "end",
-        data: {
-          type: "success",
-          result: {
-            result: "ok",
-          },
-        },
+        data: { type: "success", result: "ok" },
       });
     } catch (e) {
-      logger().error(`config:reset error for ${name}:`, e);
+      logger().error(`pipeline:delete-by-path error for ${absolutePath}:`, e);
       send({
         type: "end",
-        data: {
-          type: "error",
-          ipcError: e instanceof Error ? e.message : `Unable to reset config ${name}`,
-        },
+        data: { type: "error", ipcError: e instanceof Error ? e.message : `Unable to delete pipeline ${absolutePath}` },
       });
     }
   });

package/src/handlers/engine.ts

@@ -1,12 +1,12 @@
 import { useAPI, HandleListenerSendFn } from "../ipc-core";
-import { PipelabContext } from "../context";
+import { PipelabContext, CacheFolder } 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 { handleActionExecute } from "../handler-func";
+import { join } from "node:path";
+import { rm } from "node:fs/promises";
+import { setupSettingsConfigFile } from "../config";
 import { AppConfig } from "@pipelab/shared";
 
 export const registerEngineHandlers = (context: PipelabContext) => {
@@ -37,12 +37,6 @@ export const registerEngineHandlers = (context: PipelabContext) => {
     });
   });
 
-  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 (
@@ -85,32 +79,35 @@ export const registerEngineHandlers = (context: PipelabContext) => {
 
   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 = context.getCachePath(CacheFolder.Actions, pluginId, nodeId);
+    const cwd = await context.createTempFolder("action-execute-");
 
-    const cachePath = config?.cacheFolder || tmpdir();
-    const cwd = await generateTempFolder(cachePath);
-
-    const mainWindow = undefined;
-    abortControllerGraph = new AbortController();
+    try {
+      const mainWindow: undefined = 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",
-          },
+      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"));
         });
-        return reject(new Error("Action interrupted"));
       });
-    });
 
-    await Promise.race([
-      signalPromise,
-      effectiveActionExecute(nodeId, pluginId, params, mainWindow, send, cwd, cachePath),
-    ]);
+      await Promise.race([
+        signalPromise,
+        effectiveActionExecute(nodeId, pluginId, params, mainWindow, send, cwd, cachePath),
+      ]);
+    } finally {
+      await rm(cwd, { recursive: true, force: true }).catch((err) => {
+        console.warn(`Failed to cleanup temp folder at ${cwd}:`, err);
+      });
+    }
   });
 
   handle("constants:get", async (_, { send }) => {
@@ -145,15 +142,15 @@ export const registerEngineHandlers = (context: PipelabContext) => {
 
   handle("graph:execute", async (event, { send, value }) => {
     const { graph, variables, projectName, projectPath, pipelineId } = value;
-    const settings = await setupConfigFile<AppConfig>("settings", { context });
+    const settings = await setupSettingsConfigFile(context);
     const config = await settings.getConfig();
 
     const effectiveProjectName = projectName || "Unnamed Project";
     const effectiveProjectPath = projectPath || "";
     const effectivePipelineId = pipelineId || "unknown";
-    const effectiveCachePath = config?.cacheFolder || tmpdir();
+    const effectiveCachePath = context.getCachePath(CacheFolder.Pipelines, effectivePipelineId);
 
-    const mainWindow = undefined;
+    const mainWindow: undefined = undefined;
     abortControllerGraph = new AbortController();
 
     try {

package/src/handlers/history.ts

@@ -284,44 +284,4 @@ export const registerHistoryHandlers = (context: PipelabContext) => {
       });
     }
   });
-
-  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

@@ -6,6 +6,8 @@ import { registerEngineHandlers } from "./engine";
 import { registerAgentsHandlers } from "./agents";
 import { registerAuthHandlers } from "./auth";
 import { registerSystemHandlers } from "./system";
+import { registerPluginsHandlers } from "./plugins";
+import { registerMigrationHandlers } from "./migration";
 import { builtInPlugins } from "../plugins-registry";
 import { usePlugins } from "@pipelab/shared";
 import { PipelabContext } from "../context";
@@ -24,6 +26,8 @@ export const registerAllHandlers = async (options: {
   registerAgentsHandlers(context);
   registerAuthHandlers(context);
   registerSystemHandlers(options);
+  registerPluginsHandlers(context);
+  registerMigrationHandlers(context);
 
   const { registerPlugins } = usePlugins();
   // Execute in the background! The plugins will be dynamically registered and broadcasted to the UI.