@pipelab/cli 2.0.0-beta.17 → 2.0.0-beta.19

package/index.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { a as __require, n as __esmMin, s as __toESM, t as __commonJSMin } from "./chunk-M2dkpuaD.mjs";
-import { C as useLogger, _ as processGraph, a as isWebSocketRequestMessage, c as isSupabaseAvailable, d as usePlugins, i as WebSocketError, l as supabase, o as isRequired, r as savedFileMigrator, s as transformUrl, u as SubscriptionRequiredError } from "./src-IhkP0N4B.mjs";
+import { a as WebSocketError, c as transformUrl, d as SubscriptionRequiredError, f as usePlugins, i as savedFileMigrator, l as isSupabaseAvailable, n as connectionsMigrator, o as isWebSocketRequestMessage, r as fileRepoMigrations, s as isRequired, t as appSettingsMigrator, u as supabase, v as processGraph, w as useLogger } from "./src-CoHipk5y.mjs";
 import "./dist-BC_B45iu.mjs";
-import { a as extractTarGz, c as require_commonjs$8, l as require_balanced_match, n as setupConfigFile, o as extractZip, r as downloadFile, s as getFolderSize, t as getMigrator, u as execa } from "./config-C2_-dWDC.mjs";
+import { a as setupPipelineConfigFileByName, c as setupSettingsConfigFile, d as extractTarGz, f as extractZip, g as execa, h as require_balanced_match, i as setupConnectionsConfigFile, l as downloadFile, m as require_commonjs$8, n as deletePipelineConfigFileByPath, o as setupPipelineConfigFileByPath, p as getFolderSize, s as setupProjectsConfigFile, t as deletePipelineConfigFileByName } from "./config-C4SmHbuE.mjs";
 import path, { delimiter, dirname, isAbsolute, join, normalize, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { homedir, platform, release } from "node:os";
@@ -69,6 +69,11 @@ function findProjectRoot(startDir) {
 	return null;
 }
 const projectRoot = findProjectRoot(_dirname);
+const CacheFolder = {
+	Actions: "actions",
+	Pipelines: "pipelines",
+	Pacote: "pacote"
+};
 var PipelabContext = class {
 	userDataPath;
 	releaseTag;
@@ -85,20 +90,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");
@@ -4009,61 +4044,57 @@ const registerFsHandlers = (_context) => {
 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("settings:load", async (_, { send }) => {
+		logger().info("settings:load");
 		try {
 			send({
 				type: "end",
 				data: {
 					type: "success",
-					result: { result: await (await setupConfigFile(name, { context })).getConfig() }
+					result: await (await setupSettingsConfigFile(context)).getConfig()
 				}
 			});
 		} catch (e) {
-			logger().error(`config:load error for ${name}:`, e);
+			logger().error("settings:load error:", e);
 			send({
 				type: "end",
 				data: {
 					type: "error",
-					ipcError: e instanceof Error ? e.message : `Unable to load config ${name}`
+					ipcError: e instanceof Error ? e.message : "Unable to load settings"
 				}
 			});
 		}
 	});
-	handle("config:save", async (_, { send, value }) => {
-		const { data, config: name } = value;
+	handle("settings:save", async (_, { send, value }) => {
+		const { data } = value;
 		try {
-			const manager = await setupConfigFile(name, { context });
+			const manager = await setupSettingsConfigFile(context);
 			const json = typeof data === "string" ? JSON.parse(data) : data;
 			await manager.setConfig(json);
 			send({
 				type: "end",
 				data: {
 					type: "success",
-					result: { result: "ok" }
+					result: "ok"
 				}
 			});
 		} catch (e) {
-			logger().error(`config:save error for ${name}:`, e);
+			logger().error("settings: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 settings"
 				}
 			});
 		}
 	});
-	handle("config:reset", async (event, { value, send }) => {
-		const { config: name, key } = value;
-		logger().info("config:reset", name, key);
+	handle("settings:reset", async (_, { send, value }) => {
+		const { key } = value;
 		try {
-			const manager = await setupConfigFile(name, { context });
+			const manager = await setupSettingsConfigFile(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 = appSettingsMigrator.defaultValue[key];
 			await manager.setConfig({
 				...currentConfig ? currentConfig : {},
 				[key]: defaultValue
@@ -4072,50 +4103,300 @@ 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("settings: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 settings"
 				}
 			});
 		}
 	});
-	handle("config:delete", async (_, { send, value }) => {
-		const { config: name } = value;
-		logger().info("config:delete", name);
+	handle("connections:load", async (_, { send }) => {
+		logger().info("connections:load");
 		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 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"
+				}
+			});
+		}
+	});
+	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"
+				}
+			});
+		}
+	});
+	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"
 				}
 			});
 		} catch (e) {
-			logger().error(`config:delete error for ${name}:`, e);
+			logger().error("connections:reset error:", 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 reset connections"
+				}
+			});
+		}
+	});
+	handle("projects:load", async (_, { send }) => {
+		logger().info("projects:load");
+		try {
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: await (await setupProjectsConfigFile(context)).getConfig()
+				}
+			});
+		} catch (e) {
+			logger().error("projects:load error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to load projects"
+				}
+			});
+		}
+	});
+	handle("projects:save", async (_, { send, value }) => {
+		const { data } = value;
+		try {
+			const manager = await setupProjectsConfigFile(context);
+			const json = typeof data === "string" ? JSON.parse(data) : data;
+			await manager.setConfig(json);
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: "ok"
+				}
+			});
+		} catch (e) {
+			logger().error("projects:save error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to save projects"
+				}
+			});
+		}
+	});
+	handle("projects:reset", async (_, { send, value }) => {
+		const { key } = value;
+		try {
+			const manager = await setupProjectsConfigFile(context);
+			const currentConfig = await manager.getConfig();
+			const defaultValue = fileRepoMigrations.defaultValue[key];
+			await manager.setConfig({
+				...currentConfig ? currentConfig : {},
+				[key]: defaultValue
+			});
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: "ok"
+				}
+			});
+		} catch (e) {
+			logger().error("projects:reset error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to reset projects"
+				}
+			});
+		}
+	});
+	handle("pipeline:load-by-name", async (_, { send, value }) => {
+		const { name } = value;
+		logger().info("pipeline:load-by-name", name);
+		try {
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					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(`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}`
 				}
 			});
 		}
@@ -4284,11 +4565,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 {
@@ -4315,35 +4595,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);
@@ -4352,9 +4603,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}`);
@@ -4365,7 +4613,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;
 			}
@@ -4380,7 +4629,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);
 			}
@@ -4415,7 +4665,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) {
@@ -4449,7 +4700,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) {
@@ -4470,8 +4722,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}`);
@@ -4479,8 +4743,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.`);
@@ -4505,21 +4777,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,
@@ -4544,11 +4806,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,
@@ -4564,11 +4821,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 ../../packages/core-node/src/handlers/history.ts
@@ -4850,40 +5111,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/@npmcli/package-json/node_modules/json-parse-even-better-errors/lib/index.js
@@ -66052,8 +66279,8 @@ var require_error$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	})();
 }));
 //#endregion
-//#region ../../packages/core-node/src/migrations.ts
-var import_src$1 = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+//#region ../../node_modules/serve-handler/src/index.js
+var require_src$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { promisify: promisify$1 } = __require("util");
 	const path$3 = __require("path");
 	const { createHash } = __require("crypto");
@@ -66505,47 +66732,12 @@ var import_src$1 = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((expo
 		response.writeHead(response.statusCode || 200, headers);
 		stream.pipe(response);
 	};
-})))(), 1);
-var import_semver = /* @__PURE__ */ __toESM(require_semver(), 1);
-var import_lib = /* @__PURE__ */ __toESM(require_lib(), 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 ../../packages/core-node/src/server.ts
+var import_semver = /* @__PURE__ */ __toESM(require_semver(), 1);
+var import_lib = /* @__PURE__ */ __toESM(require_lib(), 1);
+var import_src$1 = /* @__PURE__ */ __toESM(require_src$1(), 1);
 const sendStartupProgress = (message) => {
 	console.log(`[Startup Progress] ${message}`);
 	webSocketServer.broadcast("startup:progress", {
@@ -66601,7 +66793,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$1.default)(request, response, { public: rawAssetFolder });
+		return (0, import_src$1.default)(request, response, {
+			public: rawAssetFolder,
+			rewrites: [{
+				source: "/**",
+				destination: "/index.html"
+			}]
+		});
 	});
 	console.log(`Starting Pipelab server on port ${options.port}...`);
 	console.log(`UI available at http://localhost:${options.port}`);
@@ -66610,7 +66808,6 @@ async function serveCommand(options, version, _dirname) {
 		version,
 		context
 	});
-	registerMigrationHandlers(context);
 	sendStartupReady();
 	return server;
 }
@@ -66692,7 +66889,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 = import_lib.default.packument(packageName, { cache: cachePath });
@@ -66723,7 +66920,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);
@@ -66800,7 +66997,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
 		}
@@ -67219,9 +67416,9 @@ const builtInPlugins = async (options) => {
 	const envStart = Date.now();
 	await Promise.all([ensureNodeJS(options.context), ensurePNPM(options.context)]);
 	console.log(`[Plugins] Environment preparation took ${Date.now() - envStart}ms`);
-	const { usePlugins } = await import("./src-XVe3IQMi.mjs");
+	const { usePlugins } = await import("./src-DU3j_v2A.mjs");
 	const { registerPlugins } = usePlugins();
-	const { webSocketServer } = await import("./src-CHr-wGNr.mjs");
+	const { webSocketServer } = await import("./src-5EzZR-UT.mjs");
 	webSocketServer.broadcast("startup:progress", { type: "ready" });
 	(async () => {
 		const totalStart = Date.now();
@@ -67241,8 +67438,8 @@ const builtInPlugins = async (options) => {
 			"@pipelab/plugin-netlify"
 		]) pluginsToLoad.set(name, "latest");
 		try {
-			const { setupConfigFile } = await import("./config-kWOWhsn6.mjs");
-			const settingsPlugins = (await (await setupConfigFile("settings", { context: options.context })).getConfig())?.plugins || [];
+			const { setupSettingsConfigFile } = await import("./config-B-M_kmKR.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);
@@ -67312,6 +67509,7 @@ const executeGraphWithHistory = async ({ graph, variables, projectName, projectP
 		projectName,
 		projectPath,
 		pipelineId,
+		cachePath,
 		startTime,
 		status: "running",
 		logs: [],
@@ -67340,7 +67538,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,
@@ -67408,7 +67606,6 @@ const executeGraphWithHistory = async ({ graph, variables, projectName, projectP
 		}, pipelineId);
 		throw error;
 	} finally {
-		if (!shouldDisableHistory) buildHistoryStorage.applyRetentionPolicy();
 		try {
 			await rm(sandboxPath, {
 				recursive: true,
@@ -67417,6 +67614,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
@@ -67792,24 +67997,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;
@@ -67833,11 +68046,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 {
@@ -67945,7 +68158,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 });
@@ -68365,6 +68578,470 @@ const registerPluginsHandlers = (context) => {
 	});
 };
 //#endregion
+//#region ../../packages/core-node/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 = import_semver.default.coerce(sourceVer);
+			const coercedTarget = import_semver.default.coerce(targetVer);
+			if (!coercedSource) return false;
+			if (!coercedTarget) return true;
+			return import_semver.default.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$1(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$1(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 ../../packages/core-node/src/handlers/index.ts
 const registerAllHandlers = async (options) => {
 	const context = options.context;
@@ -68377,6 +69054,7 @@ const registerAllHandlers = async (options) => {
 	registerAuthHandlers(context);
 	registerSystemHandlers(options);
 	registerPluginsHandlers(context);
+	registerMigrationHandlers(context);
 	const { registerPlugins } = usePlugins();
 	builtInPlugins({ context });
 };
@@ -68408,9 +69086,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;
@@ -68477,7 +69153,7 @@ async function runPipelineCommand(file, options, version) {
 }
 //#endregion
 //#region package.json
-var version$2 = "2.0.0-beta.17";
+var version$2 = "2.0.0-beta.19";
 //#endregion
 //#region src/paths.ts
 const getDefaultUserDataPath = () => {
@@ -68528,7 +69204,8 @@ function formatBytes(bytes, decimals = 2) {
 	return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + " " + sizes[i];
 }
 async function usageCommand(options) {
-	const info = await new BuildHistoryStorage(new PipelabContext({ userDataPath: options.userData || getDefaultUserDataPath() })).getStorageInfo();
+	const context = new PipelabContext({ userDataPath: options.userData || getDefaultUserDataPath() });
+	const info = await new BuildHistoryStorage(context).getStorageInfo();
 	console.log("Build History Storage Usage:");
 	console.table({
 		"Total Entries": info.totalEntries,
@@ -68537,13 +69214,7 @@ async function usageCommand(options) {
 		"Oldest Entry": info.oldestEntry ? new Date(info.oldestEntry).toLocaleString() : "N/A",
 		"Newest Entry": info.newestEntry ? new Date(info.newestEntry).toLocaleString() : "N/A",
 		"User Data Path": info.userDataPath,
-		"Cache Path": join(info.userDataPath, "build-history")
-	});
-	console.log("\nRetention Policy:");
-	console.table({
-		Enabled: info.retentionPolicy.enabled ? "Yes" : "No",
-		"Max Entries": info.retentionPolicy.maxEntries > 0 ? info.retentionPolicy.maxEntries : "Unlimited",
-		"Max Age (days)": info.retentionPolicy.maxAge > 0 ? info.retentionPolicy.maxAge : "Unlimited"
+		"Cache Path": context.getBuildHistoryPath()
 	});
 }
 async function purgeCommand(pipelineId, options) {
@@ -68565,7 +69236,7 @@ async function purgeCommand(pipelineId, options) {
 async function listPipelinesCommand(options) {
 	const context = new PipelabContext({ userDataPath: options.userData || getDefaultUserDataPath() });
 	try {
-		const repo = await (await setupConfigFile("projects", { context })).getConfig();
+		const repo = await (await setupProjectsConfigFile(context)).getConfig();
 		if (!repo.pipelines || repo.pipelines.length === 0) {
 			console.log("No pipelines found.");
 			return;
@@ -68602,7 +69273,7 @@ async function listPipelinesCommand(options) {
 async function showPipelineCommand(idOrName, options) {
 	const context = new PipelabContext({ userDataPath: options.userData || getDefaultUserDataPath() });
 	try {
-		const pipeline = (await (await setupConfigFile("projects", { context })).getConfig()).pipelines?.find((p) => p.id === idOrName || p.type === "internal" && p.configName === idOrName || p.type === "external" && p.path.includes(idOrName));
+		const pipeline = (await (await setupProjectsConfigFile(context)).getConfig()).pipelines?.find((p) => p.id === idOrName || p.type === "internal" && p.configName === idOrName || p.type === "external" && p.path.includes(idOrName));
 		if (!pipeline) {
 			console.error(`Pipeline "${idOrName}" not found.`);
 			process.exit(1);
@@ -68684,7 +69355,7 @@ async function deletePipelineCommand(id, options) {
 	}
 	const context = new PipelabContext({ userDataPath: options.userData || getDefaultUserDataPath() });
 	try {
-		const projectsConfig = await setupConfigFile("projects", { context });
+		const projectsConfig = await setupProjectsConfigFile(context);
 		const repo = await projectsConfig.getConfig();
 		if (!repo.pipelines) {
 			console.error(`Pipeline "${id}" not found.`);
@@ -68697,16 +69368,10 @@ async function deletePipelineCommand(id, options) {
 		}
 		const pipeline = repo.pipelines[index];
 		if (pipeline.type === "internal") try {
-			const filePath = context.getConfigPath(`${pipeline.configName}.json`);
-			await unlink(filePath);
+			await deletePipelineConfigFileByName(pipeline.configName, context);
 			console.log(`Deleted pipeline file: ${pipeline.configName}.json`);
-			const parsedPath = path.parse(filePath);
-			const dirEntries = await readdir(parsedPath.dir).catch(() => []);
-			const prefix = `${parsedPath.name}.v`;
-			const suffix = `.json`;
-			for (const entry of dirEntries) if (entry.startsWith(prefix) && entry.endsWith(suffix)) await unlink(path.join(parsedPath.dir, entry)).catch(() => {});
 		} catch (e) {
-			if (e.code !== "ENOENT") console.warn(`Warning: Could not delete pipeline file: ${e.message}`);
+			console.warn(`Warning: Could not delete pipeline file: ${e.message}`);
 		}
 		repo.pipelines.splice(index, 1);
 		await projectsConfig.setConfig(repo);
@@ -69909,7 +70574,7 @@ async function setupCommand(options) {
 		await setTimeout$1(1500);
 		s.stop("Authenticated successfully!");
 	}
-	const settings = await setupConfigFile("settings", { context });
+	const settings = await setupSettingsConfigFile(context);
 	const config = await settings.getConfig();
 	const configChanges = await dt({
 		theme: () => _t({
@@ -76553,4 +77218,4 @@ program.hook("postAction", (thisCommand) => {
 program.parse(process.argv);
 if (!process.argv.slice(2).length) program.outputHelp();
 //#endregion
-export { useAPI as A, registerHistoryHandlers as C, registerShellHandlers as D, registerFsHandlers as E, getDefaultUserDataPath$1 as M, projectRoot as N, WebSocketServer as O, registerMigrationHandlers as S, registerConfigHandlers as T, isOnline as _, executeGraphWithHistory as a, sendStartupReady as b, findInstalledPlugins as c, handleActionExecute as d, ensureNodeJS as f, fetchPipelabPlugin as g, fetchPipelabAsset as h, registerEngineHandlers as i, PipelabContext as j, webSocketServer as k, loadCustomPlugin as l, fetchPackage as m, registerAllHandlers as n, getFinalPlugins as o, ensurePNPM as p, registerAgentsHandlers as r, builtInPlugins as s, runPipelineCommand as t, loadPipelabPlugin as u, runPnpm as v, BuildHistoryStorage as w, serveCommand as x, sendStartupProgress as y };
+export { CacheFolder as A, BuildHistoryStorage as C, WebSocketServer as D, registerShellHandlers as E, getDefaultUserDataPath$1 as M, projectRoot as N, webSocketServer as O, registerHistoryHandlers as S, registerFsHandlers as T, isOnline as _, executeGraphWithHistory as a, sendStartupReady as b, findInstalledPlugins as c, handleActionExecute as d, ensureNodeJS as f, fetchPipelabPlugin as g, fetchPipelabAsset as h, registerEngineHandlers as i, PipelabContext as j, useAPI as k, loadCustomPlugin as l, fetchPackage as m, registerAllHandlers as n, getFinalPlugins as o, ensurePNPM as p, registerAgentsHandlers as r, builtInPlugins as s, runPipelineCommand as t, loadPipelabPlugin as u, runPnpm as v, registerConfigHandlers as w, serveCommand as x, sendStartupProgress as y };