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

package/dist/index.mjs

@@ -1,19 +1,16 @@
+import { a as setupPipelineConfigFileByName, c as setupSettingsConfigFile, d as extractTarGz, f as extractZip, h as zipFolder, i as setupConnectionsConfigFile, l as downloadFile, m as runWithLiveLogs, n as deletePipelineConfigFileByPath, o as setupPipelineConfigFileByPath, p as getFolderSize, s as setupProjectsConfigFile, t as deletePipelineConfigFileByName, u as ensure } from "./config-CFgGRD9U.mjs";
 import { createRequire } from "node:module";
 import path, { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
 import { homedir, platform } from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import fs, { createWriteStream, existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import fs, { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import fs$1, { access, chmod, cp, mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { DEFAULT_NODE_VERSION, DEFAULT_PNPM_VERSION, SandboxFolder, getUiDevServerMissingWarning, uiDevPort, websocketPort } from "@pipelab/constants";
 import { WebSocket, WebSocketServer as WebSocketServer$1 } from "ws";
 import http from "node:http";
 import { nanoid } from "nanoid";
-import { SubscriptionRequiredError, WebSocketError, configRegistry, isRequired, isSupabaseAvailable, isWebSocketRequestMessage, processGraph, savedFileMigrator, supabase, transformUrl, useLogger, usePlugins } from "@pipelab/shared";
+import { SubscriptionRequiredError, WebSocketError, appSettingsMigrator, connectionsMigrator, fileRepoMigrations, isRequired, isSupabaseAvailable, isWebSocketRequestMessage, processGraph, savedFileMigrator, supabase, transformUrl, useLogger, usePlugins } from "@pipelab/shared";
 import { execa } from "execa";
-import tar from "tar";
-import yauzl from "yauzl";
-import archiver from "archiver";
-import { pipeline } from "node:stream/promises";
 import checkDiskSpace from "check-disk-space";
 import dns from "node:dns/promises";
 import pacote from "pacote";
@@ -101,8 +98,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();
@@ -110,8 +132,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);
@@ -511,289 +534,207 @@ const registerFsHandlers = (_context) => {
 	});
 };
 //#endregion
-//#region src/utils/fs-extras.ts
-/**
-* Ensures a directory exists and a file is created with default content if missing.
-*/
-const ensure = async (filesPath, defaultContent = "{}") => {
-	await mkdir(dirname(filesPath), { recursive: true });
-	try {
-		if ((await stat(filesPath)).size === 0) await writeFile(filesPath, defaultContent);
-	} catch {
-		await writeFile(filesPath, defaultContent);
-	}
-};
-/**
-* Extracts a .tar.gz archive.
-*/
-async function extractTarGz(archivePath, destinationDir) {
-	await mkdir(destinationDir, { recursive: true });
-	await tar.x({
-		file: archivePath,
-		cwd: destinationDir
-	});
-}
-/**
-* Extracts a .zip archive.
-*/
-async function extractZip(archivePath, destinationDir) {
-	await mkdir(destinationDir, { recursive: true });
-	return new Promise((resolve, reject) => {
-		yauzl.open(archivePath, { lazyEntries: true }, (err, zipfile) => {
-			if (err || !zipfile) return reject(err || /* @__PURE__ */ new Error("Could not open zip file"));
-			zipfile.on("error", reject);
-			zipfile.readEntry();
-			zipfile.on("entry", (entry) => {
-				const entryPath = join(destinationDir, entry.fileName);
-				if (/\/$/.test(entry.fileName)) mkdir(entryPath, { recursive: true }).then(() => zipfile.readEntry()).catch(reject);
-				else mkdir(dirname(entryPath), { recursive: true }).then(() => {
-					zipfile.openReadStream(entry, (err, readStream) => {
-						if (err || !readStream) return reject(err || /* @__PURE__ */ new Error("Could not open read stream"));
-						readStream.on("error", reject);
-						const writeStream = createWriteStream(entryPath);
-						writeStream.on("error", reject);
-						writeStream.on("close", () => zipfile.readEntry());
-						readStream.pipe(writeStream);
-					});
-				}).catch(reject);
+//#region src/handlers/config.ts
+const registerConfigHandlers = (context) => {
+	const { handle } = useAPI();
+	const { logger } = useLogger();
+	handle("settings:load", async (_, { send }) => {
+		logger().info("settings:load");
+		try {
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: await (await setupSettingsConfigFile(context)).getConfig()
+				}
 			});
-			zipfile.on("end", () => resolve());
-		});
+		} catch (e) {
+			logger().error("settings:load error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to load settings"
+				}
+			});
+		}
 	});
-}
-/**
-* Zips a folder.
-*/
-const zipFolder = async (from, to, log = console.log) => {
-	const output = createWriteStream(to);
-	const archive = archiver("zip", { zlib: { level: 9 } });
-	return new Promise((resolve, reject) => {
-		output.on("close", () => {
-			log(archive.pointer() + " total bytes");
-			resolve(to);
-		});
-		archive.on("error", reject);
-		archive.pipe(output);
-		archive.directory(from, false);
-		archive.finalize();
+	handle("settings:save", async (_, { send, value }) => {
+		const { data } = value;
+		try {
+			const manager = await setupSettingsConfigFile(context);
+			const json = typeof data === "string" ? JSON.parse(data) : data;
+			await manager.setConfig(json);
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: "ok"
+				}
+			});
+		} catch (e) {
+			logger().error("settings:save error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to save settings"
+				}
+			});
+		}
 	});
-};
-const downloadFile = async (url, localPath, hooks, abortSignal) => {
-	const response = await fetch(url, { signal: abortSignal });
-	if (!response.ok) throw new Error(`Failed to fetch file: ${response.statusText}`);
-	const contentLength = response.headers.get("content-length");
-	if (!contentLength) throw new Error("Content-Length header is missing");
-	const totalSize = parseInt(contentLength, 10);
-	let downloadedSize = 0;
-	const fileStream = createWriteStream(localPath);
-	const progressStream = new TransformStream({ transform(chunk, controller) {
-		downloadedSize += chunk.length;
-		const progress = downloadedSize / totalSize * 100;
-		hooks?.onProgress?.({
-			progress,
-			downloadedSize
-		});
-		controller.enqueue(chunk);
-	} });
-	const readable = response.body?.pipeThrough(progressStream);
-	if (!readable) throw new Error("Failed to create a readable stream");
-	await pipeline(readable, fileStream);
-};
-const runWithLiveLogs = async (command, args, execaOptions, log, hooks, abortSignal) => {
-	const subprocess = execa(command, args, {
-		...execaOptions,
-		stdout: "pipe",
-		stderr: "pipe",
-		stdin: "pipe",
-		env: {
-			...process.env,
-			...execaOptions.env,
-			TERM: "xterm-256color",
-			FORCE_STDERR_LOGGING: "1"
-		},
-		cancelSignal: abortSignal
+	handle("settings:reset", async (_, { send, value }) => {
+		const { key } = value;
+		try {
+			const manager = await setupSettingsConfigFile(context);
+			const currentConfig = await manager.getConfig();
+			const defaultValue = appSettingsMigrator.defaultValue[key];
+			await manager.setConfig({
+				...currentConfig ? currentConfig : {},
+				[key]: defaultValue
+			});
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: "ok"
+				}
+			});
+		} catch (e) {
+			logger().error("settings:reset error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to reset settings"
+				}
+			});
+		}
 	});
-	hooks?.onCreated?.(subprocess);
-	subprocess.stdout?.on("data", (data) => {
-		hooks?.onStdout?.(data.toString(), subprocess);
+	handle("connections:load", async (_, { send }) => {
+		logger().info("connections:load");
+		try {
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: await (await setupConnectionsConfigFile(context)).getConfig()
+				}
+			});
+		} catch (e) {
+			logger().error("connections:load error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to load connections"
+				}
+			});
+		}
 	});
-	subprocess.stderr?.on("data", (data) => {
-		hooks?.onStderr?.(data.toString(), subprocess);
+	handle("connections:save", async (_, { send, value }) => {
+		const { data } = value;
+		try {
+			const manager = await setupConnectionsConfigFile(context);
+			const json = typeof data === "string" ? JSON.parse(data) : data;
+			await manager.setConfig(json);
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: "ok"
+				}
+			});
+		} catch (e) {
+			logger().error("connections:save error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to save connections"
+				}
+			});
+		}
 	});
-	try {
-		const { exitCode } = await subprocess;
-		hooks?.onExit?.(exitCode ?? 0);
-	} catch (error) {
-		const code = error.exitCode ?? 1;
-		hooks?.onExit?.(code);
-		throw new Error(`Command failed with exit code ${code}: ${error.message}`);
-	}
-};
-/**
-* Calculates the total size of a directory recursively.
-*/
-async function getFolderSize(dirPath) {
-	try {
-		const ArrayOfPromises = (await readdir(dirPath, { withFileTypes: true })).map(async (file) => {
-			const path = join(dirPath, file.name);
-			if (file.isDirectory()) try {
-				return await getFolderSize(path);
-			} catch {
-				return 0;
-			}
-			try {
-				const { size } = await stat(path);
-				return size;
-			} catch {
-				return 0;
-			}
-		});
-		return (await Promise.all(ArrayOfPromises)).reduce((acc, size) => acc + size, 0);
-	} catch {
-		return 0;
-	}
-}
-//#endregion
-//#region src/config.ts
-const getMigrator = (name) => {
-	return configRegistry[name] || configRegistry["pipeline"];
-};
-const setupConfigFile = async (name, options) => {
-	const ctx = options.context;
-	const migrator = options.migrator || getMigrator(name);
-	if (!migrator) throw new Error(`No migrator found for configuration: ${name}. All managed files must have a migration schema.`);
-	const filesPath = path.isAbsolute(name) ? name : ctx.getConfigPath(`${name}.json`);
-	await ensure(filesPath, JSON.stringify(migrator.defaultValue));
-	return {
-		setConfig: async (config) => {
-			const { logger } = useLogger();
-			try {
-				await fs$1.writeFile(filesPath, JSON.stringify(config));
-				return true;
-			} catch (e) {
-				logger().error(`Error saving config ${name}:`, e);
-				return false;
-			}
-		},
-		getConfig: async () => {
-			const { logger } = useLogger();
-			let content = void 0;
-			let originalJson = void 0;
-			let parseFailed = false;
-			try {
-				content = await fs$1.readFile(filesPath, "utf8");
-				if (content !== void 0) originalJson = JSON.parse(content);
-			} catch (e) {
-				logger().error(`Error reading or parsing config ${name}:`, e);
-				parseFailed = true;
-			}
-			let json = void 0;
-			let migrationFailed = false;
-			try {
-				if (!parseFailed) json = await migrator.migrate(originalJson, {
-					debug: false,
-					onStep: async (state, version) => {
-						const parsedPath = path.parse(filesPath);
-						const versionedPath = ctx.getConfigPath(`${parsedPath.name}.v${version}.json`);
-						try {
-							await fs$1.writeFile(versionedPath, JSON.stringify(state));
-							logger().info(`Intermediate backup created for ${name} at ${versionedPath}`);
-						} catch (e) {
-							logger().error(`Failed to create intermediate backup for ${name} at v${version}:`, e);
-						}
-					}
-				});
-				else json = migrator.defaultValue;
-			} catch (e) {
-				logger().error(`Error migrating config ${name}:`, e);
-				migrationFailed = true;
-				json = migrator.defaultValue;
-			}
-			if (originalJson?.version !== json?.version || content === void 0 || parseFailed || migrationFailed) {
-				if (parseFailed || migrationFailed) try {
-					const parsedPath = path.parse(filesPath);
-					const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-					const corruptedPath = ctx.getConfigPath(`${parsedPath.name}.corrupted.${timestamp}.json`);
-					const backupContent = parseFailed ? content || "" : JSON.stringify(originalJson, null, 2);
-					await fs$1.writeFile(corruptedPath, backupContent);
-					logger().info(`Corrupted config file preserved at ${corruptedPath}`);
-				} catch (e) {
-					logger().error(`Failed to backup corrupted config ${name}:`, e);
+	handle("connections:reset", async (_, { send, value }) => {
+		const { key } = value;
+		try {
+			const manager = await setupConnectionsConfigFile(context);
+			const currentConfig = await manager.getConfig();
+			const defaultValue = connectionsMigrator.defaultValue[key];
+			await manager.setConfig({
+				...currentConfig ? currentConfig : {},
+				[key]: defaultValue
+			});
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: "ok"
 				}
-				try {
-					await fs$1.writeFile(filesPath, JSON.stringify(json));
-				} catch (e) {
-					logger().error(`Error saving migrated config ${name}:`, e);
+			});
+		} catch (e) {
+			logger().error("connections:reset error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to reset connections"
 				}
-			}
-			return json;
+			});
 		}
-	};
-};
-const deleteConfigFile = async (nameOrPath, context) => {
-	const filesPath = path.isAbsolute(nameOrPath) ? nameOrPath : context.getConfigPath(`${nameOrPath}.json`);
-	await fs$1.rm(filesPath, { force: true });
-};
-//#endregion
-//#region src/handlers/config.ts
-const registerConfigHandlers = (context) => {
-	const { handle } = useAPI();
-	const { logger } = useLogger();
-	handle("config:load", async (_, { send, value }) => {
-		const { config: name } = value;
-		logger().info("config:load", name);
+	});
+	handle("projects:load", async (_, { send }) => {
+		logger().info("projects:load");
 		try {
 			send({
 				type: "end",
 				data: {
 					type: "success",
-					result: { result: await (await setupConfigFile(name, { context })).getConfig() }
+					result: await (await setupProjectsConfigFile(context)).getConfig()
 				}
 			});
 		} catch (e) {
-			logger().error(`config:load error for ${name}:`, e);
+			logger().error("projects:load error:", e);
 			send({
 				type: "end",
 				data: {
 					type: "error",
-					ipcError: e instanceof Error ? e.message : `Unable to load config ${name}`
+					ipcError: e instanceof Error ? e.message : "Unable to load projects"
 				}
 			});
 		}
 	});
-	handle("config:save", async (_, { send, value }) => {
-		const { data, config: name } = value;
+	handle("projects:save", async (_, { send, value }) => {
+		const { data } = value;
 		try {
-			const manager = await setupConfigFile(name, { context });
+			const manager = await setupProjectsConfigFile(context);
 			const json = typeof data === "string" ? JSON.parse(data) : data;
 			await manager.setConfig(json);
 			send({
 				type: "end",
 				data: {
 					type: "success",
-					result: { result: "ok" }
+					result: "ok"
 				}
 			});
 		} catch (e) {
-			logger().error(`config:save error for ${name}:`, e);
+			logger().error("projects:save error:", e);
 			send({
 				type: "end",
 				data: {
 					type: "error",
-					ipcError: e instanceof Error ? e.message : `Unable to save config ${name}`
+					ipcError: e instanceof Error ? e.message : "Unable to save projects"
 				}
 			});
 		}
 	});
-	handle("config:reset", async (event, { value, send }) => {
-		const { config: name, key } = value;
-		logger().info("config:reset", name, key);
+	handle("projects:reset", async (_, { send, value }) => {
+		const { key } = value;
 		try {
-			const manager = await setupConfigFile(name, { context });
+			const manager = await setupProjectsConfigFile(context);
 			const currentConfig = await manager.getConfig();
-			const migrator = getMigrator(name);
-			if (!migrator) throw new Error(`No migrator found for configuration: ${name}`);
-			const defaultValue = migrator.defaultValue[key];
+			const defaultValue = fileRepoMigrations.defaultValue[key];
 			await manager.setConfig({
 				...currentConfig ? currentConfig : {},
 				[key]: defaultValue
@@ -802,39 +743,154 @@ const registerConfigHandlers = (context) => {
 				type: "end",
 				data: {
 					type: "success",
-					result: { result: "ok" }
+					result: "ok"
 				}
 			});
 		} catch (e) {
-			logger().error(`config:reset error for ${name}:`, e);
+			logger().error("projects:reset error:", e);
 			send({
 				type: "end",
 				data: {
 					type: "error",
-					ipcError: e instanceof Error ? e.message : `Unable to reset config ${name}`
+					ipcError: e instanceof Error ? e.message : "Unable to reset projects"
 				}
 			});
 		}
 	});
-	handle("config:delete", async (_, { send, value }) => {
-		const { config: name } = value;
-		logger().info("config:delete", name);
+	handle("pipeline:load-by-name", async (_, { send, value }) => {
+		const { name } = value;
+		logger().info("pipeline:load-by-name", name);
 		try {
-			await deleteConfigFile(name, context);
 			send({
 				type: "end",
 				data: {
 					type: "success",
-					result: { result: "ok" }
+					result: await (await setupPipelineConfigFileByName(name, context)).getConfig()
+				}
+			});
+		} catch (e) {
+			logger().error(`pipeline:load-by-name error for ${name}:`, e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : `Unable to load pipeline ${name}`
+				}
+			});
+		}
+	});
+	handle("pipeline:load-by-path", async (_, { send, value }) => {
+		const { path: absolutePath } = value;
+		logger().info("pipeline:load-by-path", absolutePath);
+		try {
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: await (await setupPipelineConfigFileByPath(absolutePath, context)).getConfig()
+				}
+			});
+		} catch (e) {
+			logger().error(`pipeline:load-by-path error for ${absolutePath}:`, e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : `Unable to load pipeline ${absolutePath}`
+				}
+			});
+		}
+	});
+	handle("pipeline:save-by-name", async (_, { send, value }) => {
+		const { data, name } = value;
+		try {
+			const manager = await setupPipelineConfigFileByName(name, context);
+			const json = typeof data === "string" ? JSON.parse(data) : data;
+			await manager.setConfig(json);
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: "ok"
+				}
+			});
+		} catch (e) {
+			logger().error(`pipeline:save-by-name error for ${name}:`, e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : `Unable to save pipeline ${name}`
+				}
+			});
+		}
+	});
+	handle("pipeline:save-by-path", async (_, { send, value }) => {
+		const { data, path: absolutePath } = value;
+		try {
+			const manager = await setupPipelineConfigFileByPath(absolutePath, context);
+			const json = typeof data === "string" ? JSON.parse(data) : data;
+			await manager.setConfig(json);
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: "ok"
+				}
+			});
+		} catch (e) {
+			logger().error(`pipeline:save-by-path error for ${absolutePath}:`, e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : `Unable to save pipeline ${absolutePath}`
+				}
+			});
+		}
+	});
+	handle("pipeline:delete-by-name", async (_, { send, value }) => {
+		const { name } = value;
+		logger().info("pipeline:delete-by-name", name);
+		try {
+			await deletePipelineConfigFileByName(name, context);
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: "ok"
+				}
+			});
+		} catch (e) {
+			logger().error(`pipeline:delete-by-name error for ${name}:`, e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : `Unable to delete pipeline ${name}`
+				}
+			});
+		}
+	});
+	handle("pipeline:delete-by-path", async (_, { send, value }) => {
+		const { path: absolutePath } = value;
+		logger().info("pipeline:delete-by-path", absolutePath);
+		try {
+			await deletePipelineConfigFileByPath(absolutePath, context);
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: "ok"
 				}
 			});
 		} catch (e) {
-			logger().error(`config:delete error for ${name}:`, e);
+			logger().error(`pipeline:delete-by-path error for ${absolutePath}:`, e);
 			send({
 				type: "end",
 				data: {
 					type: "error",
-					ipcError: e instanceof Error ? e.message : `Unable to delete config ${name}`
+					ipcError: e instanceof Error ? e.message : `Unable to delete pipeline ${absolutePath}`
 				}
 			});
 		}
@@ -8383,7 +8439,7 @@ var require_error = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	})();
 }));
 //#endregion
-//#region src/migrations.ts
+//#region src/server.ts
 var import_src = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { promisify } = __require("util");
 	const path$1 = __require("path");
@@ -8837,44 +8893,6 @@ var import_src = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((export
 		stream.pipe(response);
 	};
 })))(), 1);
-/**
-* Registers migration handlers for the CLI/Standalone server.
-* This overrides the default handlers from @pipelab/core-node to include
-* pipeline and file repo migrations directly in the backend.
-*/
-function registerMigrationHandlers(context) {
-	const { handle } = useAPI();
-	const { logger } = useLogger();
-	handle("config:load", async (_, { send, value }) => {
-		const { config: name } = value;
-		logger().info("[CLI Migration] config:load", name);
-		try {
-			const migrator = getMigrator(name);
-			if (!migrator) throw new Error(`No migrator found for configuration: ${name}. All files loaded via config:load MUST have a migration schema.`);
-			send({
-				type: "end",
-				data: {
-					type: "success",
-					result: { result: await (await setupConfigFile(name, {
-						context,
-						migrator
-					})).getConfig() }
-				}
-			});
-		} catch (e) {
-			logger().error(`[CLI Migration] config:load error for ${name}:`, e);
-			send({
-				type: "end",
-				data: {
-					type: "error",
-					ipcError: e instanceof Error ? e.message : `Unable to load config ${name}`
-				}
-			});
-		}
-	});
-}
-//#endregion
-//#region src/server.ts
 const sendStartupProgress = (message) => {
 	console.log(`[Startup Progress] ${message}`);
 	webSocketServer.broadcast("startup:progress", {
@@ -8961,7 +8979,6 @@ async function serveCommand(options, version, _dirname) {
 		version,
 		context
 	});
-	registerMigrationHandlers(context);
 	sendStartupReady();
 	return server;
 }
@@ -9693,8 +9710,8 @@ const builtInPlugins = async (options) => {
 			}
 		}
 		try {
-			const { setupConfigFile } = await import("./config-CEkOf95p.mjs");
-			const settingsPlugins = (await (await setupConfigFile("settings", { context: options.context })).getConfig())?.plugins || [];
+			const { setupSettingsConfigFile } = await import("./config-Bi0ORcTK.mjs");
+			const settingsPlugins = (await (await setupSettingsConfigFile(options.context)).getConfig())?.plugins || [];
 			for (const plugin of settingsPlugins) if (plugin.name) if (plugin.enabled) {
 				if (!pluginsToLoad.has(plugin.name)) pluginsToLoad.set(plugin.name, "latest");
 			} else pluginsToLoad.delete(plugin.name);
@@ -9793,7 +9810,7 @@ const executeGraphWithHistory = async ({ graph, variables, projectName, projectP
 		} else logger().error(`[Runner] Failed to load or register plugin "${pluginId}"`);
 	}
 	logger().info(`[Sandbox] Execution sandbox created at: ${sandboxPath}`);
-	await (await setupConfigFile("settings", { context: ctx })).getConfig();
+	await (await setupSettingsConfigFile(ctx)).getConfig();
 	try {
 		const result = await processGraph({
 			graph,
@@ -10301,7 +10318,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";
@@ -10854,6 +10871,470 @@ const registerPluginsHandlers = (context) => {
 	});
 };
 //#endregion
+//#region src/handlers/migration.ts
+const registerMigrationHandlers = (context) => {
+	const { handle } = useAPI();
+	const { logger } = useLogger();
+	const getFileMetadata = async (filePath) => {
+		const exists = existsSync(filePath);
+		let mtime = Date.now();
+		let version = null;
+		if (exists) {
+			try {
+				const stat = await fs$1.stat(filePath);
+				mtime = stat.mtime ? stat.mtime.getTime() : Date.now();
+			} catch (e) {
+				mtime = Date.now();
+			}
+			try {
+				const content = await fs$1.readFile(filePath, "utf8");
+				const json = JSON.parse(content);
+				version = json && typeof json.version === "string" ? json.version : null;
+			} catch (e) {}
+		} else mtime = Date.now();
+		return {
+			exists,
+			mtime,
+			version
+		};
+	};
+	const isVersionImportable = (sourceVer, targetVer) => {
+		if (!sourceVer) return false;
+		if (!targetVer) return true;
+		try {
+			const coercedSource = semver.coerce(sourceVer);
+			const coercedTarget = semver.coerce(targetVer);
+			if (!coercedSource) return false;
+			if (!coercedTarget) return true;
+			return semver.lte(coercedSource, coercedTarget);
+		} catch {
+			return sourceVer <= targetVer;
+		}
+	};
+	handle("migration:scan-stable", async (_, { send }) => {
+		logger().info("[Migration] Scanning other channel database...");
+		try {
+			const isStable = context.userDataPath.endsWith("app") || !context.userDataPath.includes("app-beta");
+			const sourceEnv = isStable ? "beta" : "prod";
+			const sourcePath = getDefaultUserDataPath(sourceEnv);
+			if (sourcePath === context.userDataPath) {
+				logger().info("[Migration] Running in same channel. Disabling migration scan.");
+				return send({
+					type: "end",
+					data: {
+						type: "success",
+						result: {
+							sourceChannel: isStable ? "Beta" : "Stable",
+							targetChannel: isStable ? "Stable" : "Beta",
+							settingsExists: false,
+							settingsVersion: null,
+							settingsVersionTarget: null,
+							settingsMtimeSource: Date.now(),
+							settingsMtimeTarget: Date.now(),
+							settingsImportable: false,
+							connectionsExists: false,
+							connectionsCount: 0,
+							connectionsVersion: null,
+							connectionsVersionTarget: null,
+							connectionsMtimeSource: Date.now(),
+							connectionsMtimeTarget: Date.now(),
+							connectionsImportable: false,
+							projectsExists: false,
+							projectsVersion: null,
+							projectsVersionTarget: null,
+							projectsMtimeSource: Date.now(),
+							projectsMtimeTarget: Date.now(),
+							projectsImportable: false,
+							projects: []
+						}
+					}
+				});
+			}
+			const sourceContext = new PipelabContext({
+				userDataPath: sourcePath,
+				releaseTag: sourceEnv
+			});
+			const sourceSettingsPath = sourceContext.getSettingsPath();
+			const targetSettingsPath = context.getSettingsPath();
+			const sourceConnectionsPath = sourceContext.getConnectionsPath();
+			const targetConnectionsPath = context.getConnectionsPath();
+			const sourceProjectsPath = sourceContext.getProjectsPath();
+			const targetProjectsPath = context.getProjectsPath();
+			const sourceSettingsMeta = await getFileMetadata(sourceSettingsPath);
+			const targetSettingsMeta = await getFileMetadata(targetSettingsPath);
+			const sourceConnectionsMeta = await getFileMetadata(sourceConnectionsPath);
+			const targetConnectionsMeta = await getFileMetadata(targetConnectionsPath);
+			const sourceProjectsMeta = await getFileMetadata(sourceProjectsPath);
+			const targetProjectsMeta = await getFileMetadata(targetProjectsPath);
+			const settingsExists = sourceSettingsMeta.exists;
+			const settingsVersion = sourceSettingsMeta.version;
+			const settingsMtimeSource = sourceSettingsMeta.mtime;
+			const settingsMtimeTarget = targetSettingsMeta.mtime;
+			const settingsImportable = isVersionImportable(settingsVersion, targetSettingsMeta.version);
+			const connectionsExists = sourceConnectionsMeta.exists;
+			const connectionsVersion = sourceConnectionsMeta.version;
+			const connectionsMtimeSource = sourceConnectionsMeta.mtime;
+			const connectionsMtimeTarget = targetConnectionsMeta.mtime;
+			const connectionsImportable = isVersionImportable(connectionsVersion, targetConnectionsMeta.version);
+			const projectsExists = sourceProjectsMeta.exists;
+			const projectsVersion = sourceProjectsMeta.version;
+			const projectsMtimeSource = sourceProjectsMeta.mtime;
+			const projectsMtimeTarget = targetProjectsMeta.mtime;
+			const projectsImportable = isVersionImportable(projectsVersion, targetProjectsMeta.version);
+			let connectionsCount = 0;
+			try {
+				if (sourceConnectionsMeta.exists) {
+					const connContent = await fs$1.readFile(sourceConnectionsPath, "utf8");
+					const connJson = JSON.parse(connContent);
+					if (connJson && Array.isArray(connJson.connections)) connectionsCount = connJson.connections.length;
+				}
+			} catch (err) {
+				logger().error("[Migration] Error parsing source connections.json:", err);
+			}
+			let sourceProjectsList = [];
+			let sourcePipelinesList = [];
+			try {
+				if (sourceProjectsMeta.exists) {
+					const projContent = await fs$1.readFile(sourceProjectsPath, "utf8");
+					const projJson = JSON.parse(projContent);
+					sourceProjectsList = projJson.projects || [];
+					sourcePipelinesList = projJson.pipelines || [];
+				}
+			} catch (err) {
+				logger().error("[Migration] Error parsing source projects.json:", err);
+			}
+			let targetPipelinesList = [];
+			try {
+				if (targetProjectsMeta.exists) {
+					const targetProjContent = await fs$1.readFile(targetProjectsPath, "utf8");
+					targetPipelinesList = JSON.parse(targetProjContent).pipelines || [];
+				}
+			} catch (err) {}
+			const projectsReport = [];
+			for (const proj of sourceProjectsList) {
+				const projPipelines = sourcePipelinesList.filter((p) => p.project === proj.id);
+				const pipelinesReport = [];
+				for (const pipe of projPipelines) {
+					const targetPipe = targetPipelinesList.find((bp) => bp.id === pipe.id);
+					const existsInBeta = !!targetPipe;
+					let pipeName = pipe.id;
+					let pipeDesc = "";
+					if (pipe.type === "internal") {
+						const sourcePipeFile = sourceContext.getConfigPath(`${pipe.configName}.json`);
+						try {
+							if (existsSync(sourcePipeFile)) {
+								const pipeContent = await fs$1.readFile(sourcePipeFile, "utf8");
+								const pipeJson = JSON.parse(pipeContent);
+								pipeName = pipeJson.name || pipeName;
+								pipeDesc = pipeJson.description || pipeDesc;
+							}
+						} catch (err) {
+							logger().error(`[Migration] Error reading source pipeline file ${sourcePipeFile}:`, err);
+						}
+					} else if (pipe.type === "external") {
+						pipeName = pipe.summary?.name || pipeName;
+						pipeDesc = pipe.summary?.description || pipeDesc;
+					}
+					pipelinesReport.push({
+						id: pipe.id,
+						name: pipeName,
+						description: pipeDesc,
+						type: pipe.type,
+						lastModifiedStable: pipe.type !== "pipelab-cloud" ? pipe.lastModified : void 0,
+						lastModifiedBeta: targetPipe && targetPipe.type !== "pipelab-cloud" ? targetPipe.lastModified : void 0,
+						existsInBeta
+					});
+				}
+				projectsReport.push({
+					id: proj.id,
+					name: proj.name,
+					description: proj.description || "",
+					pipelines: pipelinesReport
+				});
+			}
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: {
+						sourceChannel: isStable ? "Beta" : "Stable",
+						targetChannel: isStable ? "Stable" : "Beta",
+						settingsExists,
+						settingsVersion,
+						settingsVersionTarget: targetSettingsMeta.version,
+						settingsMtimeSource,
+						settingsMtimeTarget,
+						settingsImportable,
+						connectionsExists,
+						connectionsCount,
+						connectionsVersion,
+						connectionsVersionTarget: targetConnectionsMeta.version,
+						connectionsMtimeSource,
+						connectionsMtimeTarget,
+						connectionsImportable,
+						projectsExists,
+						projectsVersion,
+						projectsVersionTarget: targetProjectsMeta.version,
+						projectsMtimeSource,
+						projectsMtimeTarget,
+						projectsImportable,
+						projects: projectsReport
+					}
+				}
+			});
+		} catch (e) {
+			logger().error("[Migration] Error scanning other channel folder:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Failed to scan other channel database"
+				}
+			});
+		}
+	});
+	handle("migration:perform", async (_, { send, value }) => {
+		logger().info("[Migration] Performing migration...");
+		try {
+			const { migrateSettings, migrateConnections, selectedProjects, selectedPipelines } = value;
+			const sourceEnv = context.userDataPath.endsWith("app") || !context.userDataPath.includes("app-beta") ? "beta" : "prod";
+			const sourcePath = getDefaultUserDataPath(sourceEnv);
+			const sourceContext = new PipelabContext({
+				userDataPath: sourcePath,
+				releaseTag: sourceEnv
+			});
+			sourceContext.getConfigPath();
+			const targetConfigDir = context.getConfigPath();
+			if (sourcePath === context.userDataPath) throw new Error("Cannot migrate data: Source and target directories are identical.");
+			if (existsSync(targetConfigDir)) {
+				const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+				const backupDir = context.getConfigPath("backups", `backup_${timestamp}`);
+				await fs$1.mkdir(backupDir, { recursive: true });
+				const entries = await fs$1.readdir(targetConfigDir, { withFileTypes: true });
+				for (const entry of entries) {
+					if (entry.name === "backups") continue;
+					const srcPath = join(targetConfigDir, entry.name);
+					const destPath = join(backupDir, entry.name);
+					try {
+						await fs$1.cp(srcPath, destPath, { recursive: true });
+					} catch (copyErr) {
+						logger().error(`[Migration] Failed to backup ${entry.name}:`, copyErr);
+					}
+				}
+				logger().info(`[Migration] Config backup successfully created at ${backupDir}`);
+			}
+			if (migrateSettings) {
+				const sourceSettingsFile = sourceContext.getSettingsPath();
+				const targetSettingsFile = context.getSettingsPath();
+				const sourceMeta = await getFileMetadata(sourceSettingsFile);
+				const targetMeta = await getFileMetadata(targetSettingsFile);
+				if (!isVersionImportable(sourceMeta.version, targetMeta.version)) throw new Error("Cannot migrate settings: Source version is newer than current version.");
+				if (existsSync(sourceSettingsFile)) {
+					let stableSettings = {
+						version: "7.0.0",
+						locale: "en-US",
+						theme: "light",
+						autosave: true,
+						agents: [],
+						plugins: [],
+						tours: {
+							dashboard: {
+								step: 0,
+								completed: false
+							},
+							editor: {
+								step: 0,
+								completed: false
+							}
+						}
+					};
+					try {
+						const stableContent = await fs$1.readFile(sourceSettingsFile, "utf8");
+						stableSettings = JSON.parse(stableContent);
+					} catch (e) {
+						logger().error("[Migration] Failed to read source settings.json:", e);
+					}
+					let betaSettings = {
+						version: "7.0.0",
+						locale: "en-US",
+						theme: "light",
+						autosave: true,
+						agents: [],
+						plugins: [],
+						tours: {
+							dashboard: {
+								step: 0,
+								completed: false
+							},
+							editor: {
+								step: 0,
+								completed: false
+							}
+						}
+					};
+					if (existsSync(targetSettingsFile)) try {
+						const betaContent = await fs$1.readFile(targetSettingsFile, "utf8");
+						betaSettings = JSON.parse(betaContent);
+					} catch (e) {}
+					betaSettings.theme = stableSettings.theme ?? betaSettings.theme;
+					betaSettings.locale = stableSettings.locale ?? betaSettings.locale;
+					betaSettings.autosave = stableSettings.autosave ?? betaSettings.autosave;
+					if (stableSettings.tours) {
+						betaSettings.tours = betaSettings.tours || {
+							dashboard: {
+								step: 0,
+								completed: false
+							},
+							editor: {
+								step: 0,
+								completed: false
+							}
+						};
+						if (stableSettings.tours.dashboard) betaSettings.tours.dashboard = stableSettings.tours.dashboard;
+						if (stableSettings.tours.editor) betaSettings.tours.editor = stableSettings.tours.editor;
+					}
+					const betaAgents = betaSettings.agents || [];
+					const stableAgents = stableSettings.agents || [];
+					for (const sAgent of stableAgents) {
+						const existingIdx = betaAgents.findIndex((a) => a.id === sAgent.id);
+						if (existingIdx >= 0) betaAgents[existingIdx] = { ...sAgent };
+						else betaAgents.push({ ...sAgent });
+					}
+					betaSettings.agents = betaAgents;
+					const betaPlugins = betaSettings.plugins || [];
+					const stablePlugins = stableSettings.plugins || [];
+					for (const sPlugin of stablePlugins) {
+						const existingIdx = betaPlugins.findIndex((p) => p.name === sPlugin.name);
+						if (existingIdx >= 0) betaPlugins[existingIdx] = { ...sPlugin };
+						else betaPlugins.push({ ...sPlugin });
+					}
+					betaSettings.plugins = betaPlugins;
+					await fs$1.mkdir(dirname(targetSettingsFile), { recursive: true });
+					await fs$1.writeFile(targetSettingsFile, JSON.stringify(betaSettings, null, 2));
+					logger().info("[Migration] Settings merged successfully");
+				}
+			}
+			if (migrateConnections) {
+				const sourceConnectionsFile = sourceContext.getConnectionsPath();
+				const targetConnectionsFile = context.getConnectionsPath();
+				const sourceMeta = await getFileMetadata(sourceConnectionsFile);
+				const targetMeta = await getFileMetadata(targetConnectionsFile);
+				if (!isVersionImportable(sourceMeta.version, targetMeta.version)) throw new Error("Cannot migrate connections: Source version is newer than current version.");
+				if (existsSync(sourceConnectionsFile)) {
+					let stableConnections = {
+						version: "1.0.0",
+						connections: []
+					};
+					try {
+						const stableContent = await fs$1.readFile(sourceConnectionsFile, "utf8");
+						stableConnections = JSON.parse(stableContent);
+					} catch (e) {
+						logger().error("[Migration] Failed to read source connections.json:", e);
+					}
+					let betaConnections = {
+						version: "1.0.0",
+						connections: []
+					};
+					if (existsSync(targetConnectionsFile)) try {
+						const betaContent = await fs$1.readFile(targetConnectionsFile, "utf8");
+						betaConnections = JSON.parse(betaContent);
+					} catch (e) {}
+					betaConnections.connections = betaConnections.connections || [];
+					stableConnections.connections = stableConnections.connections || [];
+					for (const sConn of stableConnections.connections) {
+						const existingIdx = betaConnections.connections.findIndex((c) => c.id === sConn.id);
+						if (existingIdx >= 0) betaConnections.connections[existingIdx] = { ...sConn };
+						else betaConnections.connections.push({ ...sConn });
+					}
+					await fs$1.mkdir(dirname(targetConnectionsFile), { recursive: true });
+					await fs$1.writeFile(targetConnectionsFile, JSON.stringify(betaConnections, null, 2));
+					logger().info("[Migration] Connections merged successfully");
+				}
+			}
+			if (selectedPipelines.length > 0 || selectedProjects.length > 0) {
+				const sourceProjectsFile = sourceContext.getProjectsPath();
+				const targetProjectsFile = context.getProjectsPath();
+				const sourceMeta = await getFileMetadata(sourceProjectsFile);
+				const targetMeta = await getFileMetadata(targetProjectsFile);
+				if (!isVersionImportable(sourceMeta.version, targetMeta.version)) throw new Error("Cannot migrate projects: Source version is newer than current version.");
+				let stableFileRepo = {
+					version: "3.0.0",
+					projects: [],
+					pipelines: []
+				};
+				if (existsSync(sourceProjectsFile)) {
+					const stableContent = await fs$1.readFile(sourceProjectsFile, "utf8");
+					stableFileRepo = JSON.parse(stableContent);
+				}
+				let betaFileRepo = {
+					version: "3.0.0",
+					projects: [],
+					pipelines: []
+				};
+				if (existsSync(targetProjectsFile)) try {
+					const betaContent = await fs$1.readFile(targetProjectsFile, "utf8");
+					betaFileRepo = JSON.parse(betaContent);
+				} catch (readErr) {
+					logger().warn("[Migration] Failed to parse existing target projects.json, starting fresh:", readErr);
+				}
+				betaFileRepo.projects = betaFileRepo.projects || [];
+				betaFileRepo.pipelines = betaFileRepo.pipelines || [];
+				for (const projId of selectedProjects) {
+					const stableProj = stableFileRepo.projects.find((p) => p.id === projId);
+					if (stableProj) {
+						const existingProjIdx = betaFileRepo.projects.findIndex((p) => p.id === projId);
+						if (existingProjIdx >= 0) betaFileRepo.projects[existingProjIdx] = { ...stableProj };
+						else betaFileRepo.projects.push({ ...stableProj });
+					}
+				}
+				for (const pipeId of selectedPipelines) {
+					const stablePipe = (stableFileRepo.pipelines || []).find((p) => p.id === pipeId);
+					if (stablePipe) {
+						const parentProjId = stablePipe.project;
+						if (!betaFileRepo.projects.some((p) => p.id === parentProjId)) {
+							const stableProj = stableFileRepo.projects.find((p) => p.id === parentProjId);
+							if (stableProj) betaFileRepo.projects.push({ ...stableProj });
+						}
+						if (stablePipe.type === "internal") {
+							const stablePipeFile = sourceContext.getConfigPath(`${stablePipe.configName}.json`);
+							const betaPipeFile = context.getConfigPath(`${stablePipe.configName}.json`);
+							if (existsSync(stablePipeFile)) {
+								await fs$1.mkdir(dirname(betaPipeFile), { recursive: true });
+								await fs$1.copyFile(stablePipeFile, betaPipeFile);
+								logger().info(`[Migration] Copied pipeline file: ${stablePipe.configName}`);
+							}
+						}
+						const updatedPipe = { ...stablePipe };
+						if (updatedPipe.type !== "pipelab-cloud") updatedPipe.lastModified = (/* @__PURE__ */ new Date()).toISOString();
+						const existingPipeIdx = betaFileRepo.pipelines.findIndex((p) => p.id === pipeId);
+						if (existingPipeIdx >= 0) betaFileRepo.pipelines[existingPipeIdx] = updatedPipe;
+						else betaFileRepo.pipelines.push(updatedPipe);
+					}
+				}
+				await fs$1.mkdir(dirname(targetProjectsFile), { recursive: true });
+				await fs$1.writeFile(targetProjectsFile, JSON.stringify(betaFileRepo, null, 2));
+				logger().info("[Migration] Merged and saved projects.json successfully");
+			}
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: { result: "ok" }
+				}
+			});
+		} catch (e) {
+			logger().error("[Migration] Error performing migration:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Failed to migrate selected data"
+				}
+			});
+		}
+	});
+};
+//#endregion
 //#region src/handlers/index.ts
 const registerAllHandlers = async (options) => {
 	const context = options.context;
@@ -10866,6 +11347,7 @@ const registerAllHandlers = async (options) => {
 	registerAuthHandlers(context);
 	registerSystemHandlers(options);
 	registerPluginsHandlers(context);
+	registerMigrationHandlers(context);
 	const { registerPlugins } = usePlugins();
 	builtInPlugins({ context });
 };
@@ -53138,7 +53620,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();
@@ -53311,6 +53792,6 @@ async function fetchLatestDesktopRelease(options = {}) {
 	return latest;
 }
 //#endregion
-export { BuildHistoryStorage, CacheFolder, PipelabContext, WebSocketServer, builtInPlugins, deleteConfigFile, downloadFile, ensure, ensureNodeJS, ensurePNPM, executeGraphWithHistory, extractTarGz, extractZip, fetchLatestDesktopRelease, fetchLatestPackageRelease, fetchPackage, fetchPackageReleases, fetchPipelabAsset, fetchPipelabCli, fetchPipelabPlugin, findInstalledPlugins, getDefaultUserDataPath, getFinalPlugins, getFolderSize, getMigrator, handleActionExecute, isDev, isOnline, loadCustomPlugin, loadPipelabPlugin, projectRoot, registerAgentsHandlers, registerAllHandlers, registerConfigHandlers, registerEngineHandlers, registerFsHandlers, registerHistoryHandlers, registerMigrationHandlers, registerShellHandlers, runPipelineCommand, runPnpm, runWithLiveLogs, sendStartupProgress, sendStartupReady, serveCommand, setupConfigFile, useAPI, usePluginAPI, webSocketServer, zipFolder };
+export { BuildHistoryStorage, CacheFolder, PipelabContext, WebSocketServer, builtInPlugins, deletePipelineConfigFileByName, deletePipelineConfigFileByPath, downloadFile, ensure, ensureNodeJS, ensurePNPM, executeGraphWithHistory, extractTarGz, extractZip, fetchLatestDesktopRelease, fetchLatestPackageRelease, fetchPackage, fetchPackageReleases, fetchPipelabAsset, fetchPipelabCli, fetchPipelabPlugin, findInstalledPlugins, getDefaultUserDataPath, getFinalPlugins, getFolderSize, handleActionExecute, isDev, isOnline, loadCustomPlugin, loadPipelabPlugin, projectRoot, registerAgentsHandlers, registerAllHandlers, registerConfigHandlers, registerEngineHandlers, registerFsHandlers, registerHistoryHandlers, registerShellHandlers, runPipelineCommand, runPnpm, runWithLiveLogs, sendStartupProgress, sendStartupReady, serveCommand, setupConnectionsConfigFile, setupPipelineConfigFileByName, setupPipelineConfigFileByPath, setupProjectsConfigFile, setupSettingsConfigFile, useAPI, usePluginAPI, webSocketServer, zipFolder };
 
 //# sourceMappingURL=index.mjs.map