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

package/index.mjs

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import { a as __require, n as __esmMin, s as __toESM, t as __commonJSMin } from "./chunk-M2dkpuaD.mjs";
-import { S as useLogger, a as isRequired, c as supabase, g as processGraph, i as isWebSocketRequestMessage, l as SubscriptionRequiredError, n as savedFileMigrator, o as transformUrl, r as WebSocketError, s as isSupabaseAvailable, u as usePlugins } from "./src-Cgn6322X.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 { c as getFolderSize, d as execa, i as downloadFile, l as require_commonjs$8, n as getMigrator, o as extractTarGz, r as setupConfigFile, s as extractZip, t as deleteConfigFile, u as require_balanced_match } from "./config-wyW8CcHw.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";
 import fs, { createReadStream, existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { access, chmod, cp, mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import fs$1, { access, chmod, cp, mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import http from "http";
 import http$1 from "node:http";
 import { webcrypto } from "node:crypto";
@@ -90,8 +90,33 @@ 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();
@@ -99,8 +124,9 @@ var PipelabContext = class {
 		return await mkdtemp(join(await realpath(baseDir), prefix));
 	}
 	getCachePath(folder, ...subpaths) {
-		if (!folder) return join(this.userDataPath, "cache");
-		return join(this.userDataPath, "cache", 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);
@@ -4018,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
@@ -4081,39 +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 {
-			await deleteConfigFile(name, context);
 			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("connections:reset error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					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(`config:delete error for ${name}:`, 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 delete config ${name}`
+					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}`
 				}
 			});
 		}
@@ -65996,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");
@@ -66449,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", {
@@ -66560,7 +66808,6 @@ async function serveCommand(options, version, _dirname) {
 		version,
 		context
 	});
-	registerMigrationHandlers(context);
 	sendStartupReady();
 	return server;
 }
@@ -67169,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-BmqReRBI.mjs");
+	const { usePlugins } = await import("./src-DU3j_v2A.mjs");
 	const { registerPlugins } = usePlugins();
-	const { webSocketServer } = await import("./src-DhNbRNuq.mjs");
+	const { webSocketServer } = await import("./src-5EzZR-UT.mjs");
 	webSocketServer.broadcast("startup:progress", { type: "ready" });
 	(async () => {
 		const totalStart = Date.now();
@@ -67191,8 +67438,8 @@ const builtInPlugins = async (options) => {
 			"@pipelab/plugin-netlify"
 		]) pluginsToLoad.set(name, "latest");
 		try {
-			const { setupConfigFile } = await import("./config-Cjh-mvRR.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);
@@ -67291,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,
@@ -67799,7 +68046,7 @@ 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";
@@ -68331,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;
@@ -68343,6 +69054,7 @@ const registerAllHandlers = async (options) => {
 	registerAuthHandlers(context);
 	registerSystemHandlers(options);
 	registerPluginsHandlers(context);
+	registerMigrationHandlers(context);
 	const { registerPlugins } = usePlugins();
 	builtInPlugins({ context });
 };
@@ -68374,7 +69086,6 @@ async function runPipelineCommand(file, options, version) {
 		version,
 		context
 	});
-	registerMigrationHandlers(context);
 	const cachePath = context.getCachePath(CacheFolder.Pipelines, effectivePipelineId);
 	await mkdir(cachePath, { recursive: true });
 	const abortController = new AbortController();
@@ -68442,7 +69153,7 @@ async function runPipelineCommand(file, options, version) {
 }
 //#endregion
 //#region package.json
-var version$2 = "2.0.0-beta.18";
+var version$2 = "2.0.0-beta.19";
 //#endregion
 //#region src/paths.ts
 const getDefaultUserDataPath = () => {
@@ -68525,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;
@@ -68562,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);
@@ -68644,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.`);
@@ -68657,10 +69368,10 @@ async function deletePipelineCommand(id, options) {
 		}
 		const pipeline = repo.pipelines[index];
 		if (pipeline.type === "internal") try {
-			await deleteConfigFile(pipeline.configName, context);
+			await deletePipelineConfigFileByName(pipeline.configName, context);
 			console.log(`Deleted pipeline file: ${pipeline.configName}.json`);
 		} 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);
@@ -69863,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({
@@ -76507,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, PipelabContext as M, getDefaultUserDataPath$1 as N, WebSocketServer as O, projectRoot as P, 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, CacheFolder 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 };