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

package/dist/index.mjs

@@ -1,19 +1,16 @@
+import { a as setupPipelineConfigFileByName, c as setupSettingsConfigFile, d as extractTarGz, f as extractZip, h as zipFolder, i as setupConnectionsConfigFile, l as downloadFile, m as runWithLiveLogs, n as deletePipelineConfigFileByPath, o as setupPipelineConfigFileByPath, p as getFolderSize, s as setupProjectsConfigFile, t as deletePipelineConfigFileByName, u as ensure } from "./config-CFgGRD9U.mjs";
 import { createRequire } from "node:module";
 import path, { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
 import { homedir, platform } from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import fs, { createWriteStream, existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import fs, { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import fs$1, { access, chmod, cp, mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { DEFAULT_NODE_VERSION, DEFAULT_PNPM_VERSION, SandboxFolder, getUiDevServerMissingWarning, uiDevPort, websocketPort } from "@pipelab/constants";
 import { WebSocket, WebSocketServer as WebSocketServer$1 } from "ws";
 import http from "node:http";
 import { nanoid } from "nanoid";
-import { SubscriptionRequiredError, WebSocketError, configRegistry, isRequired, isSupabaseAvailable, isWebSocketRequestMessage, normalizePipelineConfig, processGraph, savedFileMigrator, supabase, transformUrl, useLogger, usePlugins } from "@pipelab/shared";
+import { SubscriptionRequiredError, WebSocketError, appSettingsMigrator, connectionsMigrator, fileRepoMigrations, isRequired, isSupabaseAvailable, isWebSocketRequestMessage, processGraph, savedFileMigrator, supabase, transformUrl, useLogger, usePlugins } from "@pipelab/shared";
 import { execa } from "execa";
-import tar from "tar";
-import yauzl from "yauzl";
-import archiver from "archiver";
-import { pipeline } from "node:stream/promises";
 import checkDiskSpace from "check-disk-space";
 import dns from "node:dns/promises";
 import pacote from "pacote";
@@ -80,6 +77,11 @@ function findProjectRoot(startDir) {
 	return null;
 }
 const projectRoot = findProjectRoot(_dirname);
+const CacheFolder = {
+	Actions: "actions",
+	Pipelines: "pipelines",
+	Pacote: "pacote"
+};
 var PipelabContext = class {
 	userDataPath;
 	releaseTag;
@@ -96,20 +98,50 @@ var PipelabContext = class {
 	getConfigPath(...subpaths) {
 		return join(this.userDataPath, "config", ...subpaths);
 	}
+	getSettingsPath() {
+		return this.getConfigPath("settings.json");
+	}
+	getConnectionsPath() {
+		return this.getConfigPath("connections.json");
+	}
+	getProjectsPath() {
+		return this.getConfigPath("projects.json");
+	}
+	_cachedSettings = null;
+	_cachedSettingsTime = 0;
+	getSettings() {
+		const settingsPath = this.getSettingsPath();
+		if (!existsSync(settingsPath)) return null;
+		const now = Date.now();
+		if (this._cachedSettings && now - this._cachedSettingsTime < 2e3) return this._cachedSettings;
+		try {
+			const content = readFileSync(settingsPath, "utf8");
+			this._cachedSettings = JSON.parse(content);
+			this._cachedSettingsTime = now;
+			return this._cachedSettings;
+		} catch (e) {
+			return this._cachedSettings;
+		}
+	}
 	getTempPath(...subpaths) {
-		return join(this.userDataPath, "temp", ...subpaths);
+		return join(this.getSettings()?.tempFolder || join(this.userDataPath, "temp"), ...subpaths);
 	}
 	async createTempFolder(prefix = "pipelab-") {
 		const baseDir = this.getTempPath();
 		await mkdir(baseDir, { recursive: true });
 		return await mkdtemp(join(await realpath(baseDir), prefix));
 	}
-	getCachePath(...subpaths) {
-		return join(this.userDataPath, "cache", ...subpaths);
+	getCachePath(folder, ...subpaths) {
+		const base = this.getSettings()?.cacheFolder || join(this.userDataPath, "cache");
+		if (!folder) return base;
+		return join(base, folder, ...subpaths);
 	}
 	getPnpmPath(...subpaths) {
 		return join(this.userDataPath, "pnpm", ...subpaths);
 	}
+	getBuildHistoryPath(...subpaths) {
+		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");
@@ -502,287 +534,207 @@ const registerFsHandlers = (_context) => {
 	});
 };
 //#endregion
-//#region src/utils/fs-extras.ts
-/**
-* Ensures a directory exists and a file is created with default content if missing.
-*/
-const ensure = async (filesPath, defaultContent = "{}") => {
-	await mkdir(dirname(filesPath), { recursive: true });
-	try {
-		if ((await stat(filesPath)).size === 0) await writeFile(filesPath, defaultContent);
-	} catch {
-		await writeFile(filesPath, defaultContent);
-	}
-};
-/**
-* Extracts a .tar.gz archive.
-*/
-async function extractTarGz(archivePath, destinationDir) {
-	await mkdir(destinationDir, { recursive: true });
-	await tar.x({
-		file: archivePath,
-		cwd: destinationDir
-	});
-}
-/**
-* Extracts a .zip archive.
-*/
-async function extractZip(archivePath, destinationDir) {
-	await mkdir(destinationDir, { recursive: true });
-	return new Promise((resolve, reject) => {
-		yauzl.open(archivePath, { lazyEntries: true }, (err, zipfile) => {
-			if (err || !zipfile) return reject(err || /* @__PURE__ */ new Error("Could not open zip file"));
-			zipfile.on("error", reject);
-			zipfile.readEntry();
-			zipfile.on("entry", (entry) => {
-				const entryPath = join(destinationDir, entry.fileName);
-				if (/\/$/.test(entry.fileName)) mkdir(entryPath, { recursive: true }).then(() => zipfile.readEntry()).catch(reject);
-				else mkdir(dirname(entryPath), { recursive: true }).then(() => {
-					zipfile.openReadStream(entry, (err, readStream) => {
-						if (err || !readStream) return reject(err || /* @__PURE__ */ new Error("Could not open read stream"));
-						readStream.on("error", reject);
-						const writeStream = createWriteStream(entryPath);
-						writeStream.on("error", reject);
-						writeStream.on("close", () => zipfile.readEntry());
-						readStream.pipe(writeStream);
-					});
-				}).catch(reject);
+//#region src/handlers/config.ts
+const registerConfigHandlers = (context) => {
+	const { handle } = useAPI();
+	const { logger } = useLogger();
+	handle("settings:load", async (_, { send }) => {
+		logger().info("settings:load");
+		try {
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: await (await setupSettingsConfigFile(context)).getConfig()
+				}
 			});
-			zipfile.on("end", () => resolve());
-		});
+		} catch (e) {
+			logger().error("settings:load error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to load settings"
+				}
+			});
+		}
 	});
-}
-/**
-* Zips a folder.
-*/
-const zipFolder = async (from, to, log = console.log) => {
-	const output = createWriteStream(to);
-	const archive = archiver("zip", { zlib: { level: 9 } });
-	return new Promise((resolve, reject) => {
-		output.on("close", () => {
-			log(archive.pointer() + " total bytes");
-			resolve(to);
-		});
-		archive.on("error", reject);
-		archive.pipe(output);
-		archive.directory(from, false);
-		archive.finalize();
+	handle("settings:save", async (_, { send, value }) => {
+		const { data } = value;
+		try {
+			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"
+				}
+			});
+		}
 	});
-};
-const downloadFile = async (url, localPath, hooks, abortSignal) => {
-	const response = await fetch(url, { signal: abortSignal });
-	if (!response.ok) throw new Error(`Failed to fetch file: ${response.statusText}`);
-	const contentLength = response.headers.get("content-length");
-	if (!contentLength) throw new Error("Content-Length header is missing");
-	const totalSize = parseInt(contentLength, 10);
-	let downloadedSize = 0;
-	const fileStream = createWriteStream(localPath);
-	const progressStream = new TransformStream({ transform(chunk, controller) {
-		downloadedSize += chunk.length;
-		const progress = downloadedSize / totalSize * 100;
-		hooks?.onProgress?.({
-			progress,
-			downloadedSize
-		});
-		controller.enqueue(chunk);
-	} });
-	const readable = response.body?.pipeThrough(progressStream);
-	if (!readable) throw new Error("Failed to create a readable stream");
-	await pipeline(readable, fileStream);
-};
-const runWithLiveLogs = async (command, args, execaOptions, log, hooks, abortSignal) => {
-	const subprocess = execa(command, args, {
-		...execaOptions,
-		stdout: "pipe",
-		stderr: "pipe",
-		stdin: "pipe",
-		env: {
-			...process.env,
-			...execaOptions.env,
-			TERM: "xterm-256color",
-			FORCE_STDERR_LOGGING: "1"
-		},
-		cancelSignal: abortSignal
+	handle("settings:reset", async (_, { send, value }) => {
+		const { key } = value;
+		try {
+			const manager = await setupSettingsConfigFile(context);
+			const currentConfig = await manager.getConfig();
+			const defaultValue = appSettingsMigrator.defaultValue[key];
+			await manager.setConfig({
+				...currentConfig ? currentConfig : {},
+				[key]: defaultValue
+			});
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: "ok"
+				}
+			});
+		} catch (e) {
+			logger().error("settings:reset error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to reset settings"
+				}
+			});
+		}
 	});
-	hooks?.onCreated?.(subprocess);
-	subprocess.stdout?.on("data", (data) => {
-		hooks?.onStdout?.(data.toString(), subprocess);
+	handle("connections:load", async (_, { send }) => {
+		logger().info("connections:load");
+		try {
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: await (await setupConnectionsConfigFile(context)).getConfig()
+				}
+			});
+		} catch (e) {
+			logger().error("connections:load error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to load connections"
+				}
+			});
+		}
 	});
-	subprocess.stderr?.on("data", (data) => {
-		hooks?.onStderr?.(data.toString(), subprocess);
+	handle("connections:save", async (_, { send, value }) => {
+		const { data } = value;
+		try {
+			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"
+				}
+			});
+		}
 	});
-	try {
-		const { exitCode } = await subprocess;
-		hooks?.onExit?.(exitCode ?? 0);
-	} catch (error) {
-		const code = error.exitCode ?? 1;
-		hooks?.onExit?.(code);
-		throw new Error(`Command failed with exit code ${code}: ${error.message}`);
-	}
-};
-/**
-* Calculates the total size of a directory recursively.
-*/
-async function getFolderSize(dirPath) {
-	try {
-		const ArrayOfPromises = (await readdir(dirPath, { withFileTypes: true })).map(async (file) => {
-			const path = join(dirPath, file.name);
-			if (file.isDirectory()) try {
-				return await getFolderSize(path);
-			} catch {
-				return 0;
-			}
-			try {
-				const { size } = await stat(path);
-				return size;
-			} catch {
-				return 0;
-			}
-		});
-		return (await Promise.all(ArrayOfPromises)).reduce((acc, size) => acc + size, 0);
-	} catch {
-		return 0;
-	}
-}
-//#endregion
-//#region src/config.ts
-const getMigrator = (name) => {
-	return configRegistry[name] || configRegistry["pipeline"];
-};
-const setupConfigFile = async (name, options) => {
-	const ctx = options.context;
-	const migrator = options.migrator || getMigrator(name);
-	if (!migrator) throw new Error(`No migrator found for configuration: ${name}. All managed files must have a migration schema.`);
-	const filesPath = path.isAbsolute(name) ? name : ctx.getConfigPath(`${name}.json`);
-	await ensure(filesPath, JSON.stringify(migrator.defaultValue));
-	return {
-		setConfig: async (config) => {
-			const { logger } = useLogger();
-			try {
-				await fs$1.writeFile(filesPath, JSON.stringify(config));
-				return true;
-			} catch (e) {
-				logger().error(`Error saving config ${name}:`, e);
-				return false;
-			}
-		},
-		getConfig: async () => {
-			const { logger } = useLogger();
-			let content = void 0;
-			let originalJson = void 0;
-			let parseFailed = false;
-			try {
-				content = await fs$1.readFile(filesPath, "utf8");
-				if (content !== void 0) originalJson = JSON.parse(content);
-			} catch (e) {
-				logger().error(`Error reading or parsing config ${name}:`, e);
-				parseFailed = true;
-			}
-			let json = void 0;
-			let migrationFailed = false;
-			try {
-				if (!parseFailed) json = await migrator.migrate(originalJson, {
-					debug: false,
-					onStep: async (state, version) => {
-						const parsedPath = path.parse(filesPath);
-						const versionedPath = path.join(parsedPath.dir, `${parsedPath.name}.v${version}.json`);
-						try {
-							await fs$1.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);
-						}
-					}
-				});
-				else json = migrator.defaultValue;
-			} catch (e) {
-				logger().error(`Error migrating config ${name}:`, e);
-				migrationFailed = true;
-				json = migrator.defaultValue;
-			}
-			let normalized = false;
-			if (name.startsWith("pipeline-") || path.isAbsolute(name) || name.endsWith(".json") || name === "pipeline") normalized = normalizePipelineConfig(json);
-			if (originalJson?.version !== json?.version || normalized || content === void 0 || parseFailed || migrationFailed) {
-				if (parseFailed || migrationFailed) try {
-					const parsedPath = path.parse(filesPath);
-					const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-					const corruptedPath = path.join(parsedPath.dir, `${parsedPath.name}.corrupted.${timestamp}.json`);
-					const backupContent = parseFailed ? content || "" : JSON.stringify(originalJson, null, 2);
-					await fs$1.writeFile(corruptedPath, backupContent);
-					logger().info(`Corrupted config file preserved at ${corruptedPath}`);
-				} catch (e) {
-					logger().error(`Failed to backup corrupted config ${name}:`, e);
+	handle("connections:reset", async (_, { send, value }) => {
+		const { key } = value;
+		try {
+			const manager = await setupConnectionsConfigFile(context);
+			const currentConfig = await manager.getConfig();
+			const defaultValue = connectionsMigrator.defaultValue[key];
+			await manager.setConfig({
+				...currentConfig ? currentConfig : {},
+				[key]: defaultValue
+			});
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: "ok"
 				}
-				try {
-					await fs$1.writeFile(filesPath, JSON.stringify(json));
-				} catch (e) {
-					logger().error(`Error saving migrated config ${name}:`, e);
+			});
+		} catch (e) {
+			logger().error("connections:reset error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to reset connections"
 				}
-			}
-			return json;
+			});
 		}
-	};
-};
-//#endregion
-//#region src/handlers/config.ts
-const registerConfigHandlers = (context) => {
-	const { handle } = useAPI();
-	const { logger } = useLogger();
-	handle("config:load", async (_, { send, value }) => {
-		const { config: name } = value;
-		logger().info("config:load", name);
+	});
+	handle("projects:load", async (_, { send }) => {
+		logger().info("projects:load");
 		try {
 			send({
 				type: "end",
 				data: {
 					type: "success",
-					result: { result: await (await setupConfigFile(name, { context })).getConfig() }
+					result: await (await setupProjectsConfigFile(context)).getConfig()
 				}
 			});
 		} catch (e) {
-			logger().error(`config:load error for ${name}:`, e);
+			logger().error("projects:load error:", e);
 			send({
 				type: "end",
 				data: {
 					type: "error",
-					ipcError: e instanceof Error ? e.message : `Unable to load config ${name}`
+					ipcError: e instanceof Error ? e.message : "Unable to load projects"
 				}
 			});
 		}
 	});
-	handle("config:save", async (_, { send, value }) => {
-		const { data, config: name } = value;
+	handle("projects:save", async (_, { send, value }) => {
+		const { data } = value;
 		try {
-			const manager = await setupConfigFile(name, { context });
+			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: { result: "ok" }
+					result: "ok"
 				}
 			});
 		} catch (e) {
-			logger().error(`config:save error for ${name}:`, e);
+			logger().error("projects:save error:", e);
 			send({
 				type: "end",
 				data: {
 					type: "error",
-					ipcError: e instanceof Error ? e.message : `Unable to save config ${name}`
+					ipcError: e instanceof Error ? e.message : "Unable to save projects"
 				}
 			});
 		}
 	});
-	handle("config:reset", async (event, { value, send }) => {
-		const { config: name, key } = value;
-		logger().info("config:reset", name, key);
+	handle("projects:reset", async (_, { send, value }) => {
+		const { key } = value;
 		try {
-			const manager = await setupConfigFile(name, { context });
+			const manager = await setupProjectsConfigFile(context);
 			const currentConfig = await manager.getConfig();
-			const migrator = getMigrator(name);
-			if (!migrator) throw new Error(`No migrator found for configuration: ${name}`);
-			const defaultValue = migrator.defaultValue[key];
+			const defaultValue = fileRepoMigrations.defaultValue[key];
 			await manager.setConfig({
 				...currentConfig ? currentConfig : {},
 				[key]: defaultValue
@@ -791,50 +743,154 @@ const registerConfigHandlers = (context) => {
 				type: "end",
 				data: {
 					type: "success",
-					result: { result: "ok" }
+					result: "ok"
 				}
 			});
 		} catch (e) {
-			logger().error(`config:reset error for ${name}:`, e);
+			logger().error("projects:reset error:", e);
 			send({
 				type: "end",
 				data: {
 					type: "error",
-					ipcError: e instanceof Error ? e.message : `Unable to reset config ${name}`
+					ipcError: e instanceof Error ? e.message : "Unable to reset projects"
 				}
 			});
 		}
 	});
-	handle("config:delete", async (_, { send, value }) => {
-		const { config: name } = value;
-		logger().info("config:delete", name);
+	handle("pipeline:load-by-name", async (_, { send, value }) => {
+		const { name } = value;
+		logger().info("pipeline:load-by-name", name);
 		try {
-			const filesPath = path.isAbsolute(name) ? name : context.getConfigPath(`${name}.json`);
-			await fs$1.rm(filesPath, { force: true });
-			const parsedPath = path.parse(filesPath);
-			const dirEntries = await fs$1.readdir(parsedPath.dir).catch(() => []);
-			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$1.rm(backupPath, { force: true }).catch((err) => {
-					logger().error(`Failed to delete backup ${backupPath}:`, err);
-				});
-			}
 			send({
 				type: "end",
 				data: {
 					type: "success",
-					result: { result: "ok" }
+					result: await (await setupPipelineConfigFileByName(name, context)).getConfig()
+				}
+			});
+		} 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}`
+				}
+			});
+		}
+	});
+	handle("pipeline:load-by-path", async (_, { send, value }) => {
+		const { path: absolutePath } = value;
+		logger().info("pipeline:load-by-path", absolutePath);
+		try {
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: await (await setupPipelineConfigFileByPath(absolutePath, context)).getConfig()
+				}
+			});
+		} 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: "ok"
 				}
 			});
 		} catch (e) {
-			logger().error(`config:delete 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 delete config ${name}`
+					ipcError: e instanceof Error ? e.message : `Unable to delete pipeline ${absolutePath}`
 				}
 			});
 		}
@@ -848,11 +904,10 @@ var BuildHistoryStorage = class {
 		this.context = context;
 	}
 	getStoragePath() {
-		return join(this.context.userDataPath, "build-history");
+		return this.context.getConfigPath("pipelines");
 	}
 	getPipelinePath(pipelineId) {
-		const sanitizedId = pipelineId.replace(/[/\:*?"<>|]/g, "_").replace(/__/g, "_").replace(/^_+|_+$/g, "");
-		return join(this.getStoragePath(), `pipeline-${sanitizedId}.json`);
+		return join(this.getStoragePath(), `${pipelineId}.history.json`);
 	}
 	async ensureStoragePath() {
 		try {
@@ -879,35 +934,6 @@ var BuildHistoryStorage = class {
 			throw new Error(`Failed to save pipeline history: ${error}`);
 		}
 	}
-	async applyRetentionPolicy() {
-		try {
-			this.logger.logger().info("Applying build history retention policy...");
-			const policy = (await (await setupConfigFile("settings", { context: this.context })).getConfig())?.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;
-				if (maxAge > 0) {
-					const minDate = Date.now() - maxAge * 24 * 60 * 60 * 1e3;
-					entries = entries.filter((entry) => entry.createdAt >= minDate);
-				}
-				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);
-		}
-	}
 	async save(entry) {
 		try {
 			const entries = await this.loadPipelineHistory(entry.pipelineId);
@@ -916,9 +942,6 @@ var BuildHistoryStorage = class {
 			else entries.push(entry);
 			await this.savePipelineHistory(entry.pipelineId, entries);
 			this.logger.logger().info(`Saved build history entry: ${entry.id} for pipeline: ${entry.pipelineId}`);
-			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}`);
@@ -929,7 +952,8 @@ var BuildHistoryStorage = class {
 			if (pipelineId) return (await this.loadPipelineHistory(pipelineId)).find((e) => e.id === id);
 			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 entry = (await this.loadPipelineHistory(pId)).find((e) => e.id === id);
 				if (entry) return entry;
 			}
@@ -944,7 +968,8 @@ var BuildHistoryStorage = class {
 			const files = await this.getAllPipelineFiles();
 			const allEntries = [];
 			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);
 			}
@@ -979,7 +1004,8 @@ var BuildHistoryStorage = class {
 			} 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) {
@@ -1013,7 +1039,8 @@ var BuildHistoryStorage = class {
 			} 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) {
@@ -1034,8 +1061,20 @@ var BuildHistoryStorage = class {
 		try {
 			await this.ensureStoragePath();
 			const files = await this.getAllPipelineFiles();
-			await Promise.all(files.map((file) => unlink(join(this.getStoragePath(), file))));
+			const cachePathsToDelete = /* @__PURE__ */ new Set();
+			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}`);
@@ -1043,8 +1082,16 @@ var BuildHistoryStorage = class {
 	}
 	async clearByPipeline(pipelineId) {
 		try {
-			await unlink(this.getPipelinePath(pipelineId));
+			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 = /* @__PURE__ */ new Set();
+			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) {
 			if (error.code === "ENOENT") {
 				this.logger.logger().warn(`No history file found for pipeline "${pipelineId}". Nothing to clear.`);
@@ -1069,21 +1116,11 @@ var BuildHistoryStorage = class {
 					size
 				});
 			}
-			const policy = (await (await setupConfigFile("settings", { context: this.context })).getConfig())?.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,
@@ -1108,11 +1145,6 @@ var BuildHistoryStorage = class {
 				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,
@@ -1128,11 +1160,15 @@ var BuildHistoryStorage = class {
 	async getAllPipelineFiles() {
 		try {
 			await this.ensureStoragePath();
-			return (await readdir(this.getStoragePath())).filter((file) => file.startsWith("pipeline-") && file.endsWith(".json"));
+			return (await readdir(this.getStoragePath())).filter((file) => file.endsWith(".history.json"));
 		} catch (error) {
 			return [];
 		}
 	}
+	parsePipelineIdFromFilename(filename) {
+		const match = filename.match(/^(.+)\.history\.json$/);
+		return match ? match[1] : null;
+	}
 };
 //#endregion
 //#region src/handlers/history.ts
@@ -1414,40 +1450,6 @@ const registerHistoryHandlers = (context) => {
 			});
 		}
 	});
-	handle("build-history:configure", async (_, { send, value }) => {
-		try {
-			logger().info("Updating build history configuration:", value.config);
-			const settings = await setupConfigFile("settings", { context });
-			const currentConfig = await settings.getConfig();
-			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"
-				}
-			});
-		}
-	});
 };
 //#endregion
 //#region ../../node_modules/serve-handler/src/glob-slash.js
@@ -8437,7 +8439,7 @@ var require_error = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	})();
 }));
 //#endregion
-//#region src/migrations.ts
+//#region src/server.ts
 var import_src = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { promisify } = __require("util");
 	const path$1 = __require("path");
@@ -8891,44 +8893,6 @@ var import_src = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((export
 		stream.pipe(response);
 	};
 })))(), 1);
-/**
-* 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.
-*/
-function registerMigrationHandlers(context) {
-	const { handle } = useAPI();
-	const { logger } = useLogger();
-	handle("config:load", async (_, { send, value }) => {
-		const { config: name } = value;
-		logger().info("[CLI Migration] config:load", name);
-		try {
-			const migrator = getMigrator(name);
-			if (!migrator) throw new Error(`No migrator found for configuration: ${name}. All files loaded via config:load MUST have a migration schema.`);
-			send({
-				type: "end",
-				data: {
-					type: "success",
-					result: { result: await (await setupConfigFile(name, {
-						context,
-						migrator
-					})).getConfig() }
-				}
-			});
-		} 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}`
-				}
-			});
-		}
-	});
-}
-//#endregion
-//#region src/server.ts
 const sendStartupProgress = (message) => {
 	console.log(`[Startup Progress] ${message}`);
 	webSocketServer.broadcast("startup:progress", {
@@ -8997,7 +8961,13 @@ async function serveCommand(options, version, _dirname) {
 			response.end(`Error: UI directory not found at ${rawAssetFolder}.\nPlease run 'pnpm build' in apps/ui to generate the distribution.`);
 			return;
 		}
-		return (0, import_src.default)(request, response, { public: rawAssetFolder });
+		return (0, import_src.default)(request, response, {
+			public: rawAssetFolder,
+			rewrites: [{
+				source: "/**",
+				destination: "/index.html"
+			}]
+		});
 	});
 	console.log(`Starting Pipelab server on port ${options.port}...`);
 	if (isDev) {
@@ -9009,7 +8979,6 @@ async function serveCommand(options, version, _dirname) {
 		version,
 		context
 	});
-	registerMigrationHandlers(context);
 	sendStartupReady();
 	return server;
 }
@@ -9104,7 +9073,7 @@ async function fetchPackage(packageName, versionOrRange, options) {
 			console.log(`[Fetcher] ${packageName}: Resolved to local fallback ${resolvedVersion} (${Date.now() - fallbackStart}ms)`);
 		} else throw new Error(`Offline and no local fallback version available for ${packageName}`);
 	} else try {
-		const cachePath = join(ctx.userDataPath, "cache", "pacote");
+		const cachePath = ctx.getCachePath(CacheFolder.Pacote);
 		let packumentPromise = packumentRequests.get(packageName);
 		if (!packumentPromise) {
 			packumentPromise = pacote.packument(packageName, { cache: cachePath });
@@ -9135,7 +9104,7 @@ async function fetchPackage(packageName, versionOrRange, options) {
 			console.log(`[Fetcher] ${packageName}: Resolved to local fallback ${resolvedVersion} (${Date.now() - fallbackStart}ms)`);
 		} else throw error;
 	}
-	const cachePath = join(ctx.userDataPath, "cache", "pacote");
+	const cachePath = ctx.getCachePath(CacheFolder.Pacote);
 	const packageDir = join(baseDir, resolvedVersion);
 	const checkStart = Date.now();
 	const isInstalled = options?.installDeps ? isPackageComplete(packageDir) && isDependenciesInstalledSync(packageDir) : isPackageComplete(packageDir);
@@ -9212,7 +9181,7 @@ async function runPnpm(cwd, options) {
 			...process.env,
 			NODE_ENV: "production",
 			PATH: nodePath ? `${dirname(nodePath)}${delimiter}${process.env.PATH}` : process.env.PATH,
-			PNPM_HOME: join(ctx.userDataPath, "pnpm"),
+			PNPM_HOME: ctx.getPnpmPath(),
 			PNPM_ONLY_ALLOW_TRUSTED_DEPENDENCIES: "false",
 			...extraEnv
 		}
@@ -9741,8 +9710,8 @@ const builtInPlugins = async (options) => {
 			}
 		}
 		try {
-			const { setupConfigFile } = await import("./config-CEkOf95p.mjs");
-			const settingsPlugins = (await (await setupConfigFile("settings", { context: options.context })).getConfig())?.plugins || [];
+			const { setupSettingsConfigFile } = await import("./config-Bi0ORcTK.mjs");
+			const settingsPlugins = (await (await setupSettingsConfigFile(options.context)).getConfig())?.plugins || [];
 			for (const plugin of settingsPlugins) if (plugin.name) if (plugin.enabled) {
 				if (!pluginsToLoad.has(plugin.name)) pluginsToLoad.set(plugin.name, "latest");
 			} else pluginsToLoad.delete(plugin.name);
@@ -9812,6 +9781,7 @@ const executeGraphWithHistory = async ({ graph, variables, projectName, projectP
 		projectName,
 		projectPath,
 		pipelineId,
+		cachePath,
 		startTime,
 		status: "running",
 		logs: [],
@@ -9840,7 +9810,7 @@ const executeGraphWithHistory = async ({ graph, variables, projectName, projectP
 		} else logger().error(`[Runner] Failed to load or register plugin "${pluginId}"`);
 	}
 	logger().info(`[Sandbox] Execution sandbox created at: ${sandboxPath}`);
-	await (await setupConfigFile("settings", { context: ctx })).getConfig();
+	await (await setupSettingsConfigFile(ctx)).getConfig();
 	try {
 		const result = await processGraph({
 			graph,
@@ -9908,7 +9878,6 @@ const executeGraphWithHistory = async ({ graph, variables, projectName, projectP
 		}, pipelineId);
 		throw error;
 	} finally {
-		if (!shouldDisableHistory) buildHistoryStorage.applyRetentionPolicy();
 		try {
 			await rm(sandboxPath, {
 				recursive: true,
@@ -9917,6 +9886,14 @@ const executeGraphWithHistory = async ({ graph, variables, projectName, projectP
 		} catch (e) {
 			console.warn(`Failed to cleanup sandbox at ${sandboxPath}:`, e);
 		}
+		try {
+			await rm(cachePath, {
+				recursive: true,
+				force: true
+			});
+		} catch (e) {
+			console.warn(`Failed to cleanup cache at ${cachePath}:`, e);
+		}
 	}
 };
 //#endregion
@@ -10292,24 +10269,32 @@ const registerEngineHandlers = (context) => {
 	};
 	handle("action:execute", async (event, { send, value }) => {
 		const { nodeId, params, pluginId } = value;
-		await (await setupConfigFile("settings", { context })).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 = void 0;
-		abortControllerGraph = new AbortController();
-		const signalPromise = new Promise((resolve, reject) => {
-			abortControllerGraph.signal.addEventListener("abort", async () => {
-				await send({
-					type: "end",
-					data: {
-						ipcError: "Action aborted",
-						type: "error"
-					}
+		try {
+			const mainWindow = void 0;
+			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(/* @__PURE__ */ new Error("Action interrupted"));
 				});
-				return reject(/* @__PURE__ */ 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 }) => {
 		const userData = context.userDataPath;
@@ -10333,11 +10318,11 @@ const registerEngineHandlers = (context) => {
 	});
 	handle("graph:execute", async (event, { send, value }) => {
 		const { graph, variables, projectName, projectPath, pipelineId } = value;
-		await (await setupConfigFile("settings", { context })).getConfig();
+		await (await setupSettingsConfigFile(context)).getConfig();
 		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 = void 0;
 		abortControllerGraph = new AbortController();
 		try {
@@ -10445,7 +10430,7 @@ var JsonFileStorage = class {
 	filePath;
 	logger = useLogger().logger;
 	constructor(fileName, context) {
-		this.filePath = path.join(context.userDataPath, fileName);
+		this.filePath = context.getConfigPath(fileName);
 		const dir = path.dirname(this.filePath);
 		if (!fs.existsSync(dir)) try {
 			fs.mkdirSync(dir, { recursive: true });
@@ -10886,6 +10871,470 @@ const registerPluginsHandlers = (context) => {
 	});
 };
 //#endregion
+//#region src/handlers/migration.ts
+const registerMigrationHandlers = (context) => {
+	const { handle } = useAPI();
+	const { logger } = useLogger();
+	const getFileMetadata = async (filePath) => {
+		const exists = existsSync(filePath);
+		let mtime = Date.now();
+		let version = null;
+		if (exists) {
+			try {
+				const stat = await fs$1.stat(filePath);
+				mtime = stat.mtime ? stat.mtime.getTime() : Date.now();
+			} catch (e) {
+				mtime = Date.now();
+			}
+			try {
+				const content = await fs$1.readFile(filePath, "utf8");
+				const json = JSON.parse(content);
+				version = json && typeof json.version === "string" ? json.version : null;
+			} catch (e) {}
+		} else mtime = Date.now();
+		return {
+			exists,
+			mtime,
+			version
+		};
+	};
+	const isVersionImportable = (sourceVer, targetVer) => {
+		if (!sourceVer) return false;
+		if (!targetVer) return true;
+		try {
+			const coercedSource = semver.coerce(sourceVer);
+			const coercedTarget = semver.coerce(targetVer);
+			if (!coercedSource) return false;
+			if (!coercedTarget) return true;
+			return semver.lte(coercedSource, coercedTarget);
+		} catch {
+			return sourceVer <= targetVer;
+		}
+	};
+	handle("migration:scan-stable", async (_, { send }) => {
+		logger().info("[Migration] Scanning other channel database...");
+		try {
+			const isStable = context.userDataPath.endsWith("app") || !context.userDataPath.includes("app-beta");
+			const sourceEnv = isStable ? "beta" : "prod";
+			const sourcePath = getDefaultUserDataPath(sourceEnv);
+			if (sourcePath === context.userDataPath) {
+				logger().info("[Migration] Running in same channel. Disabling migration scan.");
+				return send({
+					type: "end",
+					data: {
+						type: "success",
+						result: {
+							sourceChannel: isStable ? "Beta" : "Stable",
+							targetChannel: isStable ? "Stable" : "Beta",
+							settingsExists: false,
+							settingsVersion: null,
+							settingsVersionTarget: null,
+							settingsMtimeSource: Date.now(),
+							settingsMtimeTarget: Date.now(),
+							settingsImportable: false,
+							connectionsExists: false,
+							connectionsCount: 0,
+							connectionsVersion: null,
+							connectionsVersionTarget: null,
+							connectionsMtimeSource: Date.now(),
+							connectionsMtimeTarget: Date.now(),
+							connectionsImportable: false,
+							projectsExists: false,
+							projectsVersion: null,
+							projectsVersionTarget: null,
+							projectsMtimeSource: Date.now(),
+							projectsMtimeTarget: Date.now(),
+							projectsImportable: false,
+							projects: []
+						}
+					}
+				});
+			}
+			const sourceContext = new PipelabContext({
+				userDataPath: sourcePath,
+				releaseTag: sourceEnv
+			});
+			const sourceSettingsPath = sourceContext.getSettingsPath();
+			const targetSettingsPath = context.getSettingsPath();
+			const sourceConnectionsPath = sourceContext.getConnectionsPath();
+			const targetConnectionsPath = context.getConnectionsPath();
+			const sourceProjectsPath = sourceContext.getProjectsPath();
+			const targetProjectsPath = context.getProjectsPath();
+			const sourceSettingsMeta = await getFileMetadata(sourceSettingsPath);
+			const targetSettingsMeta = await getFileMetadata(targetSettingsPath);
+			const sourceConnectionsMeta = await getFileMetadata(sourceConnectionsPath);
+			const targetConnectionsMeta = await getFileMetadata(targetConnectionsPath);
+			const sourceProjectsMeta = await getFileMetadata(sourceProjectsPath);
+			const targetProjectsMeta = await getFileMetadata(targetProjectsPath);
+			const settingsExists = sourceSettingsMeta.exists;
+			const settingsVersion = sourceSettingsMeta.version;
+			const settingsMtimeSource = sourceSettingsMeta.mtime;
+			const settingsMtimeTarget = targetSettingsMeta.mtime;
+			const settingsImportable = isVersionImportable(settingsVersion, targetSettingsMeta.version);
+			const connectionsExists = sourceConnectionsMeta.exists;
+			const connectionsVersion = sourceConnectionsMeta.version;
+			const connectionsMtimeSource = sourceConnectionsMeta.mtime;
+			const connectionsMtimeTarget = targetConnectionsMeta.mtime;
+			const connectionsImportable = isVersionImportable(connectionsVersion, targetConnectionsMeta.version);
+			const projectsExists = sourceProjectsMeta.exists;
+			const projectsVersion = sourceProjectsMeta.version;
+			const projectsMtimeSource = sourceProjectsMeta.mtime;
+			const projectsMtimeTarget = targetProjectsMeta.mtime;
+			const projectsImportable = isVersionImportable(projectsVersion, targetProjectsMeta.version);
+			let connectionsCount = 0;
+			try {
+				if (sourceConnectionsMeta.exists) {
+					const connContent = await fs$1.readFile(sourceConnectionsPath, "utf8");
+					const connJson = JSON.parse(connContent);
+					if (connJson && Array.isArray(connJson.connections)) connectionsCount = connJson.connections.length;
+				}
+			} catch (err) {
+				logger().error("[Migration] Error parsing source connections.json:", err);
+			}
+			let sourceProjectsList = [];
+			let sourcePipelinesList = [];
+			try {
+				if (sourceProjectsMeta.exists) {
+					const projContent = await fs$1.readFile(sourceProjectsPath, "utf8");
+					const projJson = JSON.parse(projContent);
+					sourceProjectsList = projJson.projects || [];
+					sourcePipelinesList = projJson.pipelines || [];
+				}
+			} catch (err) {
+				logger().error("[Migration] Error parsing source projects.json:", err);
+			}
+			let targetPipelinesList = [];
+			try {
+				if (targetProjectsMeta.exists) {
+					const targetProjContent = await fs$1.readFile(targetProjectsPath, "utf8");
+					targetPipelinesList = JSON.parse(targetProjContent).pipelines || [];
+				}
+			} catch (err) {}
+			const projectsReport = [];
+			for (const proj of sourceProjectsList) {
+				const projPipelines = sourcePipelinesList.filter((p) => p.project === proj.id);
+				const pipelinesReport = [];
+				for (const pipe of projPipelines) {
+					const targetPipe = targetPipelinesList.find((bp) => bp.id === pipe.id);
+					const existsInBeta = !!targetPipe;
+					let pipeName = pipe.id;
+					let pipeDesc = "";
+					if (pipe.type === "internal") {
+						const sourcePipeFile = sourceContext.getConfigPath(`${pipe.configName}.json`);
+						try {
+							if (existsSync(sourcePipeFile)) {
+								const pipeContent = await fs$1.readFile(sourcePipeFile, "utf8");
+								const pipeJson = JSON.parse(pipeContent);
+								pipeName = pipeJson.name || pipeName;
+								pipeDesc = pipeJson.description || pipeDesc;
+							}
+						} catch (err) {
+							logger().error(`[Migration] Error reading source pipeline file ${sourcePipeFile}:`, err);
+						}
+					} else if (pipe.type === "external") {
+						pipeName = pipe.summary?.name || pipeName;
+						pipeDesc = pipe.summary?.description || pipeDesc;
+					}
+					pipelinesReport.push({
+						id: pipe.id,
+						name: pipeName,
+						description: pipeDesc,
+						type: pipe.type,
+						lastModifiedStable: pipe.type !== "pipelab-cloud" ? pipe.lastModified : void 0,
+						lastModifiedBeta: targetPipe && targetPipe.type !== "pipelab-cloud" ? targetPipe.lastModified : void 0,
+						existsInBeta
+					});
+				}
+				projectsReport.push({
+					id: proj.id,
+					name: proj.name,
+					description: proj.description || "",
+					pipelines: pipelinesReport
+				});
+			}
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: {
+						sourceChannel: isStable ? "Beta" : "Stable",
+						targetChannel: isStable ? "Stable" : "Beta",
+						settingsExists,
+						settingsVersion,
+						settingsVersionTarget: targetSettingsMeta.version,
+						settingsMtimeSource,
+						settingsMtimeTarget,
+						settingsImportable,
+						connectionsExists,
+						connectionsCount,
+						connectionsVersion,
+						connectionsVersionTarget: targetConnectionsMeta.version,
+						connectionsMtimeSource,
+						connectionsMtimeTarget,
+						connectionsImportable,
+						projectsExists,
+						projectsVersion,
+						projectsVersionTarget: targetProjectsMeta.version,
+						projectsMtimeSource,
+						projectsMtimeTarget,
+						projectsImportable,
+						projects: projectsReport
+					}
+				}
+			});
+		} catch (e) {
+			logger().error("[Migration] Error scanning other channel folder:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Failed to scan other channel database"
+				}
+			});
+		}
+	});
+	handle("migration:perform", async (_, { send, value }) => {
+		logger().info("[Migration] Performing migration...");
+		try {
+			const { migrateSettings, migrateConnections, selectedProjects, selectedPipelines } = value;
+			const sourceEnv = context.userDataPath.endsWith("app") || !context.userDataPath.includes("app-beta") ? "beta" : "prod";
+			const sourcePath = getDefaultUserDataPath(sourceEnv);
+			const sourceContext = new PipelabContext({
+				userDataPath: sourcePath,
+				releaseTag: sourceEnv
+			});
+			sourceContext.getConfigPath();
+			const targetConfigDir = context.getConfigPath();
+			if (sourcePath === context.userDataPath) throw new Error("Cannot migrate data: Source and target directories are identical.");
+			if (existsSync(targetConfigDir)) {
+				const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+				const backupDir = context.getConfigPath("backups", `backup_${timestamp}`);
+				await fs$1.mkdir(backupDir, { recursive: true });
+				const entries = await fs$1.readdir(targetConfigDir, { withFileTypes: true });
+				for (const entry of entries) {
+					if (entry.name === "backups") continue;
+					const srcPath = join(targetConfigDir, entry.name);
+					const destPath = join(backupDir, entry.name);
+					try {
+						await fs$1.cp(srcPath, destPath, { recursive: true });
+					} catch (copyErr) {
+						logger().error(`[Migration] Failed to backup ${entry.name}:`, copyErr);
+					}
+				}
+				logger().info(`[Migration] Config backup successfully created at ${backupDir}`);
+			}
+			if (migrateSettings) {
+				const sourceSettingsFile = sourceContext.getSettingsPath();
+				const targetSettingsFile = context.getSettingsPath();
+				const sourceMeta = await getFileMetadata(sourceSettingsFile);
+				const targetMeta = await getFileMetadata(targetSettingsFile);
+				if (!isVersionImportable(sourceMeta.version, targetMeta.version)) throw new Error("Cannot migrate settings: Source version is newer than current version.");
+				if (existsSync(sourceSettingsFile)) {
+					let stableSettings = {
+						version: "7.0.0",
+						locale: "en-US",
+						theme: "light",
+						autosave: true,
+						agents: [],
+						plugins: [],
+						tours: {
+							dashboard: {
+								step: 0,
+								completed: false
+							},
+							editor: {
+								step: 0,
+								completed: false
+							}
+						}
+					};
+					try {
+						const stableContent = await fs$1.readFile(sourceSettingsFile, "utf8");
+						stableSettings = JSON.parse(stableContent);
+					} catch (e) {
+						logger().error("[Migration] Failed to read source settings.json:", e);
+					}
+					let betaSettings = {
+						version: "7.0.0",
+						locale: "en-US",
+						theme: "light",
+						autosave: true,
+						agents: [],
+						plugins: [],
+						tours: {
+							dashboard: {
+								step: 0,
+								completed: false
+							},
+							editor: {
+								step: 0,
+								completed: false
+							}
+						}
+					};
+					if (existsSync(targetSettingsFile)) try {
+						const betaContent = await fs$1.readFile(targetSettingsFile, "utf8");
+						betaSettings = JSON.parse(betaContent);
+					} catch (e) {}
+					betaSettings.theme = stableSettings.theme ?? betaSettings.theme;
+					betaSettings.locale = stableSettings.locale ?? betaSettings.locale;
+					betaSettings.autosave = stableSettings.autosave ?? betaSettings.autosave;
+					if (stableSettings.tours) {
+						betaSettings.tours = betaSettings.tours || {
+							dashboard: {
+								step: 0,
+								completed: false
+							},
+							editor: {
+								step: 0,
+								completed: false
+							}
+						};
+						if (stableSettings.tours.dashboard) betaSettings.tours.dashboard = stableSettings.tours.dashboard;
+						if (stableSettings.tours.editor) betaSettings.tours.editor = stableSettings.tours.editor;
+					}
+					const betaAgents = betaSettings.agents || [];
+					const stableAgents = stableSettings.agents || [];
+					for (const sAgent of stableAgents) {
+						const existingIdx = betaAgents.findIndex((a) => a.id === sAgent.id);
+						if (existingIdx >= 0) betaAgents[existingIdx] = { ...sAgent };
+						else betaAgents.push({ ...sAgent });
+					}
+					betaSettings.agents = betaAgents;
+					const betaPlugins = betaSettings.plugins || [];
+					const stablePlugins = stableSettings.plugins || [];
+					for (const sPlugin of stablePlugins) {
+						const existingIdx = betaPlugins.findIndex((p) => p.name === sPlugin.name);
+						if (existingIdx >= 0) betaPlugins[existingIdx] = { ...sPlugin };
+						else betaPlugins.push({ ...sPlugin });
+					}
+					betaSettings.plugins = betaPlugins;
+					await fs$1.mkdir(dirname(targetSettingsFile), { recursive: true });
+					await fs$1.writeFile(targetSettingsFile, JSON.stringify(betaSettings, null, 2));
+					logger().info("[Migration] Settings merged successfully");
+				}
+			}
+			if (migrateConnections) {
+				const sourceConnectionsFile = sourceContext.getConnectionsPath();
+				const targetConnectionsFile = context.getConnectionsPath();
+				const sourceMeta = await getFileMetadata(sourceConnectionsFile);
+				const targetMeta = await getFileMetadata(targetConnectionsFile);
+				if (!isVersionImportable(sourceMeta.version, targetMeta.version)) throw new Error("Cannot migrate connections: Source version is newer than current version.");
+				if (existsSync(sourceConnectionsFile)) {
+					let stableConnections = {
+						version: "1.0.0",
+						connections: []
+					};
+					try {
+						const stableContent = await fs$1.readFile(sourceConnectionsFile, "utf8");
+						stableConnections = JSON.parse(stableContent);
+					} catch (e) {
+						logger().error("[Migration] Failed to read source connections.json:", e);
+					}
+					let betaConnections = {
+						version: "1.0.0",
+						connections: []
+					};
+					if (existsSync(targetConnectionsFile)) try {
+						const betaContent = await fs$1.readFile(targetConnectionsFile, "utf8");
+						betaConnections = JSON.parse(betaContent);
+					} catch (e) {}
+					betaConnections.connections = betaConnections.connections || [];
+					stableConnections.connections = stableConnections.connections || [];
+					for (const sConn of stableConnections.connections) {
+						const existingIdx = betaConnections.connections.findIndex((c) => c.id === sConn.id);
+						if (existingIdx >= 0) betaConnections.connections[existingIdx] = { ...sConn };
+						else betaConnections.connections.push({ ...sConn });
+					}
+					await fs$1.mkdir(dirname(targetConnectionsFile), { recursive: true });
+					await fs$1.writeFile(targetConnectionsFile, JSON.stringify(betaConnections, null, 2));
+					logger().info("[Migration] Connections merged successfully");
+				}
+			}
+			if (selectedPipelines.length > 0 || selectedProjects.length > 0) {
+				const sourceProjectsFile = sourceContext.getProjectsPath();
+				const targetProjectsFile = context.getProjectsPath();
+				const sourceMeta = await getFileMetadata(sourceProjectsFile);
+				const targetMeta = await getFileMetadata(targetProjectsFile);
+				if (!isVersionImportable(sourceMeta.version, targetMeta.version)) throw new Error("Cannot migrate projects: Source version is newer than current version.");
+				let stableFileRepo = {
+					version: "3.0.0",
+					projects: [],
+					pipelines: []
+				};
+				if (existsSync(sourceProjectsFile)) {
+					const stableContent = await fs$1.readFile(sourceProjectsFile, "utf8");
+					stableFileRepo = JSON.parse(stableContent);
+				}
+				let betaFileRepo = {
+					version: "3.0.0",
+					projects: [],
+					pipelines: []
+				};
+				if (existsSync(targetProjectsFile)) try {
+					const betaContent = await fs$1.readFile(targetProjectsFile, "utf8");
+					betaFileRepo = JSON.parse(betaContent);
+				} catch (readErr) {
+					logger().warn("[Migration] Failed to parse existing target projects.json, starting fresh:", readErr);
+				}
+				betaFileRepo.projects = betaFileRepo.projects || [];
+				betaFileRepo.pipelines = betaFileRepo.pipelines || [];
+				for (const projId of selectedProjects) {
+					const stableProj = stableFileRepo.projects.find((p) => p.id === projId);
+					if (stableProj) {
+						const existingProjIdx = betaFileRepo.projects.findIndex((p) => p.id === projId);
+						if (existingProjIdx >= 0) betaFileRepo.projects[existingProjIdx] = { ...stableProj };
+						else betaFileRepo.projects.push({ ...stableProj });
+					}
+				}
+				for (const pipeId of selectedPipelines) {
+					const stablePipe = (stableFileRepo.pipelines || []).find((p) => p.id === pipeId);
+					if (stablePipe) {
+						const parentProjId = stablePipe.project;
+						if (!betaFileRepo.projects.some((p) => p.id === parentProjId)) {
+							const stableProj = stableFileRepo.projects.find((p) => p.id === parentProjId);
+							if (stableProj) betaFileRepo.projects.push({ ...stableProj });
+						}
+						if (stablePipe.type === "internal") {
+							const stablePipeFile = sourceContext.getConfigPath(`${stablePipe.configName}.json`);
+							const betaPipeFile = context.getConfigPath(`${stablePipe.configName}.json`);
+							if (existsSync(stablePipeFile)) {
+								await fs$1.mkdir(dirname(betaPipeFile), { recursive: true });
+								await fs$1.copyFile(stablePipeFile, betaPipeFile);
+								logger().info(`[Migration] Copied pipeline file: ${stablePipe.configName}`);
+							}
+						}
+						const updatedPipe = { ...stablePipe };
+						if (updatedPipe.type !== "pipelab-cloud") updatedPipe.lastModified = (/* @__PURE__ */ new Date()).toISOString();
+						const existingPipeIdx = betaFileRepo.pipelines.findIndex((p) => p.id === pipeId);
+						if (existingPipeIdx >= 0) betaFileRepo.pipelines[existingPipeIdx] = updatedPipe;
+						else betaFileRepo.pipelines.push(updatedPipe);
+					}
+				}
+				await fs$1.mkdir(dirname(targetProjectsFile), { recursive: true });
+				await fs$1.writeFile(targetProjectsFile, JSON.stringify(betaFileRepo, null, 2));
+				logger().info("[Migration] Merged and saved projects.json successfully");
+			}
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: { result: "ok" }
+				}
+			});
+		} catch (e) {
+			logger().error("[Migration] Error performing migration:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Failed to migrate selected data"
+				}
+			});
+		}
+	});
+};
+//#endregion
 //#region src/handlers/index.ts
 const registerAllHandlers = async (options) => {
 	const context = options.context;
@@ -10898,6 +11347,7 @@ const registerAllHandlers = async (options) => {
 	registerAuthHandlers(context);
 	registerSystemHandlers(options);
 	registerPluginsHandlers(context);
+	registerMigrationHandlers(context);
 	const { registerPlugins } = usePlugins();
 	builtInPlugins({ context });
 };
@@ -53170,9 +53620,7 @@ async function runPipelineCommand(file, options, version) {
 		version,
 		context
 	});
-	registerMigrationHandlers(context);
-	await (await setupConfigFile("settings", { context })).getConfig();
-	const cachePath = join(context.userDataPath, "cache");
+	const cachePath = context.getCachePath(CacheFolder.Pipelines, effectivePipelineId);
 	await mkdir(cachePath, { recursive: true });
 	const abortController = new AbortController();
 	let supabase;
@@ -53344,6 +53792,6 @@ async function fetchLatestDesktopRelease(options = {}) {
 	return latest;
 }
 //#endregion
-export { BuildHistoryStorage, PipelabContext, WebSocketServer, builtInPlugins, downloadFile, ensure, ensureNodeJS, ensurePNPM, executeGraphWithHistory, extractTarGz, extractZip, fetchLatestDesktopRelease, fetchLatestPackageRelease, fetchPackage, fetchPackageReleases, fetchPipelabAsset, fetchPipelabCli, fetchPipelabPlugin, findInstalledPlugins, getDefaultUserDataPath, getFinalPlugins, getFolderSize, getMigrator, handleActionExecute, isDev, isOnline, loadCustomPlugin, loadPipelabPlugin, projectRoot, registerAgentsHandlers, registerAllHandlers, registerConfigHandlers, registerEngineHandlers, registerFsHandlers, registerHistoryHandlers, registerMigrationHandlers, registerShellHandlers, runPipelineCommand, runPnpm, runWithLiveLogs, sendStartupProgress, sendStartupReady, serveCommand, setupConfigFile, useAPI, usePluginAPI, webSocketServer, zipFolder };
+export { BuildHistoryStorage, CacheFolder, PipelabContext, WebSocketServer, builtInPlugins, deletePipelineConfigFileByName, deletePipelineConfigFileByPath, downloadFile, ensure, ensureNodeJS, ensurePNPM, executeGraphWithHistory, extractTarGz, extractZip, fetchLatestDesktopRelease, fetchLatestPackageRelease, fetchPackage, fetchPackageReleases, fetchPipelabAsset, fetchPipelabCli, fetchPipelabPlugin, findInstalledPlugins, getDefaultUserDataPath, getFinalPlugins, getFolderSize, handleActionExecute, isDev, isOnline, loadCustomPlugin, loadPipelabPlugin, projectRoot, registerAgentsHandlers, registerAllHandlers, registerConfigHandlers, registerEngineHandlers, registerFsHandlers, registerHistoryHandlers, registerShellHandlers, runPipelineCommand, runPnpm, runWithLiveLogs, sendStartupProgress, sendStartupReady, serveCommand, setupConnectionsConfigFile, setupPipelineConfigFileByName, setupPipelineConfigFileByPath, setupProjectsConfigFile, setupSettingsConfigFile, useAPI, usePluginAPI, webSocketServer, zipFolder };
 
 //# sourceMappingURL=index.mjs.map