@pipelab/core-node 1.0.0-beta.21 → 1.0.0-beta.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipelab/core-node",
-  "version": "1.0.0-beta.21",
+  "version": "1.0.0-beta.25",
   "private": false,
   "description": "The Pipelab automation engine for Node.js",
   "license": "FSL-1.1-MIT",
@@ -40,8 +40,8 @@
     "type-fest": "4.39.0",
     "ws": "8.18.3",
     "yauzl": "2.10.0",
-    "@pipelab/constants": "1.0.0-beta.19",
-    "@pipelab/shared": "1.0.0-beta.17"
+    "@pipelab/constants": "1.0.0-beta.23",
+    "@pipelab/shared": "1.0.0-beta.21"
   },
   "devDependencies": {
     "@types/adm-zip": "0.5.7",
@@ -56,7 +56,7 @@
     "tsdown": "0.21.2",
     "typescript": "^5.0.0",
     "vitest": "3.1.4",
-    "@pipelab/tsconfig": "1.0.0-beta.17"
+    "@pipelab/tsconfig": "1.0.0-beta.21"
   },
   "scripts": {
     "build": "tsdown",

package/src/config.test.ts

@@ -180,9 +180,7 @@ describe("setupConfigFile & Backup Creation", () => {
     const success = await configInstance.setConfig(newConfig);
     expect(success).toBe(true);
 
-    const savedContent = JSON.parse(
-      await fs.readFile(context.getProjectsPath(), "utf8"),
-    );
+    const savedContent = JSON.parse(await fs.readFile(context.getProjectsPath(), "utf8"));
     expect(savedContent.pipelines).toHaveLength(1);
     expect(savedContent.pipelines[0].id).toBe("pipeline-new");
   });
@@ -229,4 +227,3 @@ describe("deletePipelineConfigFile", () => {
     await expect(deletePipelineConfigFileByName("does-not-exist", context)).resolves.not.toThrow();
   });
 });
-

package/src/config.ts

@@ -59,10 +59,15 @@ export const setupConfigFile = async <T>(
           json = await migrator.migrate(originalJson, {
             debug: false,
             onStep: async (state: any, version: string) => {
-              const versionedPath = path.join(parsedPath.dir, `${parsedPath.name}.v${version}.json`);
+              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 ${parsedPath.name} at ${versionedPath}`);
+                logger().info(
+                  `Intermediate backup created for ${parsedPath.name} at ${versionedPath}`,
+                );
               } catch (e) {
                 logger().error(
                   `Failed to create intermediate backup for ${parsedPath.name} at v${version}:`,
@@ -161,6 +166,9 @@ export const deletePipelineConfigFileByName = async (name: string, context: Pipe
   await deleteConfigFile(filesPath);
 };
 
-export const deletePipelineConfigFileByPath = async (absolutePath: string, context: PipelabContext) => {
+export const deletePipelineConfigFileByPath = async (
+  absolutePath: string,
+  context: PipelabContext,
+) => {
   await deleteConfigFile(absolutePath);
 };

package/src/context.ts

@@ -66,6 +66,12 @@ export interface PipelabContextOptions {
   releaseTag?: string;
 }
 
+type Join<T extends string[], D extends string> =
+  T extends [] ? "" :
+  T extends [infer F extends string] ? F :
+  T extends [infer F extends string, ...infer R extends string[]] ? `${F}${D}${Join<R, D>}` :
+  string;
+
 export class PipelabContext {
   public readonly userDataPath: string;
   public readonly releaseTag: string;
@@ -75,27 +81,30 @@ export class PipelabContext {
     this.releaseTag = options.releaseTag || "latest";
   }
 
-  getPackagesPath(...subpaths: string[]) {
+  getPackagesPath<S extends string[]>(...subpaths: S): `PACKAGES/${Join<S, "/">}`;
+  getPackagesPath(...subpaths: string[]): string {
     return join(this.userDataPath, "packages", ...subpaths);
   }
 
-  getThirdPartyPath(...subpaths: string[]) {
+  getThirdPartyPath<S extends string[]>(...subpaths: S): `THIRDPARTY/${Join<S, "/">}`;
+  getThirdPartyPath(...subpaths: string[]): string {
     return join(this.userDataPath, "thirdparty", ...subpaths);
   }
 
-  getConfigPath(...subpaths: string[]) {
+  getConfigPath<S extends string[]>(...subpaths: S): `CONFIG/${Join<S, "/">}`;
+  getConfigPath(...subpaths: string[]): string {
     return join(this.userDataPath, "config", ...subpaths);
   }
 
-  getSettingsPath() {
+  getSettingsPath(): `CONFIG/settings.json` {
     return this.getConfigPath("settings.json");
   }
 
-  getConnectionsPath() {
+  getConnectionsPath(): `CONFIG/connections.json` {
     return this.getConfigPath("connections.json");
   }
 
-  getProjectsPath() {
+  getProjectsPath(): `CONFIG/projects.json` {
     return this.getConfigPath("projects.json");
   }
 
@@ -121,22 +130,24 @@ export class PipelabContext {
     }
   }
 
-  getTempPath(...subpaths: string[]) {
+  getTempPath<S extends string[]>(...subpaths: S): `TEMP/${Join<S, "/">}`;
+  getTempPath(...subpaths: string[]): string {
     const settings = this.getSettings();
     const base = settings?.tempFolder || join(this.userDataPath, "temp");
     return join(base, ...subpaths);
   }
 
-  async createTempFolder(prefix = "pipelab-") {
+  createTempFolder<T extends string = "pipelab-">(prefix?: T): Promise<`TEMP/${T}${string}`>;
+  async createTempFolder(prefix = "pipelab-"): Promise<string> {
     const baseDir = this.getTempPath();
     await mkdir(baseDir, { recursive: true });
     const realBaseDir = await realpath(baseDir);
-    return await mkdtemp(join(realBaseDir, prefix));
+    return mkdtemp(join(realBaseDir, prefix));
   }
 
-  getCachePath(): string;
-  getCachePath(folder: CacheFolderType, ...subpaths: string[]): string;
-  getCachePath(folder?: CacheFolderType, ...subpaths: string[]) {
+  getCachePath(): `CACHE/`;
+  getCachePath<F extends CacheFolderType, S extends string[]>(folder: F, ...subpaths: S): `CACHE/${F}/${Join<S, "/">}`;
+  getCachePath(folder?: CacheFolderType, ...subpaths: string[]): string {
     const settings = this.getSettings();
     const base = settings?.cacheFolder || join(this.userDataPath, "cache");
     if (!folder) {
@@ -145,20 +156,24 @@ export class PipelabContext {
     return join(base, folder, ...subpaths);
   }
 
-  getPnpmPath(...subpaths: string[]) {
+  getPnpmPath<S extends string[]>(...subpaths: S): `PNPM/${Join<S, "/">}`;
+  getPnpmPath(...subpaths: string[]): string {
     return join(this.userDataPath, "pnpm", ...subpaths);
   }
 
-  getBuildHistoryPath(...subpaths: string[]) {
+  getBuildHistoryPath<S extends string[]>(...subpaths: S): `BUILD_HISTORY/${Join<S, "/">}`;
+  getBuildHistoryPath(...subpaths: string[]): string {
     return join(this.userDataPath, "build-history", ...subpaths);
   }
 
-  getNodePath(version = DEFAULT_NODE_VERSION) {
+  getNodePath<V extends string = typeof DEFAULT_NODE_VERSION>(version?: V): `THIRDPARTY/node/${V}/${string}`;
+  getNodePath(version = DEFAULT_NODE_VERSION): string {
     const isWindows = process.platform === "win32";
     return this.getThirdPartyPath("node", version, isWindows ? "node.exe" : "bin/node");
   }
 
-  getPnpmBinPath(version = DEFAULT_PNPM_VERSION) {
+  getPnpmBinPath<V extends string = typeof DEFAULT_PNPM_VERSION>(version?: V): `PACKAGES/pnpm/${V}/bin/pnpm.cjs`;
+  getPnpmBinPath(version = DEFAULT_PNPM_VERSION): string {
     return this.getPackagesPath("pnpm", version, "bin", "pnpm.cjs");
   }
 

package/src/fs-utils.test.ts

@@ -0,0 +1,125 @@
+import { describe, test, expect } from "vitest";
+import { homedir } from "node:os";
+import { resolve, join } from "node:path";
+import slash from "slash";
+import { isPathBlacklisted } from "./fs-utils";
+import { getDefaultUserDataPath, projectRoot } from "./context";
+
+const isWindows = process.platform === "win32";
+
+describe("isPathBlacklisted", () => {
+  test("should return false for empty or falsy paths", () => {
+    expect(isPathBlacklisted("")).toBe(false);
+    expect(isPathBlacklisted(undefined as any)).toBe(false);
+    expect(isPathBlacklisted(null as any)).toBe(false);
+  });
+
+  test("should return false for safe user workspace paths", () => {
+    const safePath = join(homedir(), "my-custom-projects", "project-1");
+    expect(isPathBlacklisted(safePath)).toBe(false);
+  });
+
+  test("should blacklist user home directory", () => {
+    expect(isPathBlacklisted(homedir())).toBe(true);
+    expect(isPathBlacklisted(homedir() + "/")).toBe(true);
+  });
+
+  test.skipIf(isWindows)("should blacklist common system paths on Unix-like systems", () => {
+    // These Unix paths are checked as absolute paths starting with /
+    expect(isPathBlacklisted("/usr")).toBe(true);
+    expect(isPathBlacklisted("/var")).toBe(true);
+    expect(isPathBlacklisted("/etc")).toBe(true);
+    expect(isPathBlacklisted("/bin")).toBe(true);
+    expect(isPathBlacklisted("/sbin")).toBe(true);
+    expect(isPathBlacklisted("/lib")).toBe(true);
+    expect(isPathBlacklisted("/lib64")).toBe(true);
+    expect(isPathBlacklisted("/boot")).toBe(true);
+    expect(isPathBlacklisted("/sys")).toBe(true);
+    expect(isPathBlacklisted("/proc")).toBe(true);
+    expect(isPathBlacklisted("/dev")).toBe(true);
+    expect(isPathBlacklisted("/run")).toBe(true);
+    expect(isPathBlacklisted("/home")).toBe(true);
+    expect(isPathBlacklisted("/root")).toBe(true);
+    expect(isPathBlacklisted("/mnt")).toBe(true);
+    expect(isPathBlacklisted("/media")).toBe(true);
+    expect(isPathBlacklisted("/srv")).toBe(true);
+    expect(isPathBlacklisted("/applications")).toBe(true);
+    expect(isPathBlacklisted("/library")).toBe(true);
+    expect(isPathBlacklisted("/system")).toBe(true);
+    expect(isPathBlacklisted("/volumes")).toBe(true);
+    expect(isPathBlacklisted("/snap")).toBe(true);
+    expect(isPathBlacklisted("/")).toBe(true);
+  });
+
+  test.runIf(isWindows)(
+    "should blacklist common Windows directories dynamically on any drive (Windows-only)",
+    () => {
+      // Windows drive roots
+      expect(isPathBlacklisted("c:")).toBe(true);
+      expect(isPathBlacklisted("d:")).toBe(true);
+      expect(isPathBlacklisted("Z:")).toBe(true);
+      expect(isPathBlacklisted("C:\\")).toBe(true);
+      expect(isPathBlacklisted("d:/")).toBe(true);
+
+      // Windows system directories on any drive letter
+      expect(isPathBlacklisted("c:/windows")).toBe(true);
+      expect(isPathBlacklisted("D:\\Windows\\")).toBe(true);
+      expect(isPathBlacklisted("e:/program files")).toBe(true);
+      expect(isPathBlacklisted("f:/program files (x86)")).toBe(true);
+      expect(isPathBlacklisted("g:/users")).toBe(true);
+      expect(isPathBlacklisted("h:/programdata")).toBe(true);
+      expect(isPathBlacklisted("i:/perflogs")).toBe(true);
+
+      // Should NOT blacklist normal subfolders on other drives
+      expect(isPathBlacklisted("d:/my-folder")).toBe(false);
+      expect(isPathBlacklisted("c:/windows-backup")).toBe(false);
+    },
+  );
+
+  test("should blacklist standard user profile directories", () => {
+    expect(isPathBlacklisted(join(homedir(), "Downloads"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), "Documents"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), "Desktop"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), "Pictures"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), "Music"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), "Videos"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), "Saved Games"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), "Contacts"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), "Searches"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), "Links"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), "3D Objects"))).toBe(true);
+  });
+
+  test("should blacklist developer settings and credentials", () => {
+    expect(isPathBlacklisted(join(homedir(), ".ssh"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), ".gnupg"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), ".aws"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), ".docker"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), ".kube"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), ".vscode"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), ".cursor"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), ".npm"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), ".pnpm-state"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), ".yarn"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), ".cargo"))).toBe(true);
+    expect(isPathBlacklisted(join(homedir(), ".rustup"))).toBe(true);
+  });
+
+  test("should blacklist Pipelab-specific directories", () => {
+    expect(isPathBlacklisted(getDefaultUserDataPath("prod"))).toBe(true);
+    expect(isPathBlacklisted(getDefaultUserDataPath("dev"))).toBe(true);
+    expect(isPathBlacklisted(getDefaultUserDataPath("beta"))).toBe(true);
+    if (projectRoot) {
+      expect(isPathBlacklisted(projectRoot)).toBe(true);
+    }
+    expect(isPathBlacklisted(process.cwd())).toBe(true);
+  });
+
+  test("should handle case-insensitive paths and slash normalization", () => {
+    const mixedPath = join(homedir(), "DoWnLoAdS");
+    expect(isPathBlacklisted(mixedPath)).toBe(true);
+
+    const trailingSlashPath = homedir() + "/";
+    expect(isPathBlacklisted(trailingSlashPath)).toBe(true);
+  });
+});

package/src/fs-utils.ts

@@ -0,0 +1,142 @@
+import { homedir } from "node:os";
+import { resolve, join } from "node:path";
+import slash from "slash";
+
+function removeTrailingSlash(path: string): string {
+  return path.replace(/[\\/]+$/, "");
+}
+
+function isWindowsDriveRoot(path: string): boolean {
+  return /^[a-z]:$/.test(path);
+}
+
+import { getDefaultUserDataPath, projectRoot } from "./context";
+
+const windowsSystemFolders = [
+  "windows",
+  "program files",
+  "program files (x86)",
+  "users",
+  "programdata",
+  "perflogs",
+];
+
+function isWindowsSystemDirectory(path: string): boolean {
+  const driveRoot = path.substring(0, 2);
+  if (!isWindowsDriveRoot(driveRoot) || path.charAt(2) !== "/") return false;
+  const folder = path.substring(3);
+  return windowsSystemFolders.includes(folder);
+}
+
+// Static Unix/Linux/macOS system directories (normalized)
+const unixSystemDirectories = new Set([
+  "", // represents "/" after removeTrailingSlash
+  "/usr",
+  "/var",
+  "/opt",
+  "/etc",
+  "/bin",
+  "/sbin",
+  "/lib",
+  "/lib64",
+  "/boot",
+  "/sys",
+  "/proc",
+  "/dev",
+  "/run",
+  "/home",
+  "/root",
+  "/mnt",
+  "/media",
+  "/srv",
+  "/applications",
+  "/library",
+  "/system",
+  "/volumes",
+  "/snap",
+]);
+
+// Statically resolved home directory, user directories, temp directories, and Pipelab's AppData
+const homeDirectory = removeTrailingSlash(slash(resolve(homedir()))).toLowerCase();
+
+const additionalProtectedPaths = [
+  // Pipelab user data directories (dev, beta, prod)
+  getDefaultUserDataPath("dev"),
+  getDefaultUserDataPath("beta"),
+  getDefaultUserDataPath("prod"),
+  // Pipelab source directory if available
+  projectRoot,
+  // Current working directory of the process
+  process.cwd(),
+  // System temp directories
+  "/tmp",
+  "/var/tmp",
+  process.env.TEMP,
+  process.env.TMP,
+  // Windows AppData roots
+  join(homedir(), "AppData"),
+  join(homedir(), "AppData", "Local"),
+  join(homedir(), "AppData", "Roaming"),
+  // macOS / Unix config roots
+  join(homedir(), "Library"),
+  join(homedir(), "Library", "Application Support"),
+  join(homedir(), ".config"),
+  join(homedir(), ".local"),
+  join(homedir(), ".local", "share"),
+  join(homedir(), ".cache"),
+  // Cloud directories
+  join(homedir(), "OneDrive"),
+  join(homedir(), "Dropbox"),
+  // Critical SSH/GPG credentials folders
+  join(homedir(), ".ssh"),
+  join(homedir(), ".gnupg"),
+  // Developer CLI configurations
+  join(homedir(), ".aws"),
+  join(homedir(), ".docker"),
+  join(homedir(), ".kube"),
+  // IDE environments
+  join(homedir(), ".vscode"),
+  join(homedir(), ".vscode-insiders"),
+  join(homedir(), ".cursor"),
+  // Package manager / toolchain directories
+  join(homedir(), ".npm"),
+  join(homedir(), ".pnpm-state"),
+  join(homedir(), ".yarn"),
+  join(homedir(), ".cargo"),
+  join(homedir(), ".rustup"),
+  join(homedir(), ".m2"),
+  join(homedir(), ".gradle"),
+].filter((p): p is string => typeof p === "string" && p.length > 0);
+
+const userSubdirectories = new Set(
+  [
+    join(homedir(), "Downloads"),
+    join(homedir(), "Documents"),
+    join(homedir(), "Desktop"),
+    join(homedir(), "Pictures"),
+    join(homedir(), "Music"),
+    join(homedir(), "Videos"),
+    join(homedir(), "Saved Games"),
+    join(homedir(), "Contacts"),
+    join(homedir(), "Searches"),
+    join(homedir(), "Links"),
+    join(homedir(), "3D Objects"),
+    ...additionalProtectedPaths,
+  ].map((p) => removeTrailingSlash(slash(resolve(p))).toLowerCase()),
+);
+
+/**
+ * Checks if a path matches a critical user or system directory.
+ */
+export function isPathBlacklisted(pathToCheck: string): boolean {
+  if (!pathToCheck) return false;
+  const normalized = removeTrailingSlash(slash(resolve(pathToCheck))).toLowerCase();
+
+  return (
+    normalized === homeDirectory ||
+    unixSystemDirectories.has(normalized) ||
+    userSubdirectories.has(normalized) ||
+    isWindowsDriveRoot(normalized) ||
+    isWindowsSystemDirectory(normalized)
+  );
+}

package/src/handler-func.ts

@@ -100,14 +100,27 @@ export const handleActionExecute = async (
       inputs: resolvedInputs,
       log: (...args) => {
         const decorator = `[${node.node.name}]`;
-        const logArgs = [decorator, ...args];
+        const formattedArgs = args.map((arg) => {
+          if (arg instanceof Error) {
+            return arg.stack || arg.message || String(arg);
+          }
+          if (typeof arg === "object" && arg !== null) {
+            try {
+              return JSON.stringify(arg, null, 2);
+            } catch {
+              return String(arg);
+            }
+          }
+          return arg;
+        });
+        const logArgs = [decorator, ...formattedArgs];
         logger().info(...logArgs);
         send({
           type: "log",
           data: {
             decorator,
             time: Date.now(),
-            message: args,
+            message: formattedArgs,
           },
         });
       },

package/src/handlers/config.ts

@@ -34,7 +34,10 @@ export const registerConfigHandlers = (context: PipelabContext) => {
       logger().error("settings:load error:", e);
       send({
         type: "end",
-        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to load settings" },
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : "Unable to load settings",
+        },
       });
     }
   });
@@ -53,7 +56,10 @@ export const registerConfigHandlers = (context: PipelabContext) => {
       logger().error("settings:save error:", e);
       send({
         type: "end",
-        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to save settings" },
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : "Unable to save settings",
+        },
       });
     }
   });
@@ -76,7 +82,10 @@ export const registerConfigHandlers = (context: PipelabContext) => {
       logger().error("settings:reset error:", e);
       send({
         type: "end",
-        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to reset settings" },
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : "Unable to reset settings",
+        },
       });
     }
   });
@@ -95,7 +104,10 @@ export const registerConfigHandlers = (context: PipelabContext) => {
       logger().error("connections:load error:", e);
       send({
         type: "end",
-        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to load connections" },
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : "Unable to load connections",
+        },
       });
     }
   });
@@ -114,7 +126,10 @@ export const registerConfigHandlers = (context: PipelabContext) => {
       logger().error("connections:save error:", e);
       send({
         type: "end",
-        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to save connections" },
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : "Unable to save connections",
+        },
       });
     }
   });
@@ -137,7 +152,10 @@ export const registerConfigHandlers = (context: PipelabContext) => {
       logger().error("connections:reset error:", e);
       send({
         type: "end",
-        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to reset connections" },
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : "Unable to reset connections",
+        },
       });
     }
   });
@@ -156,7 +174,10 @@ export const registerConfigHandlers = (context: PipelabContext) => {
       logger().error("projects:load error:", e);
       send({
         type: "end",
-        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to load projects" },
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : "Unable to load projects",
+        },
       });
     }
   });
@@ -175,7 +196,10 @@ export const registerConfigHandlers = (context: PipelabContext) => {
       logger().error("projects:save error:", e);
       send({
         type: "end",
-        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to save projects" },
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : "Unable to save projects",
+        },
       });
     }
   });
@@ -198,7 +222,10 @@ export const registerConfigHandlers = (context: PipelabContext) => {
       logger().error("projects:reset error:", e);
       send({
         type: "end",
-        data: { type: "error", ipcError: e instanceof Error ? e.message : "Unable to reset projects" },
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : "Unable to reset projects",
+        },
       });
     }
   });
@@ -218,7 +245,10 @@ export const registerConfigHandlers = (context: PipelabContext) => {
       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}` },
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : `Unable to load pipeline ${name}`,
+        },
       });
     }
   });
@@ -238,7 +268,10 @@ export const registerConfigHandlers = (context: PipelabContext) => {
       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}` },
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : `Unable to load pipeline ${absolutePath}`,
+        },
       });
     }
   });
@@ -257,7 +290,10 @@ export const registerConfigHandlers = (context: PipelabContext) => {
       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}` },
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : `Unable to save pipeline ${name}`,
+        },
       });
     }
   });
@@ -276,7 +312,10 @@ export const registerConfigHandlers = (context: PipelabContext) => {
       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}` },
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : `Unable to save pipeline ${absolutePath}`,
+        },
       });
     }
   });
@@ -294,7 +333,10 @@ export const registerConfigHandlers = (context: PipelabContext) => {
       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}` },
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : `Unable to delete pipeline ${name}`,
+        },
       });
     }
   });
@@ -312,7 +354,10 @@ export const registerConfigHandlers = (context: PipelabContext) => {
       logger().error(`pipeline:delete-by-path error for ${absolutePath}:`, e);
       send({
         type: "end",
-        data: { type: "error", ipcError: e instanceof Error ? e.message : `Unable to delete pipeline ${absolutePath}` },
+        data: {
+          type: "error",
+          ipcError: e instanceof Error ? e.message : `Unable to delete pipeline ${absolutePath}`,
+        },
       });
     }
   });