@pipelab/core-node 1.0.0-beta.2 → 1.0.0-beta.21

package/dist/index.mjs

@@ -1,20 +1,18 @@
+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, tmpdir } from "node:os";
+import { homedir, platform } from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import fs, { createWriteStream, existsSync } 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, appSettingsMigrator, configRegistry, fileRepoMigrations, isRequired, isSupabaseAvailable, isWebSocketRequestMessage, processGraph, savedFileMigrator, supabase, useLogger, usePlugins } from "@pipelab/shared";
-import { getUiDevServerMissingWarning, uiDevPort, websocketPort } from "@pipelab/constants";
-import fs$1, { access, chmod, cp, mkdir, mkdtemp, readFile, readdir, realpath, rm, stat, unlink, writeFile } from "node:fs/promises";
+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";
 import semver from "semver";
 import http$1 from "http";
@@ -53,16 +51,19 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 //#endregion
 //#region src/context.ts
-const _dirname = typeof __dirname !== "undefined" ? __dirname : typeof import.meta !== "undefined" && import.meta.url ? dirname(fileURLToPath(import.meta.url)) : process.cwd();
+const metaUrl = typeof import.meta !== "undefined" ? import.meta.url : void 0;
+const _dirname = typeof __dirname !== "undefined" ? __dirname : metaUrl ? dirname(fileURLToPath(metaUrl)) : process.cwd();
 const isDev = process.env.NODE_ENV === "development";
-const getDefaultUserDataPath = () => {
-	return join((() => {
+const getDefaultUserDataPath = (env) => {
+	const base = (() => {
 		switch (platform()) {
 			case "win32": return process.env.APPDATA || join(homedir(), "AppData", "Roaming");
 			case "darwin": return join(homedir(), "Library", "Application Support");
 			default: return process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
 		}
-	})(), "@pipelab", isDev ? "app-dev" : "app");
+	})();
+	const mode = env ?? (isDev ? "dev" : "prod");
+	return join(base, "@pipelab", mode === "dev" ? "app-dev" : mode === "beta" ? "app-beta" : "app");
 };
 /**
 * Finds the monorepo root by looking for pnpm-workspace.yaml.
@@ -76,10 +77,17 @@ function findProjectRoot(startDir) {
 	return null;
 }
 const projectRoot = findProjectRoot(_dirname);
+const CacheFolder = {
+	Actions: "actions",
+	Pipelines: "pipelines",
+	Pacote: "pacote"
+};
 var PipelabContext = class {
 	userDataPath;
+	releaseTag;
 	constructor(options) {
 		this.userDataPath = options.userDataPath;
+		this.releaseTag = options.releaseTag || "latest";
 	}
 	getPackagesPath(...subpaths) {
 		return join(this.userDataPath, "packages", ...subpaths);
@@ -90,6 +98,89 @@ 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.getSettings()?.tempFolder || join(this.userDataPath, "temp"), ...subpaths);
+	}
+	async createTempFolder(prefix = "pipelab-") {
+		const baseDir = this.getTempPath();
+		await mkdir(baseDir, { recursive: true });
+		return await mkdtemp(join(await realpath(baseDir), prefix));
+	}
+	getCachePath(folder, ...subpaths) {
+		const base = this.getSettings()?.cacheFolder || join(this.userDataPath, "cache");
+		if (!folder) return base;
+		return join(base, folder, ...subpaths);
+	}
+	getPnpmPath(...subpaths) {
+		return join(this.userDataPath, "pnpm", ...subpaths);
+	}
+	getBuildHistoryPath(...subpaths) {
+		return join(this.userDataPath, "build-history", ...subpaths);
+	}
+	getNodePath(version = DEFAULT_NODE_VERSION) {
+		const isWindows = process.platform === "win32";
+		return this.getThirdPartyPath("node", version, isWindows ? "node.exe" : "bin/node");
+	}
+	getPnpmBinPath(version = DEFAULT_PNPM_VERSION) {
+		return this.getPackagesPath("pnpm", version, "bin", "pnpm.cjs");
+	}
+	getSandboxFolders() {
+		const foldersRecord = {
+			[SandboxFolder.Packages]: {
+				label: "Packages",
+				path: this.getPackagesPath()
+			},
+			[SandboxFolder.ThirdParty]: {
+				label: "Third-Party Tools",
+				path: this.getThirdPartyPath()
+			},
+			[SandboxFolder.Config]: {
+				label: "Configuration",
+				path: this.getConfigPath()
+			},
+			[SandboxFolder.Temp]: {
+				label: "Temporary Files",
+				path: this.getTempPath()
+			},
+			[SandboxFolder.Cache]: {
+				label: "Cache",
+				path: this.getCachePath()
+			},
+			[SandboxFolder.Pnpm]: {
+				label: "PNPM Home",
+				path: this.getPnpmPath()
+			}
+		};
+		return Object.keys(foldersRecord).map((key) => ({
+			name: key,
+			...foldersRecord[key]
+		}));
+	}
 };
 //#endregion
 //#region src/ipc-core.ts
@@ -443,296 +534,363 @@ 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 {
-		await access(filesPath);
-	} catch {
-		await writeFile(filesPath, defaultContent);
-	}
-};
-/**
-* Generates a unique temporary folder.
-*/
-const generateTempFolder = async (base) => {
-	const targetBase = base || tmpdir();
-	await mkdir(targetBase, { recursive: true });
-	return await mkdtemp(join(await realpath(targetBase), "pipelab-"));
-};
-/**
-* Extracts a .tar.gz archive.
-*/
-async function extractTarGz(archivePath, destinationDir) {
-	await mkdir(destinationDir, { recursive: true });
-	await tar.x({
-		file: archivePath,
-		cwd: destinationDir
+//#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()
+				}
+			});
+		} catch (e) {
+			logger().error("settings:load error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to load settings"
+				}
+			});
+		}
 	});
-}
-/**
-* 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);
+	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"
+				}
 			});
-			zipfile.on("end", () => resolve());
-		});
+		} catch (e) {
+			logger().error("settings:save error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to save 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: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"
+				}
+			});
+		}
 	});
-};
-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("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"
+				}
+			});
+		}
 	});
-	hooks?.onCreated?.(subprocess);
-	subprocess.stdout?.on("data", (data) => {
-		hooks?.onStdout?.(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"
+				}
+			});
+		}
 	});
-	subprocess.stderr?.on("data", (data) => {
-		hooks?.onStderr?.(data.toString(), subprocess);
+	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"
+				}
+			});
+		}
 	});
-	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) => {
-	if (configRegistry[name]) return configRegistry[name];
-	if (name.startsWith("pipeline-")) return 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;
-			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);
-			}
-			let json = void 0;
-			try {
-				json = await migrator.migrate(originalJson, { debug: false });
-			} catch (e) {
-				logger().error(`Error migrating config ${name}:`, e);
-				json = migrator.defaultValue;
-			}
-			const originalVersion = originalJson?.version;
-			const newVersion = json?.version;
-			if (originalVersion !== newVersion && content !== void 0) {
-				const parsedPath = path.parse(filesPath);
-				const versionSuffix = originalVersion || "unknown";
-				const backupPath = path.join(parsedPath.dir, `${parsedPath.name}.${versionSuffix}.bak`);
-				try {
-					await fs$1.copyFile(filesPath, backupPath);
-					logger().info(`Backup created for ${name} at ${backupPath} (version ${versionSuffix})`);
-				} catch (e) {
-					logger().error(`Failed to create backup for ${name}:`, e);
+	handle("projects:load", async (_, { send }) => {
+		logger().info("projects:load");
+		try {
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: await (await setupProjectsConfigFile(context)).getConfig()
 				}
-			}
-			if (originalVersion !== newVersion || content === void 0) try {
-				await fs$1.writeFile(filesPath, JSON.stringify(json));
-			} catch (e) {
-				logger().error(`Error saving migrated config ${name}:`, e);
-			}
-			return json;
+			});
+		} catch (e) {
+			logger().error("projects:load error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to load projects"
+				}
+			});
 		}
-	};
-};
-//#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:save", async (_, { send, value }) => {
+		const { data } = value;
+		try {
+			const manager = await setupProjectsConfigFile(context);
+			const json = typeof data === "string" ? JSON.parse(data) : data;
+			await manager.setConfig(json);
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: "ok"
+				}
+			});
+		} catch (e) {
+			logger().error("projects:save error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to save projects"
+				}
+			});
+		}
+	});
+	handle("projects:reset", async (_, { send, value }) => {
+		const { key } = value;
+		try {
+			const manager = await setupProjectsConfigFile(context);
+			const currentConfig = await manager.getConfig();
+			const defaultValue = fileRepoMigrations.defaultValue[key];
+			await manager.setConfig({
+				...currentConfig ? currentConfig : {},
+				[key]: defaultValue
+			});
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: "ok"
+				}
+			});
+		} catch (e) {
+			logger().error("projects:reset error:", e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : "Unable to reset projects"
+				}
+			});
+		}
+	});
+	handle("pipeline:load-by-name", async (_, { send, value }) => {
+		const { name } = value;
+		logger().info("pipeline:load-by-name", name);
+		try {
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: await (await setupPipelineConfigFileByName(name, context)).getConfig()
+				}
+			});
+		} catch (e) {
+			logger().error(`pipeline:load-by-name error for ${name}:`, e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : `Unable to load pipeline ${name}`
+				}
+			});
+		}
+	});
+	handle("pipeline:load-by-path", async (_, { send, value }) => {
+		const { path: absolutePath } = value;
+		logger().info("pipeline:load-by-path", absolutePath);
 		try {
 			send({
 				type: "end",
 				data: {
 					type: "success",
-					result: { result: await (await setupConfigFile(name, { context })).getConfig() }
+					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(`config:load error for ${name}:`, 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 load config ${name}`
+					ipcError: e instanceof Error ? e.message : `Unable to save pipeline ${name}`
 				}
 			});
 		}
 	});
-	handle("config:save", async (_, { send, value }) => {
-		const { data, config: name } = value;
+	handle("pipeline:save-by-path", async (_, { send, value }) => {
+		const { data, path: absolutePath } = value;
 		try {
-			const manager = await setupConfigFile(name, { context });
+			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: { result: "ok" }
+					result: "ok"
 				}
 			});
 		} catch (e) {
-			logger().error(`config:save error for ${name}:`, 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 config ${name}`
+					ipcError: e instanceof Error ? e.message : `Unable to save pipeline ${absolutePath}`
 				}
 			});
 		}
 	});
-	handle("config:reset", async (event, { value, send }) => {
-		const { config: name, key } = value;
-		logger().info("config:reset", name, key);
+	handle("pipeline:delete-by-name", async (_, { send, value }) => {
+		const { name } = value;
+		logger().info("pipeline:delete-by-name", name);
 		try {
-			const manager = await setupConfigFile(name, { 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];
-			await manager.setConfig({
-				...currentConfig ? currentConfig : {},
-				[key]: defaultValue
+			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: { result: "ok" }
+					result: "ok"
 				}
 			});
 		} catch (e) {
-			logger().error(`config:reset 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 reset config ${name}`
+					ipcError: e instanceof Error ? e.message : `Unable to delete pipeline ${absolutePath}`
 				}
 			});
 		}
@@ -746,11 +904,10 @@ var BuildHistoryStorage = class {
 		this.context = context;
 	}
 	getStoragePath() {
-		return join(this.context.userDataPath, "build-history");
+		return this.context.getConfigPath("pipelines");
 	}
 	getPipelinePath(pipelineId) {
-		const sanitizedId = pipelineId.replace(/[/\:*?"<>|]/g, "_").replace(/__/g, "_").replace(/^_+|_+$/g, "");
-		return join(this.getStoragePath(), `pipeline-${sanitizedId}.json`);
+		return join(this.getStoragePath(), `${pipelineId}.history.json`);
 	}
 	async ensureStoragePath() {
 		try {
@@ -777,35 +934,6 @@ var BuildHistoryStorage = class {
 			throw new Error(`Failed to save pipeline history: ${error}`);
 		}
 	}
-	async applyRetentionPolicy() {
-		try {
-			this.logger.logger().info("Applying build history retention policy...");
-			const policy = (await (await setupConfigFile("settings", { context: this.context })).getConfig())?.buildHistory?.retentionPolicy;
-			if (!policy || !policy.enabled) {
-				this.logger.logger().info("Retention policy is disabled. Skipping.");
-				return;
-			}
-			const { maxAge, maxEntries } = policy;
-			const pipelineFiles = await this.getAllPipelineFiles();
-			for (const file of pipelineFiles) {
-				const pipelineId = file.replace("pipeline-", "").replace(".json", "");
-				let entries = await this.loadPipelineHistory(pipelineId);
-				const originalCount = entries.length;
-				if (maxAge > 0) {
-					const minDate = Date.now() - maxAge * 24 * 60 * 60 * 1e3;
-					entries = entries.filter((entry) => entry.createdAt >= minDate);
-				}
-				if (maxEntries > 0 && entries.length > maxEntries) entries = entries.sort((a, b) => b.createdAt - a.createdAt).slice(0, maxEntries);
-				if (entries.length < originalCount) {
-					this.logger.logger().info(`[${pipelineId}] Pruned ${originalCount - entries.length} history entries.`);
-					await this.savePipelineHistory(pipelineId, entries);
-				}
-			}
-			this.logger.logger().info("Retention policy applied successfully.");
-		} catch (error) {
-			this.logger.logger().error("Failed to apply retention policy:", error);
-		}
-	}
 	async save(entry) {
 		try {
 			const entries = await this.loadPipelineHistory(entry.pipelineId);
@@ -814,9 +942,6 @@ var BuildHistoryStorage = class {
 			else entries.push(entry);
 			await this.savePipelineHistory(entry.pipelineId, entries);
 			this.logger.logger().info(`Saved build history entry: ${entry.id} for pipeline: ${entry.pipelineId}`);
-			this.applyRetentionPolicy().catch((err) => {
-				this.logger.logger().error("Failed to apply retention policy after save:", err);
-			});
 		} catch (error) {
 			this.logger.logger().error("Failed to save build history entry:", error);
 			throw new Error(`Failed to save build history entry: ${error}`);
@@ -827,7 +952,8 @@ var BuildHistoryStorage = class {
 			if (pipelineId) return (await this.loadPipelineHistory(pipelineId)).find((e) => e.id === id);
 			const files = await this.getAllPipelineFiles();
 			for (const file of files) {
-				const pId = file.replace("pipeline-", "").replace(".json", "");
+				const pId = this.parsePipelineIdFromFilename(file);
+				if (!pId) continue;
 				const entry = (await this.loadPipelineHistory(pId)).find((e) => e.id === id);
 				if (entry) return entry;
 			}
@@ -842,7 +968,8 @@ var BuildHistoryStorage = class {
 			const files = await this.getAllPipelineFiles();
 			const allEntries = [];
 			for (const file of files) {
-				const pipelineId = file.replace("pipeline-", "").replace(".json", "");
+				const pipelineId = this.parsePipelineIdFromFilename(file);
+				if (!pipelineId) continue;
 				const entries = await this.loadPipelineHistory(pipelineId);
 				allEntries.push(...entries);
 			}
@@ -877,7 +1004,8 @@ var BuildHistoryStorage = class {
 			} else {
 				const files = await this.getAllPipelineFiles();
 				for (const file of files) {
-					const pId = file.replace("pipeline-", "").replace(".json", "");
+					const pId = this.parsePipelineIdFromFilename(file);
+					if (!pId) continue;
 					const entries = await this.loadPipelineHistory(pId);
 					const entryIndex = entries.findIndex((e) => e.id === id);
 					if (entryIndex >= 0) {
@@ -911,7 +1039,8 @@ var BuildHistoryStorage = class {
 			} else {
 				const files = await this.getAllPipelineFiles();
 				for (const file of files) {
-					const pId = file.replace("pipeline-", "").replace(".json", "");
+					const pId = this.parsePipelineIdFromFilename(file);
+					if (!pId) continue;
 					const entries = await this.loadPipelineHistory(pId);
 					const entryIndex = entries.findIndex((e) => e.id === id);
 					if (entryIndex >= 0) {
@@ -932,8 +1061,20 @@ var BuildHistoryStorage = class {
 		try {
 			await this.ensureStoragePath();
 			const files = await this.getAllPipelineFiles();
-			await Promise.all(files.map((file) => unlink(join(this.getStoragePath(), file))));
+			const cachePathsToDelete = /* @__PURE__ */ new Set();
+			for (const file of files) {
+				const pipelineId = this.parsePipelineIdFromFilename(file);
+				if (pipelineId) {
+					const entries = await this.loadPipelineHistory(pipelineId);
+					for (const entry of entries) if (entry.cachePath) cachePathsToDelete.add(entry.cachePath);
+				}
+				await unlink(join(this.getStoragePath(), file));
+			}
 			this.logger.logger().info("Cleared all build history");
+			for (const cachePath of cachePathsToDelete) await rm(cachePath, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
 		} catch (error) {
 			this.logger.logger().error("Failed to clear build history:", error);
 			throw new Error(`Failed to clear build history: ${error}`);
@@ -941,8 +1082,16 @@ var BuildHistoryStorage = class {
 	}
 	async clearByPipeline(pipelineId) {
 		try {
-			await unlink(this.getPipelinePath(pipelineId));
+			const pipelinePath = this.getPipelinePath(pipelineId);
+			const entries = await this.loadPipelineHistory(pipelineId);
+			await unlink(pipelinePath);
 			this.logger.logger().info(`Cleared history for pipeline "${pipelineId}"`);
+			const cachePathsToDelete = /* @__PURE__ */ new Set();
+			for (const entry of entries) if (entry.cachePath) cachePathsToDelete.add(entry.cachePath);
+			for (const cachePath of cachePathsToDelete) await rm(cachePath, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
 		} catch (error) {
 			if (error.code === "ENOENT") {
 				this.logger.logger().warn(`No history file found for pipeline "${pipelineId}". Nothing to clear.`);
@@ -958,25 +1107,25 @@ var BuildHistoryStorage = class {
 			const files = await this.getAllPipelineFiles();
 			const diskSpace = await checkDiskSpace(this.context.userDataPath);
 			const pipelabSize = await getFolderSize(this.context.userDataPath);
-			const policy = (await (await setupConfigFile("settings", { context: this.context })).getConfig())?.buildHistory?.retentionPolicy || {
-				enabled: false,
-				maxEntries: 50,
-				maxAge: 30
-			};
+			const folders = [];
+			for (const folder of this.context.getSandboxFolders()) {
+				const size = await getFolderSize(folder.path);
+				folders.push({
+					name: folder.name,
+					label: folder.label,
+					size
+				});
+			}
 			if (allEntries.length === 0) return {
 				totalEntries: 0,
 				totalSize: 0,
 				numberOfPipelines: files.length,
 				userDataPath: this.context.userDataPath,
-				retentionPolicy: {
-					enabled: policy.enabled,
-					maxEntries: policy.maxEntries,
-					maxAge: policy.maxAge
-				},
 				disk: {
 					total: diskSpace.size,
 					free: diskSpace.free,
-					pipelab: pipelabSize
+					pipelab: pipelabSize,
+					folders
 				}
 			};
 			let totalSize = 0;
@@ -996,15 +1145,11 @@ var BuildHistoryStorage = class {
 				newestEntry: sortedEntries[sortedEntries.length - 1]?.createdAt,
 				numberOfPipelines: files.length,
 				userDataPath: this.context.userDataPath,
-				retentionPolicy: {
-					enabled: policy.enabled,
-					maxEntries: policy.maxEntries,
-					maxAge: policy.maxAge
-				},
 				disk: {
 					total: diskSpace.size,
 					free: diskSpace.free,
-					pipelab: pipelabSize
+					pipelab: pipelabSize,
+					folders
 				}
 			};
 		} catch (error) {
@@ -1015,11 +1160,15 @@ var BuildHistoryStorage = class {
 	async getAllPipelineFiles() {
 		try {
 			await this.ensureStoragePath();
-			return (await readdir(this.getStoragePath())).filter((file) => file.startsWith("pipeline-") && file.endsWith(".json"));
+			return (await readdir(this.getStoragePath())).filter((file) => file.endsWith(".history.json"));
 		} catch (error) {
 			return [];
 		}
 	}
+	parsePipelineIdFromFilename(filename) {
+		const match = filename.match(/^(.+)\.history\.json$/);
+		return match ? match[1] : null;
+	}
 };
 //#endregion
 //#region src/handlers/history.ts
@@ -1301,40 +1450,6 @@ const registerHistoryHandlers = (context) => {
 			});
 		}
 	});
-	handle("build-history:configure", async (_, { send, value }) => {
-		try {
-			logger().info("Updating build history configuration:", value.config);
-			const settings = await setupConfigFile("settings", { context });
-			const currentConfig = await settings.getConfig();
-			const newConfig = {
-				...currentConfig,
-				buildHistory: {
-					...currentConfig?.buildHistory,
-					retentionPolicy: {
-						...currentConfig?.buildHistory?.retentionPolicy,
-						...value.config.retentionPolicy
-					}
-				}
-			};
-			await settings.saveConfig(newConfig);
-			send({
-				type: "end",
-				data: {
-					type: "success",
-					result: { result: "ok" }
-				}
-			});
-		} catch (error) {
-			logger().error("Failed to configure build history:", error);
-			send({
-				type: "end",
-				data: {
-					type: "error",
-					ipcError: error instanceof Error ? error.message : "Failed to configure build history"
-				}
-			});
-		}
-	});
 };
 //#endregion
 //#region ../../node_modules/serve-handler/src/glob-slash.js
@@ -8324,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");
@@ -8778,47 +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 {
-			let migrator = null;
-			if (name === "projects") migrator = fileRepoMigrations;
-			else if (name === "settings") migrator = appSettingsMigrator;
-			else if (name.startsWith("pipeline-") || name.endsWith(".plb")) migrator = savedFileMigrator;
-			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", {
@@ -8832,10 +8906,43 @@ const sendStartupReady = () => {
 };
 async function serveCommand(options, version, _dirname) {
 	if (!options.userData) throw new Error("userDataPath is required for serveCommand");
-	const context = new PipelabContext({ userDataPath: options.userData });
+	const releaseTag = version.includes("beta") ? "beta" : "latest";
+	const context = new PipelabContext({
+		userDataPath: options.userData,
+		releaseTag
+	});
 	let rawAssetFolder;
-	if (!isDev) rawAssetFolder = await fetchPipelabAsset("@pipelab/ui", "latest", { context });
+	if (!isDev) rawAssetFolder = await fetchPipelabAsset("@pipelab/ui", releaseTag, { context });
 	const server = http$1.createServer(async (request, response) => {
+		if (request.url?.startsWith("/media-file/")) {
+			const encodedPath = request.url.substring(12);
+			const filePath = decodeURIComponent(encodedPath);
+			const normalizedPath = filePath.startsWith("/") && filePath.match(/^\/[a-zA-Z]:/) ? filePath.substring(1) : filePath;
+			if (existsSync(normalizedPath)) try {
+				const content = await readFile(normalizedPath);
+				let contentType = "application/octet-stream";
+				if (normalizedPath.endsWith(".png")) contentType = "image/png";
+				else if (normalizedPath.endsWith(".jpg") || normalizedPath.endsWith(".jpeg")) contentType = "image/jpeg";
+				else if (normalizedPath.endsWith(".svg")) contentType = "image/svg+xml";
+				else if (normalizedPath.endsWith(".gif")) contentType = "image/gif";
+				else if (normalizedPath.endsWith(".webp")) contentType = "image/webp";
+				response.writeHead(200, {
+					"Content-Type": contentType,
+					"Access-Control-Allow-Origin": "*"
+				});
+				response.end(content);
+				return;
+			} catch (e) {
+				response.writeHead(500, { "Content-Type": "text/plain" });
+				response.end(`Error reading file: ${e}`);
+				return;
+			}
+			else {
+				response.writeHead(404, { "Content-Type": "text/plain" });
+				response.end(`File not found: ${normalizedPath}`);
+				return;
+			}
+		}
 		if (isDev) {
 			response.writeHead(200, { "Content-Type": "text/html" });
 			response.end(`
@@ -8854,7 +8961,13 @@ async function serveCommand(options, version, _dirname) {
 			response.end(`Error: UI directory not found at ${rawAssetFolder}.\nPlease run 'pnpm build' in apps/ui to generate the distribution.`);
 			return;
 		}
-		return (0, import_src.default)(request, response, { public: rawAssetFolder });
+		return (0, import_src.default)(request, response, {
+			public: rawAssetFolder,
+			rewrites: [{
+				source: "/**",
+				destination: "/index.html"
+			}]
+		});
 	});
 	console.log(`Starting Pipelab server on port ${options.port}...`);
 	if (isDev) {
@@ -8866,14 +8979,30 @@ async function serveCommand(options, version, _dirname) {
 		version,
 		context
 	});
-	registerMigrationHandlers(context);
 	sendStartupReady();
 	return server;
 }
 //#endregion
 //#region src/utils/remote.ts
-const DEFAULT_NODE_VERSION = "24.14.1";
-const DEFAULT_PNPM_VERSION = "10.12.0";
+function isPackageComplete(packageDir) {
+	return existsSync(join(packageDir, "package.json"));
+}
+function isNodeJSComplete(nodePath) {
+	try {
+		return existsSync(nodePath) && statSync(nodePath).size > 0;
+	} catch {
+		return false;
+	}
+}
+function isDependenciesInstalledSync(packageDir) {
+	const nodeModulesPath = join(packageDir, "node_modules");
+	if (!existsSync(nodeModulesPath)) return false;
+	try {
+		return readdirSync(nodeModulesPath).length > 0;
+	} catch {
+		return false;
+	}
+}
 /**
 * In-memory lock to prevent concurrent operations on the same resource (e.g., downloading Node.js).
 */
@@ -8895,16 +9024,32 @@ async function withLock(key, fn) {
 	activeOperations.set(key, promise);
 	return promise;
 }
+let isOnlineCached = null;
+let lastCheckTime = 0;
+async function isOnline() {
+	const now = Date.now();
+	if (isOnlineCached !== null && now - lastCheckTime < 1e4) return isOnlineCached;
+	try {
+		await Promise.race([dns.lookup("registry.npmjs.org"), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("timeout")), 1500))]);
+		isOnlineCached = true;
+	} catch {
+		isOnlineCached = false;
+	}
+	lastCheckTime = now;
+	return isOnlineCached;
+}
 /**
 * Robust utility to fetch, cache, and resolve an NPM package.
 * Centralized in core-node to avoid circular dependencies.
 */
 async function fetchPackage(packageName, versionOrRange, options) {
+	const start = Date.now();
 	if (isDev && projectRoot && process.env.PIPELAB_FORCE_NPM !== "true") {
 		if (packageName.startsWith("@pipelab/")) {
+			const localStart = Date.now();
 			const local = await tryResolveMonorepoPackage(packageName);
 			if (local) {
-				console.log(`[Fetcher] ${packageName}: Resolved to local source at ${local.packageDir}`);
+				console.log(`[Fetcher] ${packageName}: Resolved to local source at ${local.packageDir} (${Date.now() - localStart}ms)`);
 				return {
 					...local,
 					resolvedVersion: "workspace"
@@ -8915,9 +9060,20 @@ async function fetchPackage(packageName, versionOrRange, options) {
 	const ctx = options.context;
 	const baseDir = ctx.getPackagesPath(packageName);
 	let resolvedVersion;
-	console.log(`[Fetcher] Resolving ${packageName}@${versionOrRange || "latest"}...`);
-	try {
-		const cachePath = join(ctx.userDataPath, "cache", "pacote");
+	let resolvedVersionOrRange = versionOrRange;
+	if (resolvedVersionOrRange === "local") resolvedVersionOrRange = "latest";
+	console.log(`[Fetcher] Resolving ${packageName}@${resolvedVersionOrRange || "latest"}...`);
+	const resolveStart = Date.now();
+	if (!await isOnline()) {
+		console.warn(`[Fetcher] ${packageName}: offline mode detected (${Date.now() - resolveStart}ms), trying local fallback...`);
+		const fallbackStart = Date.now();
+		const fallbackVersion = await tryLocalFallback(resolvedVersionOrRange, /* @__PURE__ */ new Error("Offline"), baseDir, packageName);
+		if (fallbackVersion) {
+			resolvedVersion = fallbackVersion;
+			console.log(`[Fetcher] ${packageName}: Resolved to local fallback ${resolvedVersion} (${Date.now() - fallbackStart}ms)`);
+		} else throw new Error(`Offline and no local fallback version available for ${packageName}`);
+	} else try {
+		const cachePath = ctx.getCachePath(CacheFolder.Pacote);
 		let packumentPromise = packumentRequests.get(packageName);
 		if (!packumentPromise) {
 			packumentPromise = pacote.packument(packageName, { cache: cachePath });
@@ -8925,31 +9081,78 @@ async function fetchPackage(packageName, versionOrRange, options) {
 		}
 		const packument = await packumentPromise;
 		const versions = Object.keys(packument.versions);
-		const range = versionOrRange || "latest";
-		const foundVersion = packument["dist-tags"]?.[range] || semver.maxSatisfying(versions, range);
+		const range = resolvedVersionOrRange || "latest";
+		let foundVersion = packument["dist-tags"]?.[range] || semver.maxSatisfying(versions, range);
+		if (range === "latest" && ctx.releaseTag && ctx.releaseTag !== "latest") {
+			const releaseTagVersion = packument["dist-tags"]?.[ctx.releaseTag];
+			if (releaseTagVersion && semver.valid(releaseTagVersion)) {
+				if (!foundVersion || semver.valid(foundVersion) && semver.gte(releaseTagVersion, foundVersion)) {
+					console.log(`[Fetcher] Using release tag "${ctx.releaseTag}" (${releaseTagVersion}) instead of "latest" (${foundVersion || "none"}) for ${packageName}`);
+					foundVersion = releaseTagVersion;
+				} else if (foundVersion) console.warn(`[Fetcher] Tag "${ctx.releaseTag}" (${releaseTagVersion}) is older than "latest" (${foundVersion}) for ${packageName}, keeping "latest"`);
+			}
+		}
 		if (!foundVersion) throw new Error(`Package ${packageName}@${range} not found on npm (available tags: ${Object.keys(packument["dist-tags"] || {}).join(", ")})`);
 		resolvedVersion = foundVersion;
-		console.log(`[Fetcher] ${packageName}: Resolved to v${resolvedVersion} via npm`);
+		console.log(`[Fetcher] ${packageName}: Resolved to v${resolvedVersion} via npm (${Date.now() - resolveStart}ms)`);
 	} catch (error) {
-		console.warn(`[Fetcher] ${packageName}: remote resolution failed, trying local fallback...`);
-		const fallbackVersion = await tryLocalFallback(versionOrRange, error, baseDir, packageName);
-		if (fallbackVersion) resolvedVersion = fallbackVersion;
-		else throw error;
-	}
-	const cachePath = join(ctx.userDataPath, "cache", "pacote");
+		console.warn(`[Fetcher] ${packageName}: remote resolution failed (${Date.now() - resolveStart}ms), trying local fallback...`);
+		const fallbackStart = Date.now();
+		const fallbackVersion = await tryLocalFallback(resolvedVersionOrRange, error, baseDir, packageName);
+		if (fallbackVersion) {
+			resolvedVersion = fallbackVersion;
+			console.log(`[Fetcher] ${packageName}: Resolved to local fallback ${resolvedVersion} (${Date.now() - fallbackStart}ms)`);
+		} else throw error;
+	}
+	const cachePath = ctx.getCachePath(CacheFolder.Pacote);
 	const packageDir = join(baseDir, resolvedVersion);
-	if (existsSync(packageDir) && !options?.installDeps) return {
-		packageDir,
-		resolvedVersion
-	};
+	const checkStart = Date.now();
+	const isInstalled = options?.installDeps ? isPackageComplete(packageDir) && isDependenciesInstalledSync(packageDir) : isPackageComplete(packageDir);
+	const checkDuration = Date.now() - checkStart;
+	if (isInstalled) {
+		console.log(`[Fetcher] ${packageName}@${resolvedVersion}: Already installed (check took ${checkDuration}ms, fetchPackage took ${Date.now() - start}ms)`);
+		return {
+			packageDir,
+			resolvedVersion
+		};
+	}
 	return withLock(`package:${packageName}:${resolvedVersion}`, async () => {
-		if (!existsSync(packageDir)) {
+		if (!isPackageComplete(packageDir)) {
 			console.log(`[Fetcher] ${packageName}@${resolvedVersion}: Downloading to ${packageDir}...`);
-			await mkdir(packageDir, { recursive: true });
-			await pacote.extract(`${packageName}@${resolvedVersion}`, packageDir, { cache: cachePath });
+			const downloadStart = Date.now();
+			const tempDir = join(baseDir, `.tmp-${resolvedVersion}-${Math.random().toString(36).slice(2)}`);
+			await mkdir(tempDir, { recursive: true });
+			try {
+				await pacote.extract(`${packageName}@${resolvedVersion}`, tempDir, { cache: cachePath });
+				await resolveEntryPoint(tempDir, packageName);
+				if (existsSync(packageDir)) await rm(packageDir, {
+					recursive: true,
+					force: true
+				}).catch(() => {});
+				try {
+					await rename(tempDir, packageDir);
+				} catch (err) {
+					if (isPackageComplete(packageDir)) console.log(`[Fetcher] Destination ${packageDir} already exists and is valid.`);
+					else throw err;
+				}
+				console.log(`[Fetcher] ${packageName}@${resolvedVersion}: Downloaded and extracted in ${Date.now() - downloadStart}ms`);
+			} catch (err) {
+				await rm(tempDir, {
+					recursive: true,
+					force: true
+				}).catch(() => {});
+				throw err;
+			}
 		}
+		const entryStart = Date.now();
 		const entryPoint = await resolveEntryPoint(packageDir, packageName);
-		if (options?.installDeps) await installDependencies(packageDir, packageName, options);
+		console.log(`[Fetcher] ${packageName}@${resolvedVersion}: Resolved entry point in ${Date.now() - entryStart}ms`);
+		if (options?.installDeps) {
+			const depsStart = Date.now();
+			await installDependencies(packageDir, packageName, options);
+			console.log(`[Fetcher] ${packageName}@${resolvedVersion}: Installed dependencies in ${Date.now() - depsStart}ms`);
+		}
+		console.log(`[Fetcher] ${packageName}@${resolvedVersion}: FetchPackage complete in ${Date.now() - start}ms`);
 		return {
 			packageDir,
 			resolvedVersion,
@@ -8978,7 +9181,7 @@ async function runPnpm(cwd, options) {
 			...process.env,
 			NODE_ENV: "production",
 			PATH: nodePath ? `${dirname(nodePath)}${delimiter}${process.env.PATH}` : process.env.PATH,
-			PNPM_HOME: join(ctx.userDataPath, "pnpm"),
+			PNPM_HOME: ctx.getPnpmPath(),
 			PNPM_ONLY_ALLOW_TRUSTED_DEPENDENCIES: "false",
 			...extraEnv
 		}
@@ -8988,24 +9191,31 @@ async function runPnpm(cwd, options) {
 * Installs a specific version of Node.js if not already present.
 */
 async function ensureNodeJS(context, version = DEFAULT_NODE_VERSION) {
+	const checkStart = Date.now();
 	const isWindows = process.platform === "win32";
 	const nodeDir = context.getThirdPartyPath("node", version);
 	const finalNodePath = join(nodeDir, isWindows ? "node.exe" : "bin/node");
-	if (existsSync(finalNodePath)) return finalNodePath;
+	if (isNodeJSComplete(finalNodePath)) {
+		console.log(`[Environment] Node.js check took ${Date.now() - checkStart}ms (found at ${finalNodePath})`);
+		return finalNodePath;
+	}
 	return withLock(`node:${version}`, async () => {
-		if (existsSync(finalNodePath)) return finalNodePath;
+		if (isNodeJSComplete(finalNodePath)) return finalNodePath;
 		const arch = process.arch === "x64" ? "x64" : process.arch === "arm64" ? "arm64" : "x86";
 		const platform = isWindows ? "win" : process.platform === "darwin" ? "osx" : "linux";
 		const extension = isWindows ? "zip" : "tar.gz";
 		const fileName = `node-v${version}-${platform === "osx" ? "darwin" : platform}-${arch}.${extension}`;
 		const downloadUrl = `https://nodejs.org/dist/v${version}/${fileName}`;
-		const tempDir = await generateTempFolder(tmpdir());
+		const tempDir = await context.createTempFolder("node-download-");
 		const archivePath = join(tempDir, fileName);
 		sendStartupProgress(`Downloading Node.js v${version}...`);
 		console.log(`Downloading Node.js from ${downloadUrl}...`);
+		const dlStart = Date.now();
 		await downloadFile(downloadUrl, archivePath);
+		console.log(`[Environment] Node.js download took ${Date.now() - dlStart}ms`);
 		sendStartupProgress(`Extracting Node.js v${version}...`);
 		console.log(`Extracting Node.js to ${tempDir}...`);
+		const extStart = Date.now();
 		const extractTempDir = join(tempDir, "extracted");
 		await mkdir(extractTempDir, { recursive: true });
 		if (extension === "zip") await extractZip(archivePath, extractTempDir);
@@ -9013,17 +9223,35 @@ async function ensureNodeJS(context, version = DEFAULT_NODE_VERSION) {
 		const nodeSubDir = (await readdir(extractTempDir)).find((entry) => entry.startsWith(`node-v${version}`));
 		if (!nodeSubDir) throw new Error(`Could not find extracted Node.js directory`);
 		const sourceDir = join(extractTempDir, nodeSubDir);
-		await mkdir(dirname(nodeDir), { recursive: true });
-		await rm(nodeDir, {
-			recursive: true,
-			force: true
-		});
-		await cp(sourceDir, nodeDir, { recursive: true });
-		await rm(tempDir, {
-			recursive: true,
-			force: true
-		});
-		if (!isWindows) await chmod(finalNodePath, 493).catch(() => {});
+		const parentDir = dirname(nodeDir);
+		await mkdir(parentDir, { recursive: true });
+		const tempNodeDir = join(parentDir, `.tmp-node-${version}-${Math.random().toString(36).slice(2)}`);
+		await mkdir(tempNodeDir, { recursive: true });
+		try {
+			await cp(sourceDir, tempNodeDir, { recursive: true });
+			if (!isWindows) await chmod(join(tempNodeDir, "bin/node"), 493).catch(() => {});
+			if (existsSync(nodeDir)) await rm(nodeDir, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+			try {
+				await rename(tempNodeDir, nodeDir);
+			} catch (err) {
+				if (isNodeJSComplete(finalNodePath)) console.log(`[Fetcher] Node.js directory already exists and is valid.`);
+				else throw err;
+			}
+			console.log(`[Environment] Node.js extraction took ${Date.now() - extStart}ms`);
+		} finally {
+			await rm(tempNodeDir, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+			await rm(tempDir, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+		}
+		console.log(`[Environment] Node.js set up complete in ${Date.now() - checkStart}ms`);
 		return finalNodePath;
 	});
 }
@@ -9031,36 +9259,56 @@ async function ensureNodeJS(context, version = DEFAULT_NODE_VERSION) {
 * Installs the PNPM package from npm if not already present.
 */
 async function ensurePNPM(context, version = DEFAULT_PNPM_VERSION) {
+	const checkStart = Date.now();
 	const pnpmPath = join(context.getPackagesPath("pnpm", version), "bin", "pnpm.cjs");
-	if (existsSync(pnpmPath)) return pnpmPath;
+	if (existsSync(pnpmPath)) {
+		console.log(`[Environment] PNPM check took ${Date.now() - checkStart}ms (found at ${pnpmPath})`);
+		return pnpmPath;
+	}
 	return withLock(`pnpm:${version}`, async () => {
 		if (existsSync(pnpmPath)) return pnpmPath;
 		sendStartupProgress(`Checking PNPM v${version}...`);
 		const { packageDir } = await fetchPackage("pnpm", version, { context });
+		console.log(`[Environment] PNPM set up complete in ${Date.now() - checkStart}ms`);
 		return join(packageDir, "bin", "pnpm.cjs");
 	});
 }
 async function installDependencies(packageDir, packageName, options) {
+	const start = Date.now();
 	const nodeModulesPath = join(packageDir, "node_modules");
-	if (existsSync(nodeModulesPath)) try {
-		if ((await readdir(nodeModulesPath)).length === 0) console.warn(`[Fetcher] ${packageName}: node_modules exists but is empty. Re-installing...`);
-		else {
-			console.log(`[Fetcher] ${packageName}: Dependencies already installed, skipping.`);
-			return;
-		}
-	} catch (e) {}
-	console.log(`[Fetcher] ${packageName}: Ensuring dependencies are installed...`);
+	if (isDependenciesInstalledSync(packageDir)) {
+		console.log(`[Fetcher] ${packageName}: Dependencies already installed, skipping.`);
+		return;
+	}
+	const tempDir = `${packageDir}.tmp-deps-${Math.random().toString(36).slice(2)}`;
+	await mkdir(tempDir, { recursive: true });
 	try {
-		const { all } = await runPnpm(packageDir, {
+		await cp(join(packageDir, "package.json"), join(tempDir, "package.json"));
+		console.log(`[Fetcher] ${packageName}: Ensuring dependencies are installed...`);
+		const pnpmStart = Date.now();
+		const { all } = await runPnpm(tempDir, {
 			signal: options.signal,
 			context: options.context
 		});
+		console.log(`[Fetcher] ${packageName}: pnpm install command took ${Date.now() - pnpmStart}ms`);
 		if (all) console.log(`[Fetcher] ${packageName}: Installation trace:\n${all}`);
-		console.log(`[Fetcher] ${packageName}: Dependencies installed successfully.`);
+		const tempNodeModules = join(tempDir, "node_modules");
+		if (existsSync(nodeModulesPath)) await rm(nodeModulesPath, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		const renameStart = Date.now();
+		await rename(tempNodeModules, nodeModulesPath);
+		console.log(`[Fetcher] ${packageName}: Dependencies installed successfully (rename took ${Date.now() - renameStart}ms, total installDependencies took ${Date.now() - start}ms).`);
 	} catch (err) {
 		console.error(`[Fetcher] ${packageName}: CRITICAL ERROR during dependency installation: ${err.message}`);
 		if (err.all) console.error(`[Fetcher] ${packageName}: Error details:\n${err.all}`);
 		throw new Error(`Failed to install dependencies for ${packageName}. See logs for details.`);
+	} finally {
+		await rm(tempDir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
 	}
 }
 async function fetchPipelabAsset(packageName, versionOrRange, options) {
@@ -9153,22 +9401,27 @@ async function crawlMonorepoPackages() {
 	}
 	return cache;
 }
-async function findLatestLocalVersion(baseDir) {
+async function tryLocalFallback(versionOrRange, _error, baseDir, logPrefix) {
 	if (!existsSync(baseDir)) return null;
 	try {
-		return (await readdir(baseDir, { withFileTypes: true })).filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name).sort((a, b) => b.localeCompare(a, void 0, {
-			numeric: true,
-			sensitivity: "base"
-		}))[0] || null;
-	} catch {
-		return null;
-	}
-}
-async function tryLocalFallback(_version, _error, baseDir, logPrefix) {
-	const latestLocal = await findLatestLocalVersion(baseDir);
-	if (latestLocal) {
-		console.info(`[Fetcher] ${logPrefix}: Using locally cached version: ${latestLocal}`);
-		return latestLocal;
+		const localVersions = (await readdir(baseDir, { withFileTypes: true })).filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name).filter((name) => !!semver.valid(name));
+		if (localVersions.length === 0) return null;
+		const range = versionOrRange || "latest";
+		if (range === "latest") {
+			const latestLocal = localVersions.sort((a, b) => semver.rcompare(a, b))[0] || null;
+			if (latestLocal) {
+				console.info(`[Fetcher] ${logPrefix}: Using locally cached latest version: ${latestLocal}`);
+				return latestLocal;
+			}
+		} else {
+			const matched = semver.maxSatisfying(localVersions, range);
+			if (matched) {
+				console.info(`[Fetcher] ${logPrefix}: Using locally cached matching version: ${matched} for range ${range}`);
+				return matched;
+			}
+		}
+	} catch (e) {
+		console.warn(`[Fetcher] ${logPrefix}: Error during local fallback resolution:`, e);
 	}
 	return null;
 }
@@ -9202,50 +9455,6 @@ const checkParams = (definitionParams, elementParams) => {
 	} else console.warn("Unexpected param \"" + param + "\"");
 	for (const param of expected) if (isRequired(definitionParams[param])) throw new Error("Missing param \"" + param + "\"");
 };
-const handleConditionExecute = async (nodeId, pluginId, params, cwd, context) => {
-	const ctx = context;
-	const { plugins } = usePlugins();
-	const { logger } = useLogger();
-	const node = plugins.value.find((plugin) => plugin.id === pluginId)?.nodes.find((node) => node.node.id === nodeId);
-	if (!node) return {
-		type: "error",
-		ipcError: "Node not found"
-	};
-	try {
-		if (!(await stat(cwd)).isDirectory()) throw new Error(`Execution directory "${cwd}" exists but is not a directory.`);
-	} catch (e) {
-		if (e.code === "ENOENT") await mkdir(cwd, { recursive: true });
-		else throw e;
-	}
-	try {
-		checkParams(node.node.params, params);
-		const resolvedInputs = params;
-		return {
-			type: "success",
-			result: {
-				outputs: {},
-				value: await node.runner({
-					inputs: resolvedInputs,
-					log: (...args) => {
-						logger().info(`[${node.node.name}]`, ...args);
-					},
-					meta: { definition: "" },
-					setMeta: () => {
-						logger().info("set meta defined here");
-					},
-					cwd,
-					context: ctx
-				})
-			}
-		};
-	} catch (e) {
-		logger().error("Error in condition execution:", e);
-		return {
-			type: "error",
-			ipcError: String(e)
-		};
-	}
-};
 const handleActionExecute = async (nodeId, pluginId, params, mainWindow, send, abortSignal, cwd, cachePath, context) => {
 	const ctx = context;
 	const { plugins } = usePlugins();
@@ -9331,26 +9540,55 @@ const handleActionExecute = async (nodeId, pluginId, params, mainWindow, send, a
 };
 //#endregion
 //#region src/plugins-registry.ts
-const DEFAULT_PLUGIN_IDS = [
-	"construct",
-	"filesystem",
-	"system",
-	"steam",
-	"itch",
-	"electron",
-	"discord",
-	"poki",
-	"nvpatch",
-	"tauri",
-	"minify",
-	"netlify"
-];
+const enhancePluginDefinition = async (plugin, packageDir, fallbackName, fallbackVersion) => {
+	if (!plugin) return plugin;
+	let packageName = fallbackName;
+	let version = fallbackVersion;
+	let pipelabMeta = null;
+	let pkgDescription = "";
+	try {
+		const pkgJsonPath = join(packageDir, "package.json");
+		if (existsSync(pkgJsonPath)) {
+			const pkgContent = await readFile(pkgJsonPath, "utf8");
+			const pkg = JSON.parse(pkgContent);
+			if (pkg.name) packageName = pkg.name;
+			if (pkg.version) version = pkg.version;
+			if (pkg.description) pkgDescription = pkg.description;
+			if (pkg.pipelab) pipelabMeta = pkg.pipelab;
+		}
+	} catch (e) {
+		console.error(`[Plugins] Failed to read package.json in ${packageDir}:`, e);
+	}
+	plugin.packageName = packageName;
+	plugin.id = packageName;
+	plugin.version = fallbackVersion === "local" ? "local" : version;
+	plugin.isOfficial = packageName.startsWith("@pipelab/");
+	plugin.name = pipelabMeta?.name || packageName;
+	plugin.description = pipelabMeta?.description || pkgDescription || "";
+	if (pipelabMeta?.icon) if (typeof pipelabMeta.icon === "string") {
+		let iconPath = pipelabMeta.icon;
+		if (iconPath.startsWith(".")) iconPath = pathToFileURL(join(packageDir, iconPath)).href;
+		plugin.icon = {
+			type: "image",
+			image: iconPath
+		};
+	} else plugin.icon = pipelabMeta.icon;
+	else plugin.icon = {
+		type: "icon",
+		icon: "pi pi-box"
+	};
+	return plugin;
+};
 const loadPipelabPlugin = async (id, options) => {
+	const start = Date.now();
 	try {
-		const { packageDir, entryPoint } = await fetchPipelabPlugin(`@pipelab/plugin-${id}`, "latest", {
+		const packageName = id;
+		const fetchStart = Date.now();
+		const { packageDir, entryPoint } = await fetchPipelabPlugin(packageName, options.context.releaseTag, {
 			context: options.context,
 			installDeps: false
 		});
+		const fetchDuration = Date.now() - fetchStart;
 		console.log(`[Plugins] [${id}] Attempting to import from: ${entryPoint}`);
 		if (!existsSync(entryPoint)) {
 			console.error(`[Plugins] [${id}] CRITICAL: Plugin entry point not found at ${entryPoint}`);
@@ -9359,37 +9597,149 @@ const loadPipelabPlugin = async (id, options) => {
 				console.log(`[Plugins] [${id}] Directory contents:`, files);
 			} catch (e) {}
 		}
+		const importStart = Date.now();
 		const pluginModule = await import(pathToFileURL(entryPoint).href);
-		console.log(`[Plugins] [${id}] Successfully loaded from: ${packageDir}`);
-		return pluginModule.default;
+		const importDuration = Date.now() - importStart;
+		const totalDuration = Date.now() - start;
+		console.log(`[Plugins] [${id}] Successfully loaded from: ${packageDir} (fetch: ${fetchDuration}ms, import: ${importDuration}ms, total: ${totalDuration}ms)`);
+		const plugin = pluginModule.default;
+		await enhancePluginDefinition(plugin, packageDir, packageName, options.context.releaseTag);
+		return plugin;
 	} catch (e) {
-		console.error(`[Plugins] [${id}] CRITICAL: Failed to load:`, e);
+		console.error(`[Plugins] [${id}] CRITICAL: Failed to load after ${Date.now() - start}ms:`, e);
 		if (e.code === "ERR_MODULE_NOT_FOUND") console.error(`[Plugins] [${id}] This usually means a dependency is missing in the plugin's node_modules.`);
 		return null;
 	}
 };
+const loadCustomPlugin = async (packageName, version, options) => {
+	const start = Date.now();
+	try {
+		const fetchStart = Date.now();
+		const { packageDir, entryPoint } = await fetchPipelabPlugin(packageName, version, {
+			context: options.context,
+			installDeps: false
+		});
+		const fetchDuration = Date.now() - fetchStart;
+		console.log(`[Plugins] [${packageName}] Attempting to import custom plugin from: ${entryPoint}`);
+		if (!existsSync(entryPoint)) {
+			console.error(`[Plugins] [${packageName}] CRITICAL: Plugin entry point not found at ${entryPoint}`);
+			return null;
+		}
+		const importStart = Date.now();
+		const pluginModule = await import(pathToFileURL(entryPoint).href);
+		const importDuration = Date.now() - importStart;
+		const totalDuration = Date.now() - start;
+		console.log(`[Plugins] [${packageName}] Successfully loaded custom plugin from: ${packageDir} (fetch: ${fetchDuration}ms, import: ${importDuration}ms, total: ${totalDuration}ms)`);
+		const plugin = pluginModule.default;
+		await enhancePluginDefinition(plugin, packageDir, packageName, version);
+		return plugin;
+	} catch (e) {
+		console.error(`[Plugins] [${packageName}] CRITICAL: Failed to load after ${Date.now() - start}ms:`, e);
+		return null;
+	}
+};
+async function findInstalledPlugins(packagesDir) {
+	const installed = [];
+	if (!existsSync(packagesDir)) return installed;
+	async function scan(dir, depth = 0) {
+		if (depth > 4) return;
+		try {
+			const entries = await readdir(dir, { withFileTypes: true });
+			if (entries.some((e) => e.isFile() && e.name === "package.json")) {
+				try {
+					const content = await readFile(join(dir, "package.json"), "utf8");
+					const pkg = JSON.parse(content);
+					if (pkg.name && pkg.name !== "pnpm") installed.push({
+						name: pkg.name,
+						version: pkg.version || "0.0.0",
+						packageDir: dir,
+						description: pkg.description || ""
+					});
+				} catch (e) {}
+				return;
+			}
+			for (const entry of entries) if (entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith(".")) await scan(join(dir, entry.name), depth + 1);
+		} catch (e) {}
+	}
+	await scan(packagesDir);
+	return installed;
+}
 const builtInPlugins = async (options) => {
 	console.log("[Plugins] Starting background plugin loading...");
 	sendStartupProgress("Preparing environment...");
+	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("@pipelab/shared");
 	const { registerPlugins } = usePlugins();
 	const { webSocketServer } = await import("./index.mjs");
-	Promise.allSettled(DEFAULT_PLUGIN_IDS.map(async (id) => {
-		sendStartupProgress(`Loading plugin: ${id}`);
-		const plugin = await loadPipelabPlugin(id, options);
-		if (plugin) {
-			registerPlugins([plugin]);
-			webSocketServer.broadcast("plugin:loaded", { plugin });
+	webSocketServer.broadcast("startup:progress", { type: "ready" });
+	(async () => {
+		const totalStart = Date.now();
+		const pluginsToLoad = /* @__PURE__ */ new Map();
+		for (const name of [
+			"@pipelab/plugin-construct",
+			"@pipelab/plugin-filesystem",
+			"@pipelab/plugin-system",
+			"@pipelab/plugin-steam",
+			"@pipelab/plugin-itch",
+			"@pipelab/plugin-electron",
+			"@pipelab/plugin-discord",
+			"@pipelab/plugin-poki",
+			"@pipelab/plugin-nvpatch",
+			"@pipelab/plugin-tauri",
+			"@pipelab/plugin-minify",
+			"@pipelab/plugin-netlify"
+		]) pluginsToLoad.set(name, "latest");
+		if (isDev && projectRoot) {
+			const pluginsDir = join(projectRoot, "plugins");
+			if (existsSync(pluginsDir)) try {
+				const entries = await readdir(pluginsDir, { withFileTypes: true });
+				for (const entry of entries) if (entry.isDirectory()) {
+					const pkgPath = join(pluginsDir, entry.name, "package.json");
+					if (existsSync(pkgPath)) try {
+						const pkgContent = await readFile(pkgPath, "utf-8");
+						const pkg = JSON.parse(pkgContent);
+						if (pkg.name && pkg.name.startsWith("@pipelab/plugin-") && pkg.name !== "@pipelab/plugin-core") pluginsToLoad.set(pkg.name, "local");
+					} catch (e) {
+						console.error(`[Plugins] Failed to parse package.json for ${entry.name}:`, e);
+					}
+				}
+			} catch (e) {
+				console.error(`[Plugins] Failed to scan local workspace plugins directory:`, e);
+			}
+		}
+		try {
+			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);
+		} catch (e) {
+			console.error(`[Plugins] Failed to load settings config on startup:`, e);
 		}
-	})).then(() => {
-		console.log("[Plugins] All default plugins loaded.");
+		console.log(`[Plugins] Total plugins to load on startup:`, Array.from(pluginsToLoad.entries()));
+		const loadPromises = Array.from(pluginsToLoad.entries()).map(async ([packageName, version]) => {
+			sendStartupProgress(`Loading plugin: ${packageName}`);
+			const pluginStart = Date.now();
+			try {
+				const plugin = await loadCustomPlugin(packageName, version, options);
+				if (plugin) {
+					registerPlugins([plugin]);
+					webSocketServer.broadcast("plugin:loaded", { plugin });
+					console.log(`[Plugins] Loaded ${packageName}@${version} in ${Date.now() - pluginStart}ms`);
+				}
+			} catch (err) {
+				console.error(`[Plugins] Failed to load plugin ${packageName} at startup:`, err);
+			}
+		});
+		await Promise.all(loadPromises);
+		console.log(`[Plugins] All startup plugins loaded in ${Date.now() - totalStart}ms.`);
 		sendStartupProgress("All plugins loaded.");
 		setTimeout(() => {
 			webSocketServer.broadcast("startup:progress", { type: "done" });
 		}, 2e3);
-	});
-	return [];
+	})();
 };
 //#endregion
 //#region src/utils.ts
@@ -9398,10 +9748,6 @@ const getFinalPlugins = () => {
 	const finalPlugins = [];
 	for (const plugin of plugins.value) {
 		const finalNodes = [];
-		const transformUrl = (url) => {
-			if (url.startsWith("file://")) return url.replace("file://", "media://");
-			return url;
-		};
 		const finalIcon = plugin.icon?.type === "image" ? {
 			...plugin.icon,
 			image: transformUrl(plugin.icon.image)
@@ -9435,6 +9781,7 @@ const executeGraphWithHistory = async ({ graph, variables, projectName, projectP
 		projectName,
 		projectPath,
 		pipelineId,
+		cachePath,
 		startTime,
 		status: "running",
 		logs: [],
@@ -9449,7 +9796,7 @@ const executeGraphWithHistory = async ({ graph, variables, projectName, projectP
 	const shouldDisableHistory = process.env.PIPELAB_DISABLE_HISTORY === "true";
 	if (!shouldDisableHistory) await buildHistoryStorage.save(initialEntry);
 	const logs = [];
-	const sandboxPath = await generateTempFolder(cachePath);
+	const sandboxPath = await ctx.createTempFolder("pipeline-sandbox-");
 	const { logger } = useLogger();
 	let completedSteps = 0;
 	const { registerPlugins, plugins: registeredPlugins } = usePlugins();
@@ -9463,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,
@@ -9531,7 +9878,6 @@ const executeGraphWithHistory = async ({ graph, variables, projectName, projectP
 		}, pipelineId);
 		throw error;
 	} finally {
-		if (!shouldDisableHistory) buildHistoryStorage.applyRetentionPolicy();
 		try {
 			await rm(sandboxPath, {
 				recursive: true,
@@ -9540,6 +9886,14 @@ const executeGraphWithHistory = async ({ graph, variables, projectName, projectP
 		} catch (e) {
 			console.warn(`Failed to cleanup sandbox at ${sandboxPath}:`, e);
 		}
+		try {
+			await rm(cachePath, {
+				recursive: true,
+				force: true
+			});
+		} catch (e) {
+			console.warn(`Failed to cleanup cache at ${cachePath}:`, e);
+		}
 	}
 };
 //#endregion
@@ -9547,7 +9901,7 @@ const executeGraphWithHistory = async ({ graph, variables, projectName, projectP
 const c3toSteamPreset = async () => {
 	return {
 		data: {
-			version: "3.0.0",
+			version: "5.0.0",
 			name: "Construct 3 to Steam",
 			description: "A basic project to get you started with Construct 3 and Steam",
 			variables: [],
@@ -9555,8 +9909,9 @@ const c3toSteamPreset = async () => {
 				triggers: [{
 					type: "event",
 					origin: {
-						pluginId: "system",
-						nodeId: "manual"
+						pluginId: "@pipelab/plugin-system",
+						nodeId: "manual",
+						version: "latest"
 					},
 					uid: "manual-start",
 					params: {}
@@ -9567,7 +9922,8 @@ const c3toSteamPreset = async () => {
 						type: "action",
 						origin: {
 							nodeId: "export-construct-project",
-							pluginId: "construct"
+							pluginId: "@pipelab/plugin-construct",
+							version: "latest"
 						},
 						params: {
 							file: {
@@ -9605,7 +9961,8 @@ const c3toSteamPreset = async () => {
 						type: "action",
 						origin: {
 							nodeId: "unzip-file-node",
-							pluginId: "filesystem"
+							pluginId: "@pipelab/plugin-filesystem",
+							version: "latest"
 						},
 						params: { file: {
 							editor: "editor",
@@ -9617,7 +9974,8 @@ const c3toSteamPreset = async () => {
 						type: "action",
 						origin: {
 							nodeId: "electron:package:v2",
-							pluginId: "electron"
+							pluginId: "@pipelab/plugin-electron",
+							version: "latest"
 						},
 						params: {
 							arch: {
@@ -9747,7 +10105,8 @@ const c3toSteamPreset = async () => {
 						type: "action",
 						origin: {
 							nodeId: "steam-upload",
-							pluginId: "steam"
+							pluginId: "@pipelab/plugin-steam",
+							version: "latest"
 						},
 						params: {
 							sdk: {
@@ -9790,7 +10149,8 @@ const c3toSteamPreset = async () => {
 						type: "action",
 						origin: {
 							nodeId: "fs:open-in-explorer",
-							pluginId: "filesystem"
+							pluginId: "@pipelab/plugin-filesystem",
+							version: "latest"
 						},
 						params: { path: {
 							editor: "editor",
@@ -9809,7 +10169,7 @@ const c3toSteamPreset = async () => {
 const newProjectPreset = async () => {
 	return {
 		data: {
-			version: "3.0.0",
+			version: "5.0.0",
 			name: "Empty project",
 			description: "A default project with no tasks added",
 			variables: [],
@@ -9817,8 +10177,9 @@ const newProjectPreset = async () => {
 				triggers: [{
 					type: "event",
 					origin: {
-						pluginId: "system",
-						nodeId: "manual"
+						pluginId: "@pipelab/plugin-system",
+						nodeId: "manual",
+						version: "latest"
 					},
 					uid: "manual-start",
 					params: {}
@@ -9834,7 +10195,7 @@ const newProjectPreset = async () => {
 const moreToCome = async () => {
 	return {
 		data: {
-			version: "3.0.0",
+			version: "5.0.0",
 			name: "More to come!",
 			description: "Do not hesitate to suggest templates you would see here",
 			variables: [],
@@ -9842,8 +10203,9 @@ const moreToCome = async () => {
 				triggers: [{
 					type: "event",
 					origin: {
-						pluginId: "system",
-						nodeId: "manual"
+						pluginId: "@pipelab/plugin-system",
+						nodeId: "manual",
+						version: "latest"
 					},
 					uid: "manual-start",
 					params: {}
@@ -9887,10 +10249,6 @@ const registerEngineHandlers = (context) => {
 			}
 		});
 	});
-	handle("condition:execute", async (_, { value }) => {
-		const { nodeId, params, pluginId } = value;
-		await handleConditionExecute(nodeId, pluginId, params, await generateTempFolder(tmpdir()), context);
-	});
 	let abortControllerGraph = void 0;
 	const effectiveActionExecute = async (nodeId, pluginId, params, mainWindow, send, cwd, cachePath) => {
 		try {
@@ -9911,23 +10269,32 @@ const registerEngineHandlers = (context) => {
 	};
 	handle("action:execute", async (event, { send, value }) => {
 		const { nodeId, params, pluginId } = value;
-		const cachePath = (await (await setupConfigFile("settings", { context })).getConfig())?.cacheFolder || tmpdir();
-		const cwd = await generateTempFolder(cachePath);
-		const mainWindow = void 0;
-		abortControllerGraph = new AbortController();
-		const signalPromise = new Promise((resolve, reject) => {
-			abortControllerGraph.signal.addEventListener("abort", async () => {
-				await send({
-					type: "end",
-					data: {
-						ipcError: "Action aborted",
-						type: "error"
-					}
+		const cachePath = context.getCachePath(CacheFolder.Actions, pluginId, nodeId);
+		const cwd = await context.createTempFolder("action-execute-");
+		try {
+			const mainWindow = void 0;
+			abortControllerGraph = new AbortController();
+			const signalPromise = new Promise((resolve, reject) => {
+				abortControllerGraph.signal.addEventListener("abort", async () => {
+					await send({
+						type: "end",
+						data: {
+							ipcError: "Action aborted",
+							type: "error"
+						}
+					});
+					return reject(/* @__PURE__ */ new Error("Action interrupted"));
 				});
-				return reject(/* @__PURE__ */ new Error("Action interrupted"));
 			});
-		});
-		await Promise.race([signalPromise, effectiveActionExecute(nodeId, pluginId, params, mainWindow, send, cwd, cachePath)]);
+			await Promise.race([signalPromise, effectiveActionExecute(nodeId, pluginId, params, mainWindow, send, cwd, cachePath)]);
+		} finally {
+			await rm(cwd, {
+				recursive: true,
+				force: true
+			}).catch((err) => {
+				console.warn(`Failed to cleanup temp folder at ${cwd}:`, err);
+			});
+		}
 	});
 	handle("constants:get", async (_, { send }) => {
 		const userData = context.userDataPath;
@@ -9951,11 +10318,11 @@ const registerEngineHandlers = (context) => {
 	});
 	handle("graph:execute", async (event, { send, value }) => {
 		const { graph, variables, projectName, projectPath, pipelineId } = value;
-		const config = await (await setupConfigFile("settings", { context })).getConfig();
+		await (await setupSettingsConfigFile(context)).getConfig();
 		const effectiveProjectName = projectName || "Unnamed Project";
 		const effectiveProjectPath = projectPath || "";
 		const effectivePipelineId = pipelineId || "unknown";
-		const effectiveCachePath = config?.cacheFolder || tmpdir();
+		const effectiveCachePath = context.getCachePath(CacheFolder.Pipelines, effectivePipelineId);
 		const mainWindow = void 0;
 		abortControllerGraph = new AbortController();
 		try {
@@ -10063,7 +10430,7 @@ var JsonFileStorage = class {
 	filePath;
 	logger = useLogger().logger;
 	constructor(fileName, context) {
-		this.filePath = path.join(context.userDataPath, fileName);
+		this.filePath = context.getConfigPath(fileName);
 		const dir = path.dirname(this.filePath);
 		if (!fs.existsSync(dir)) try {
 			fs.mkdirSync(dir, { recursive: true });
@@ -10262,16 +10629,730 @@ const registerAuthHandlers = (context) => {
 const registerSystemHandlers = (options) => {
 	const { handle } = useAPI();
 	handle("agent:version:get", async (_, { send }) => {
+		const isStable = options.context.userDataPath.endsWith("app") || !options.context.userDataPath.includes("app-beta");
+		send({
+			type: "end",
+			data: {
+				type: "success",
+				result: {
+					version: isDev ? "workspace" : options.version,
+					channel: isDev ? "dev" : isStable ? "stable" : "beta"
+				}
+			}
+		});
+	});
+};
+//#endregion
+//#region src/handlers/plugins.ts
+const localPluginsMap = /* @__PURE__ */ new Map();
+if (isDev && projectRoot) {
+	const pluginsDir = join(projectRoot, "plugins");
+	if (existsSync(pluginsDir)) try {
+		const entries = readdirSync(pluginsDir, { withFileTypes: true });
+		for (const entry of entries) if (entry.isDirectory()) {
+			const pkgPath = join(pluginsDir, entry.name, "package.json");
+			if (existsSync(pkgPath)) try {
+				const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+				if (pkg.name) localPluginsMap.set(pkg.name, join(pluginsDir, entry.name));
+			} catch (e) {
+				console.error(`[Plugins] Failed to parse package.json for ${entry.name}:`, e);
+			}
+		}
+	} catch (e) {
+		console.error(`[Plugins] Failed to scan local workspace plugins directory:`, e);
+	}
+}
+/**
+* Resolves a requested plugin version.
+* If the plugin is present in the local workspace map during development,
+* its version is overridden to "local" so Pipelab loads it from the source files.
+*/
+function resolvePluginVersion(packageName, requestedVersion) {
+	if (isDev && projectRoot && process.env.PIPELAB_FORCE_NPM !== "true" && localPluginsMap.has(packageName)) return "local";
+	return requestedVersion || "latest";
+}
+const registerPluginsHandlers = (context) => {
+	const { handle } = useAPI();
+	handle("plugin:search", async (_, { send, value }) => {
+		try {
+			const query = value.query || "";
+			const text = query ? `${query} keywords:pipelab-plugin` : "keywords:pipelab-plugin";
+			const url = `https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(text)}&size=50`;
+			const response = await fetch(url);
+			if (!response.ok) throw new Error(`NPM registry search failed with status ${response.status}`);
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: { results: ((await response.json()).objects || []).map((obj) => ({
+						name: obj.package.name,
+						version: obj.package.version,
+						description: obj.package.description,
+						keywords: obj.package.keywords,
+						date: obj.package.date
+					})) }
+				}
+			});
+		} catch (e) {
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e.message || "Failed to search npm registry"
+				}
+			});
+		}
+	});
+	handle("plugin:get-details", async (_, { send, value }) => {
+		try {
+			const { packageName } = value;
+			const packument = await pacote.packument(packageName, { fullMetadata: true });
+			const latestVersion = packument["dist-tags"]?.latest || Object.keys(packument.versions).pop() || "0.0.0";
+			const latestPkg = packument.versions[latestVersion];
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: {
+						name: packument.name,
+						latestVersion,
+						versions: Object.keys(packument.versions).reverse(),
+						description: latestPkg?.description
+					}
+				}
+			});
+		} catch (e) {
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e.message || "Failed to get plugin details"
+				}
+			});
+		}
+	});
+	handle("plugin:install", async (_, { send, value }) => {
+		try {
+			const { packageName, version } = value;
+			const mappedVersion = resolvePluginVersion(packageName, version);
+			console.log(`[Plugins] Installing ${packageName}@${mappedVersion}...`);
+			const { packageDir } = await fetchPipelabPlugin(packageName, mappedVersion, {
+				context,
+				installDeps: false
+			});
+			const plugin = await loadCustomPlugin(packageName, mappedVersion, { context });
+			if (!plugin) throw new Error("Failed to load installed plugin module.");
+			const { registerPlugins } = usePlugins();
+			registerPlugins([plugin]);
+			webSocketServer.broadcast("plugin:loaded", { plugin });
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: { result: "ok" }
+				}
+			});
+		} catch (e) {
+			console.error(`[Plugins] Installation failed for ${value.packageName}:`, e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e.message || "Failed to install plugin"
+				}
+			});
+		}
+	});
+	handle("plugin:uninstall", async (_, { send, value }) => {
+		try {
+			const { packageName } = value;
+			console.log(`[Plugins] Uninstalling plugin ${packageName}...`);
+			const targetDir = context.getPackagesPath(packageName);
+			if (existsSync(targetDir)) await rm(targetDir, {
+				recursive: true,
+				force: true
+			});
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: { result: "ok" }
+				}
+			});
+		} catch (e) {
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e.message || "Failed to uninstall plugin"
+				}
+			});
+		}
+	});
+	handle("plugin:list-installed", async (_, { send }) => {
+		try {
+			const rawInstalled = await findInstalledPlugins(context.getPackagesPath());
+			const DEFAULT_PLUGIN_IDS = [
+				"construct",
+				"filesystem",
+				"system",
+				"steam",
+				"itch",
+				"electron",
+				"discord",
+				"poki",
+				"nvpatch",
+				"tauri",
+				"minify",
+				"netlify"
+			];
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: { installed: rawInstalled.filter((item) => {
+						return !DEFAULT_PLUGIN_IDS.some((id) => item.name === `@pipelab/plugin-${id}`);
+					}).map((item) => ({
+						name: item.name,
+						version: item.version,
+						description: item.description
+					})) }
+				}
+			});
+		} catch (e) {
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e.message || "Failed to list installed plugins"
+				}
+			});
+		}
+	});
+	handle("plugin:ensure-loaded", async (_, { send, value }) => {
+		const { plugins } = value;
+		const { plugins: registeredPlugins, registerPlugins } = usePlugins();
+		const loaded = [];
+		const failed = [];
+		const pluginsToEnsure = /* @__PURE__ */ new Set();
+		if (plugins && typeof plugins === "object") {
+			for (const id of Object.keys(plugins)) if (id) pluginsToEnsure.add(id);
+		}
+		for (const packageName of pluginsToEnsure) {
+			const mappedVersion = resolvePluginVersion(packageName);
+			if (registeredPlugins.value.some((p) => {
+				if (p.packageName !== packageName) return false;
+				if (mappedVersion === "latest") return true;
+				return p.version === mappedVersion;
+			})) continue;
+			try {
+				console.log(`[Plugins] JIT loading plugin "${packageName}@${mappedVersion}" for pipeline...`);
+				const plugin = await loadCustomPlugin(packageName, mappedVersion, { context });
+				if (plugin) {
+					registerPlugins([plugin]);
+					webSocketServer.broadcast("plugin:loaded", { plugin });
+					loaded.push(packageName);
+					console.log(`[Plugins] JIT loaded "${packageName}" successfully.`);
+				} else {
+					console.warn(`[Plugins] JIT load for "${packageName}" returned no plugin.`);
+					failed.push(packageName);
+				}
+			} catch (e) {
+				console.error(`[Plugins] JIT load failed for "${packageName}":`, e);
+				failed.push(packageName);
+			}
+		}
 		send({
 			type: "end",
 			data: {
 				type: "success",
-				result: { version: options.version }
+				result: {
+					loaded,
+					failed
+				}
 			}
 		});
 	});
 };
 //#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, value }) => {
+		logger().info("[Migration] Scanning other channel database...");
+		try {
+			let sourceEnv = "prod";
+			if (value?.sourceChannel === "stable") sourceEnv = "prod";
+			else if (value?.sourceChannel === "beta") sourceEnv = "beta";
+			else sourceEnv = context.userDataPath.endsWith("app") || !context.userDataPath.includes("app-beta") ? "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: sourceEnv === "prod" ? "Stable" : "Beta",
+							targetChannel: isDev ? "Dev" : context.userDataPath.endsWith("app") || !context.userDataPath.includes("app-beta") ? "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 rawJson = JSON.parse(pipeContent);
+								const pipeJson = await savedFileMigrator.migrate(rawJson);
+								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: sourceEnv === "prod" ? "Stable" : "Beta",
+						targetChannel: isDev ? "Dev" : context.userDataPath.endsWith("app") || !context.userDataPath.includes("app-beta") ? "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, sourceChannel } = value;
+			let sourceEnv = "prod";
+			if (sourceChannel === "stable") sourceEnv = "prod";
+			else if (sourceChannel === "beta") sourceEnv = "beta";
+			else 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 });
+								try {
+									const pipeContent = await fs$1.readFile(stablePipeFile, "utf8");
+									const rawJson = JSON.parse(pipeContent);
+									const migratedJson = await savedFileMigrator.migrate(rawJson);
+									await fs$1.writeFile(betaPipeFile, JSON.stringify(migratedJson, null, 2));
+									logger().info(`[Migration] Migrated and copied pipeline file: ${stablePipe.configName}`);
+								} catch (err) {
+									await fs$1.copyFile(stablePipeFile, betaPipeFile);
+									logger().error(`[Migration] Error migrating during copy of ${stablePipe.configName}, fallback to direct copy:`, err);
+								}
+							}
+						}
+						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;
@@ -10283,6 +11364,8 @@ const registerAllHandlers = async (options) => {
 	registerAgentsHandlers(context);
 	registerAuthHandlers(context);
 	registerSystemHandlers(options);
+	registerPluginsHandlers(context);
+	registerMigrationHandlers(context);
 	const { registerPlugins } = usePlugins();
 	builtInPlugins({ context });
 };
@@ -52555,9 +53638,7 @@ async function runPipelineCommand(file, options, version) {
 		version,
 		context
 	});
-	registerMigrationHandlers(context);
-	await (await setupConfigFile("settings", { context })).getConfig();
-	const cachePath = join(context.userDataPath, "cache");
+	const cachePath = context.getCachePath(CacheFolder.Pipelines, effectivePipelineId);
 	await mkdir(cachePath, { recursive: true });
 	const abortController = new AbortController();
 	let supabase;
@@ -52630,15 +53711,63 @@ async function runPipelineCommand(file, options, version) {
 */
 async function fetchPackageReleases(packageName, options = {}) {
 	const { repo = "CynToolkit/pipelab", allowPrerelease = false } = options;
-	const url = `https://api.github.com/repos/${repo}/releases`;
-	console.log(`[GitHub] Fetching releases for ${packageName} from ${url}...`);
 	try {
-		const response = await fetch(url, { headers: {
-			"User-Agent": "Pipelab-Desktop-Updater",
-			Accept: "application/vnd.github.v3+json"
-		} });
+		const override = process.env.PIPELAB_OVERRIDE_RELEASE;
+		if (override) {
+			const targetTag = override.includes("@") ? override : `${packageName}@${override}`;
+			console.log(`[GitHub] Fetching specific override release: ${targetTag}`);
+			const response = await fetch(`https://api.github.com/repos/${repo}/releases/tags/${encodeURIComponent(targetTag)}`, {
+				headers: {
+					"User-Agent": "Pipelab-Desktop-Updater",
+					Accept: "application/vnd.github.v3+json"
+				},
+				signal: AbortSignal.timeout(1e4)
+			});
+			if (response.ok) return [await response.json()];
+			console.warn(`[GitHub] Override release tag ${targetTag} not found or error occurred`);
+		}
+		const matchingRefsUrl = `https://api.github.com/repos/${repo}/git/matching-refs/tags/${encodeURIComponent(packageName)}`;
+		console.log(`[GitHub] Querying matching tags from ${matchingRefsUrl}...`);
+		const response = await fetch(matchingRefsUrl, {
+			headers: {
+				"User-Agent": "Pipelab-Desktop-Updater",
+				Accept: "application/vnd.github.v3+json"
+			},
+			signal: AbortSignal.timeout(1e4)
+		});
 		if (!response.ok) throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
-		return (await response.json()).filter((r) => r.tag_name.startsWith(`${packageName}@`)).filter((r) => allowPrerelease || !r.prerelease);
+		const refs = await response.json();
+		if (!Array.isArray(refs)) return [];
+		const filteredTags = refs.map((r) => r.ref.replace("refs/tags/", "")).filter((tag) => tag.startsWith(`${packageName}@`)).filter((tag) => {
+			const version = tag.split("@").pop();
+			if (!version || !semver.valid(version)) return false;
+			const isPrerelease = semver.prerelease(version) !== null;
+			return allowPrerelease || !isPrerelease;
+		});
+		if (filteredTags.length === 0) return [];
+		filteredTags.sort((a, b) => {
+			const vA = a.split("@").pop() || "0.0.0";
+			const vB = b.split("@").pop() || "0.0.0";
+			return semver.rcompare(vA, vB);
+		});
+		for (const tag of filteredTags) {
+			console.log(`[GitHub] Fetching release details for tag: ${tag}`);
+			const releaseResponse = await fetch(`https://api.github.com/repos/${repo}/releases/tags/${encodeURIComponent(tag)}`, {
+				headers: {
+					"User-Agent": "Pipelab-Desktop-Updater",
+					Accept: "application/vnd.github.v3+json"
+				},
+				signal: AbortSignal.timeout(1e4)
+			});
+			if (releaseResponse.status === 404) {
+				console.warn(`[GitHub] Tag "${tag}" has no associated Release, skipping.`);
+				continue;
+			}
+			if (!releaseResponse.ok) throw new Error(`GitHub API error: ${releaseResponse.status} ${releaseResponse.statusText}`);
+			return [await releaseResponse.json()];
+		}
+		console.warn(`[GitHub] No published Release found for any matching tag of "${packageName}".`);
+		return [];
 	} catch (error) {
 		console.error(`[GitHub] Failed to fetch releases for ${packageName}:`, error);
 		return [];
@@ -52681,6 +53810,6 @@ async function fetchLatestDesktopRelease(options = {}) {
 	return latest;
 }
 //#endregion
-export { BuildHistoryStorage, DEFAULT_NODE_VERSION, DEFAULT_PNPM_VERSION, PipelabContext, WebSocketServer, builtInPlugins, downloadFile, ensure, ensureNodeJS, ensurePNPM, executeGraphWithHistory, extractTarGz, extractZip, fetchLatestDesktopRelease, fetchLatestPackageRelease, fetchPackage, fetchPackageReleases, fetchPipelabAsset, fetchPipelabCli, fetchPipelabPlugin, generateTempFolder, getDefaultUserDataPath, getFinalPlugins, getFolderSize, getMigrator, handleActionExecute, handleConditionExecute, isDev, 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