@pipelab/core-node 1.0.0-beta.17 → 1.0.0-beta.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipelab/core-node",
-  "version": "1.0.0-beta.17",
+  "version": "1.0.0-beta.18",
   "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.15",
-    "@pipelab/shared": "1.0.0-beta.13"
+    "@pipelab/constants": "1.0.0-beta.16",
+    "@pipelab/shared": "1.0.0-beta.14"
   },
   "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.13"
+    "@pipelab/tsconfig": "1.0.0-beta.14"
   },
   "scripts": {
     "build": "tsdown",

package/src/config.test.ts

@@ -38,9 +38,9 @@ describe("setupConfigFile & Backup Creation", () => {
     // 1. Setup V1 configuration file in the context's config path
     const configDir = context.getConfigPath();
     await fs.mkdir(configDir, { recursive: true });
-    
+
     const projectsFilePath = path.join(configDir, "projects.json");
-    
+
     const v1Config = {
       version: "1.0.0",
       data: {
@@ -49,10 +49,10 @@ describe("setupConfigFile & Backup Creation", () => {
           type: "internal",
           configName: "pipeline-1",
           lastModified: "2026-06-04",
-        }
-      }
+        },
+      },
     };
-    
+
     await fs.writeFile(projectsFilePath, JSON.stringify(v1Config));
 
     // 2. Initialize setupConfigFile
@@ -64,11 +64,11 @@ describe("setupConfigFile & Backup Creation", () => {
     // 3. Retrieve config (this triggers the migration process and onStep callback)
     const migratedConfig = await configInstance.getConfig();
 
-    // 4. Assert the main config is updated on disk to version 2.0.0
-    expect(migratedConfig.version).toBe("2.0.0");
-    
+    // 4. Assert the main config is updated on disk to version 3.0.0
+    expect(migratedConfig.version).toBe("3.0.0");
+
     const updatedContent = JSON.parse(await fs.readFile(projectsFilePath, "utf8"));
-    expect(updatedContent.version).toBe("2.0.0");
+    expect(updatedContent.version).toBe("3.0.0");
 
     // 5. Assert that the intermediate backup file was created on disk
     const backupFilePath = path.join(configDir, "projects.v2.0.0.json");
@@ -92,7 +92,7 @@ describe("setupConfigFile & Backup Creation", () => {
     // Should create file with default value
     expect(existsSync(projectsFilePath)).toBe(true);
     const content = JSON.parse(await fs.readFile(projectsFilePath, "utf8"));
-    expect(content.version).toBe("2.0.0");
+    expect(content.version).toBe("3.0.0");
     expect(content.projects).toHaveLength(1);
     expect(content.pipelines).toEqual([]);
   });
@@ -107,13 +107,15 @@ describe("setupConfigFile & Backup Creation", () => {
     const configInstance = await setupConfigFile<FileRepo>("projects", { context });
     const config = await configInstance.getConfig();
 
-    expect(config.version).toBe("2.0.0");
+    expect(config.version).toBe("3.0.0");
     expect(config.projects).toHaveLength(1);
     expect(config.pipelines).toEqual([]);
 
     // Verify a timestamped corrupted backup file exists
     const files = await fs.readdir(configDir);
-    const corruptedFile = files.find(f => f.startsWith("projects.corrupted.") && f.endsWith(".json"));
+    const corruptedFile = files.find(
+      (f) => f.startsWith("projects.corrupted.") && f.endsWith(".json"),
+    );
     expect(corruptedFile).toBeDefined();
     const corruptedContent = await fs.readFile(path.join(configDir, corruptedFile!), "utf8");
     expect(corruptedContent).toBe("{ corrupted json... }");
@@ -143,9 +145,13 @@ describe("setupConfigFile & Backup Creation", () => {
 
     // Verify a timestamped corrupted backup file exists
     const files = await fs.readdir(configDir);
-    const corruptedFile = files.find(f => f.startsWith("projects.corrupted.") && f.endsWith(".json"));
+    const corruptedFile = files.find(
+      (f) => f.startsWith("projects.corrupted.") && f.endsWith(".json"),
+    );
     expect(corruptedFile).toBeDefined();
-    const corruptedContent = JSON.parse(await fs.readFile(path.join(configDir, corruptedFile!), "utf8"));
+    const corruptedContent = JSON.parse(
+      await fs.readFile(path.join(configDir, corruptedFile!), "utf8"),
+    );
     expect(corruptedContent.invalidData).toBe(true);
   });
 
@@ -169,7 +175,9 @@ describe("setupConfigFile & Backup Creation", () => {
     const success = await configInstance.setConfig(newConfig);
     expect(success).toBe(true);
 
-    const savedContent = JSON.parse(await fs.readFile(path.join(context.getConfigPath(), "projects.json"), "utf8"));
+    const savedContent = JSON.parse(
+      await fs.readFile(path.join(context.getConfigPath(), "projects.json"), "utf8"),
+    );
     expect(savedContent.pipelines).toHaveLength(1);
     expect(savedContent.pipelines[0].id).toBe("pipeline-new");
   });

package/src/config.ts

@@ -3,7 +3,7 @@ import path from "node:path";
 import { ensure } from "./utils/fs-extras";
 import fs from "node:fs/promises";
 import { useLogger } from "@pipelab/shared";
-import { configRegistry, Migrator, normalizePipelineConfig } from "@pipelab/shared";
+import { configRegistry, Migrator } from "@pipelab/shared";
 
 export const getMigrator = <T>(name: string) => {
   return (configRegistry[name] || configRegistry["pipeline"]) as Migrator<T>;
@@ -62,12 +62,15 @@ export const setupConfigFile = async <T>(
             debug: false,
             onStep: async (state: any, version: string) => {
               const parsedPath = path.parse(filesPath);
-              const versionedPath = path.join(parsedPath.dir, `${parsedPath.name}.v${version}.json`);
+              const versionedPath = ctx.getConfigPath(`${parsedPath.name}.v${version}.json`);
               try {
                 await fs.writeFile(versionedPath, JSON.stringify(state));
                 logger().info(`Intermediate backup created for ${name} at ${versionedPath}`);
               } catch (e) {
-                logger().error(`Failed to create intermediate backup for ${name} at v${version}:`, e);
+                logger().error(
+                  `Failed to create intermediate backup for ${name} at v${version}:`,
+                  e,
+                );
               }
             },
           });
@@ -80,36 +83,23 @@ export const setupConfigFile = async <T>(
         json = migrator.defaultValue;
       }
 
-      let normalized = false;
-      const isPipeline =
-        name.startsWith("pipeline-") ||
-        path.isAbsolute(name) ||
-        name.endsWith(".json") ||
-        name === "pipeline";
-      if (isPipeline) {
-        normalized = normalizePipelineConfig(json);
-      }
-
       const originalVersion = originalJson?.version;
       const newVersion = json?.version;
 
       const shouldSaveBack =
-        originalVersion !== newVersion ||
-        normalized ||
-        content === undefined ||
-        parseFailed ||
-        migrationFailed;
+        originalVersion !== newVersion || content === undefined || parseFailed || migrationFailed;
 
       if (shouldSaveBack) {
         if (parseFailed || migrationFailed) {
           try {
             const parsedPath = path.parse(filesPath);
             const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-            const corruptedPath = path.join(
-              parsedPath.dir,
+            const corruptedPath = ctx.getConfigPath(
               `${parsedPath.name}.corrupted.${timestamp}.json`,
             );
-            const backupContent = parseFailed ? (content || "") : JSON.stringify(originalJson, null, 2);
+            const backupContent = parseFailed
+              ? content || ""
+              : JSON.stringify(originalJson, null, 2);
             await fs.writeFile(corruptedPath, backupContent);
             logger().info(`Corrupted config file preserved at ${corruptedPath}`);
           } catch (e) {
@@ -128,3 +118,10 @@ export const setupConfigFile = async <T>(
     },
   };
 };
+
+export const deleteConfigFile = async (nameOrPath: string, context: PipelabContext) => {
+  const isAbsolutePath = path.isAbsolute(nameOrPath);
+  const filesPath = isAbsolutePath ? nameOrPath : context.getConfigPath(`${nameOrPath}.json`);
+
+  await fs.rm(filesPath, { force: true });
+};

package/src/context.ts

@@ -51,6 +51,14 @@ function findProjectRoot(startDir: string): string | null {
 
 export const projectRoot = findProjectRoot(_dirname);
 
+export const CacheFolder = {
+  Actions: "actions",
+  Pipelines: "pipelines",
+  Pacote: "pacote",
+} as const;
+
+export type CacheFolderType = (typeof CacheFolder)[keyof typeof CacheFolder];
+
 export interface PipelabContextOptions {
   userDataPath: string;
   releaseTag?: string;
@@ -88,14 +96,23 @@ export class PipelabContext {
     return await mkdtemp(join(realBaseDir, prefix));
   }
 
-  getCachePath(...subpaths: string[]) {
-    return join(this.userDataPath, "cache", ...subpaths);
+  getCachePath(): string;
+  getCachePath(folder: CacheFolderType, ...subpaths: string[]): string;
+  getCachePath(folder?: CacheFolderType, ...subpaths: string[]) {
+    if (!folder) {
+      return join(this.userDataPath, "cache");
+    }
+    return join(this.userDataPath, "cache", folder, ...subpaths);
   }
 
   getPnpmPath(...subpaths: string[]) {
     return join(this.userDataPath, "pnpm", ...subpaths);
   }
 
+  getBuildHistoryPath(...subpaths: string[]) {
+    return join(this.userDataPath, "build-history", ...subpaths);
+  }
+
   getNodePath(version = DEFAULT_NODE_VERSION) {
     const isWindows = process.platform === "win32";
     return this.getThirdPartyPath("node", version, isWindows ? "node.exe" : "bin/node");

package/src/handlers/build-history.ts

@@ -1,8 +1,7 @@
 import { PipelabContext } from "../context";
 import { join } from "node:path";
-import { writeFile, readFile, unlink, mkdir, stat, readdir } from "node:fs/promises";
+import { writeFile, readFile, unlink, mkdir, stat, readdir, rm } from "node:fs/promises";
 import { useLogger, BuildHistoryEntry, IBuildHistoryStorage, AppConfig } from "@pipelab/shared";
-import { setupConfigFile } from "../config";
 import checkDiskSpace from "check-disk-space";
 import { getFolderSize } from "../utils/fs-extras";
 import { SandboxFolder } from "@pipelab/constants";
@@ -17,18 +16,11 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
   }
 
   private getStoragePath() {
-    return join(this.context.userDataPath, "build-history");
+    return this.context.getConfigPath("pipelines");
   }
 
   private getPipelinePath(pipelineId: string): string {
-    // Sanitize the pipelineId to create a valid filename
-    // Replace invalid filename characters with underscores
-    const sanitizedId = pipelineId
-      .replace(/[/\:*?"<>|]/g, "_")
-      .replace(/__/g, "_") // Replace multiple underscores with single
-      .replace(/^_+|_+$/g, ""); // Remove leading/trailing underscores
-
-    return join(this.getStoragePath(), `pipeline-${sanitizedId}.json`);
+    return join(this.getStoragePath(), `${pipelineId}.history.json`);
   }
 
   private async ensureStoragePath(): Promise<void> {
@@ -65,51 +57,6 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
     }
   }
 
-  async applyRetentionPolicy(): Promise<void> {
-    try {
-      this.logger.logger().info("Applying build history retention policy...");
-      const settings = await setupConfigFile<AppConfig>("settings", { context: this.context });
-      const config = await settings.getConfig();
-      const policy = config?.buildHistory?.retentionPolicy;
-
-      if (!policy || !policy.enabled) {
-        this.logger.logger().info("Retention policy is disabled. Skipping.");
-        return;
-      }
-
-      const { maxAge, maxEntries } = policy;
-      const pipelineFiles = await this.getAllPipelineFiles();
-
-      for (const file of pipelineFiles) {
-        const pipelineId = file.replace("pipeline-", "").replace(".json", "");
-        let entries = await this.loadPipelineHistory(pipelineId);
-        const originalCount = entries.length;
-
-        // 1. Filter by maxAge
-        if (maxAge > 0) {
-          const minDate = Date.now() - maxAge * 24 * 60 * 60 * 1000;
-          entries = entries.filter((entry) => entry.createdAt >= minDate);
-        }
-
-        // 2. Filter by maxEntries (sort by date first to keep the newest)
-        if (maxEntries > 0 && entries.length > maxEntries) {
-          entries = entries.sort((a, b) => b.createdAt - a.createdAt).slice(0, maxEntries);
-        }
-
-        if (entries.length < originalCount) {
-          this.logger
-            .logger()
-            .info(`[${pipelineId}] Pruned ${originalCount - entries.length} history entries.`);
-          await this.savePipelineHistory(pipelineId, entries);
-        }
-      }
-      this.logger.logger().info("Retention policy applied successfully.");
-    } catch (error) {
-      this.logger.logger().error("Failed to apply retention policy:", error);
-      // We don't re-throw here as this is a background task and shouldn't crash the app
-    }
-  }
-
   async save(entry: BuildHistoryEntry): Promise<void> {
     try {
       const entries = await this.loadPipelineHistory(entry.pipelineId);
@@ -125,11 +72,6 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
       this.logger
         .logger()
         .info(`Saved build history entry: ${entry.id} for pipeline: ${entry.pipelineId}`);
-
-      // Apply retention policy after each save
-      this.applyRetentionPolicy().catch((err) => {
-        this.logger.logger().error("Failed to apply retention policy after save:", err);
-      });
     } catch (error) {
       this.logger.logger().error("Failed to save build history entry:", error);
       throw new Error(`Failed to save build history entry: ${error}`);
@@ -145,7 +87,8 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
 
       const files = await this.getAllPipelineFiles();
       for (const file of files) {
-        const pId = file.replace("pipeline-", "").replace(".json", "");
+        const pId = this.parsePipelineIdFromFilename(file);
+        if (!pId) continue;
         const entries = await this.loadPipelineHistory(pId);
         const entry = entries.find((e) => e.id === id);
         if (entry) return entry;
@@ -162,7 +105,8 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
       const files = await this.getAllPipelineFiles();
       const allEntries: BuildHistoryEntry[] = [];
       for (const file of files) {
-        const pipelineId = file.replace("pipeline-", "").replace(".json", "");
+        const pipelineId = this.parsePipelineIdFromFilename(file);
+        if (!pipelineId) continue;
         const entries = await this.loadPipelineHistory(pipelineId);
         allEntries.push(...entries);
       }
@@ -200,7 +144,8 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
       } else {
         const files = await this.getAllPipelineFiles();
         for (const file of files) {
-          const pId = file.replace("pipeline-", "").replace(".json", "");
+          const pId = this.parsePipelineIdFromFilename(file);
+          if (!pId) continue;
           const entries = await this.loadPipelineHistory(pId);
           const entryIndex = entries.findIndex((e) => e.id === id);
           if (entryIndex >= 0) {
@@ -231,7 +176,8 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
       } else {
         const files = await this.getAllPipelineFiles();
         for (const file of files) {
-          const pId = file.replace("pipeline-", "").replace(".json", "");
+          const pId = this.parsePipelineIdFromFilename(file);
+          if (!pId) continue;
           const entries = await this.loadPipelineHistory(pId);
           const entryIndex = entries.findIndex((e) => e.id === id);
           if (entryIndex >= 0) {
@@ -253,8 +199,26 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
     try {
       await this.ensureStoragePath();
       const files = await this.getAllPipelineFiles();
-      await Promise.all(files.map((file) => unlink(join(this.getStoragePath(), file))));
+      const cachePathsToDelete = new Set<string>();
+
+      for (const file of files) {
+        const pipelineId = this.parsePipelineIdFromFilename(file);
+        if (pipelineId) {
+          const entries = await this.loadPipelineHistory(pipelineId);
+          for (const entry of entries) {
+            if (entry.cachePath) {
+              cachePathsToDelete.add(entry.cachePath);
+            }
+          }
+        }
+        await unlink(join(this.getStoragePath(), file));
+      }
+
       this.logger.logger().info("Cleared all build history");
+
+      for (const cachePath of cachePathsToDelete) {
+        await rm(cachePath, { recursive: true, force: true }).catch(() => {});
+      }
     } catch (error) {
       this.logger.logger().error("Failed to clear build history:", error);
       throw new Error(`Failed to clear build history: ${error}`);
@@ -264,8 +228,19 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
   async clearByPipeline(pipelineId: string): Promise<void> {
     try {
       const pipelinePath = this.getPipelinePath(pipelineId);
+      const entries = await this.loadPipelineHistory(pipelineId);
       await unlink(pipelinePath);
       this.logger.logger().info(`Cleared history for pipeline "${pipelineId}"`);
+
+      const cachePathsToDelete = new Set<string>();
+      for (const entry of entries) {
+        if (entry.cachePath) {
+          cachePathsToDelete.add(entry.cachePath);
+        }
+      }
+      for (const cachePath of cachePathsToDelete) {
+        await rm(cachePath, { recursive: true, force: true }).catch(() => {});
+      }
     } catch (error: any) {
       if (error.code === "ENOENT") {
         this.logger
@@ -285,11 +260,6 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
     newestEntry?: number;
     numberOfPipelines: number;
     userDataPath: string;
-    retentionPolicy: {
-      enabled: boolean;
-      maxEntries: number;
-      maxAge: number;
-    };
     disk: {
       total: number;
       free: number;
@@ -314,25 +284,12 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
         });
       }
 
-      const settings = await setupConfigFile<AppConfig>("settings", { context: this.context });
-      const config = await settings.getConfig();
-      const policy = config?.buildHistory?.retentionPolicy || {
-        enabled: false,
-        maxEntries: 50,
-        maxAge: 30,
-      };
-
       if (allEntries.length === 0) {
         return {
           totalEntries: 0,
           totalSize: 0,
           numberOfPipelines: files.length,
           userDataPath: this.context.userDataPath,
-          retentionPolicy: {
-            enabled: policy.enabled,
-            maxEntries: policy.maxEntries,
-            maxAge: policy.maxAge,
-          },
           disk: {
             total: diskSpace.size,
             free: diskSpace.free,
@@ -362,11 +319,6 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
         newestEntry: sortedEntries[sortedEntries.length - 1]?.createdAt,
         numberOfPipelines: files.length,
         userDataPath: this.context.userDataPath,
-        retentionPolicy: {
-          enabled: policy.enabled,
-          maxEntries: policy.maxEntries,
-          maxAge: policy.maxAge,
-        },
         disk: {
           total: diskSpace.size,
           free: diskSpace.free,
@@ -384,9 +336,14 @@ export class BuildHistoryStorage implements IBuildHistoryStorage {
     try {
       await this.ensureStoragePath();
       const files = await readdir(this.getStoragePath());
-      return files.filter((file) => file.startsWith("pipeline-") && file.endsWith(".json"));
+      return files.filter((file) => file.endsWith(".history.json"));
     } catch (error) {
       return [];
     }
   }
+
+  private parsePipelineIdFromFilename(filename: string): string | null {
+    const match = filename.match(/^(.+)\.history\.json$/);
+    return match ? match[1] : null;
+  }
 }

package/src/handlers/config.ts

@@ -1,6 +1,6 @@
 import { useAPI } from "../ipc-core";
 import { useLogger, configRegistry } from "@pipelab/shared";
-import { setupConfigFile, getMigrator } from "../config";
+import { setupConfigFile, getMigrator, deleteConfigFile } from "../config";
 import { PipelabContext } from "../context";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -114,26 +114,7 @@ export const registerConfigHandlers = (context: PipelabContext) => {
     logger().info("config:delete", name);
 
     try {
-      // Config could be an absolute path (for external files/pipelines)
-      // or a name/identifier (for internal config files stored in Pipelab's app data directory).
-      const isAbsolutePath = path.isAbsolute(name);
-      const filesPath = isAbsolutePath ? name : context.getConfigPath(`${name}.json`);
-
-      await fs.rm(filesPath, { force: true });
-
-      // Clean up versioned backups too
-      const parsedPath = path.parse(filesPath);
-      const dirEntries = await fs.readdir(parsedPath.dir).catch(() => [] as string[]);
-      const prefix = `${parsedPath.name}.v`;
-      const suffix = `.json`;
-      for (const entry of dirEntries) {
-        if (entry.startsWith(prefix) && entry.endsWith(suffix)) {
-          const backupPath = path.join(parsedPath.dir, entry);
-          await fs.rm(backupPath, { force: true }).catch((err) => {
-            logger().error(`Failed to delete backup ${backupPath}:`, err);
-          });
-        }
-      }
+      await deleteConfigFile(name, context);
 
       send({
         type: "end",

package/src/handlers/engine.ts

@@ -1,10 +1,11 @@
 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 } from "../handler-func";
 import { join } from "node:path";
+import { rm } from "node:fs/promises";
 import { setupConfigFile } from "../config";
 import { AppConfig } from "@pipelab/shared";
 
@@ -78,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 = join(context.userDataPath, "cache", "actions", pluginId, nodeId);
+    const cachePath = context.getCachePath(CacheFolder.Actions, pluginId, nodeId);
     const cwd = await context.createTempFolder("action-execute-");
 
-    const mainWindow: undefined = 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 }) => {
@@ -144,7 +148,7 @@ export const registerEngineHandlers = (context: PipelabContext) => {
     const effectiveProjectName = projectName || "Unnamed Project";
     const effectiveProjectPath = projectPath || "";
     const effectivePipelineId = pipelineId || "unknown";
-    const effectiveCachePath = join(context.userDataPath, "cache", effectivePipelineId);
+    const effectiveCachePath = context.getCachePath(CacheFolder.Pipelines, effectivePipelineId);
 
     const mainWindow: undefined = undefined;
     abortControllerGraph = new AbortController();

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.setConfig(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",
-        },
-      });
-    }
-  });
 };