@pipelab/core-node 1.0.0-beta.10 → 1.0.0-beta.12

package/dist/index.mjs

@@ -2,11 +2,11 @@ import { createRequire } from "node:module";
 import path, { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
 import { homedir, platform, tmpdir } from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import fs, { createWriteStream, existsSync, readdirSync, statSync } from "node:fs";
+import fs, { createWriteStream, existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 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 { SubscriptionRequiredError, WebSocketError, appSettingsMigrator, configRegistry, fileRepoMigrations, isRequired, isSupabaseAvailable, isWebSocketRequestMessage, normalizePipelineConfig, processGraph, savedFileMigrator, supabase, transformUrl, useLogger, usePlugins } from "@pipelab/shared";
 import { getUiDevServerMissingWarning, uiDevPort, websocketPort } from "@pipelab/constants";
 import fs$1, { access, chmod, cp, mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { execa } from "execa";
@@ -454,7 +454,7 @@ const registerFsHandlers = (_context) => {
 const ensure = async (filesPath, defaultContent = "{}") => {
 	await mkdir(dirname(filesPath), { recursive: true });
 	try {
-		await access(filesPath);
+		if ((await stat(filesPath)).size === 0) await writeFile(filesPath, defaultContent);
 	} catch {
 		await writeFile(filesPath, defaultContent);
 	}
@@ -601,7 +601,7 @@ async function getFolderSize(dirPath) {
 //#region src/config.ts
 const getMigrator = (name) => {
 	if (configRegistry[name]) return configRegistry[name];
-	if (name.startsWith("pipeline-")) return configRegistry["pipeline"];
+	if (name.startsWith("pipeline-") || path.isAbsolute(name) || name.endsWith(".json")) return configRegistry["pipeline"];
 };
 const setupConfigFile = async (name, options) => {
 	const ctx = options.context;
@@ -624,11 +624,13 @@ const setupConfigFile = async (name, options) => {
 			const { logger } = useLogger();
 			let content = void 0;
 			let originalJson = void 0;
+			let parseFailed = false;
 			try {
 				content = await fs$1.readFile(filesPath, "utf8");
 				if (content !== void 0) originalJson = JSON.parse(content);
 			} catch (e) {
 				logger().error(`Error reading or parsing config ${name}:`, e);
+				parseFailed = true;
 			}
 			let json = void 0;
 			try {
@@ -649,7 +651,9 @@ const setupConfigFile = async (name, options) => {
 				logger().error(`Error migrating config ${name}:`, e);
 				json = migrator.defaultValue;
 			}
-			if (originalJson?.version !== json?.version || content === void 0) try {
+			let normalized = false;
+			if (name.startsWith("pipeline-") || path.isAbsolute(name) || name.endsWith(".json") || name === "pipeline") normalized = normalizePipelineConfig(json);
+			if (originalJson?.version !== json?.version || normalized || content === void 0 || parseFailed) try {
 				await fs$1.writeFile(filesPath, JSON.stringify(json));
 			} catch (e) {
 				logger().error(`Error saving migrated config ${name}:`, e);
@@ -740,6 +744,40 @@ const registerConfigHandlers = (context) => {
 			});
 		}
 	});
+	handle("config:delete", async (_, { send, value }) => {
+		const { config: name } = value;
+		logger().info("config:delete", name);
+		try {
+			const filesPath = path.isAbsolute(name) ? name : context.getConfigPath(`${name}.json`);
+			await fs$1.rm(filesPath, { force: true });
+			const parsedPath = path.parse(filesPath);
+			const dirEntries = await fs$1.readdir(parsedPath.dir).catch(() => []);
+			const prefix = `${parsedPath.name}.v`;
+			const suffix = `.json`;
+			for (const entry of dirEntries) if (entry.startsWith(prefix) && entry.endsWith(suffix)) {
+				const backupPath = path.join(parsedPath.dir, entry);
+				await fs$1.rm(backupPath, { force: true }).catch((err) => {
+					logger().error(`Failed to delete backup ${backupPath}:`, err);
+				});
+			}
+			send({
+				type: "end",
+				data: {
+					type: "success",
+					result: { result: "ok" }
+				}
+			});
+		} catch (e) {
+			logger().error(`config:delete error for ${name}:`, e);
+			send({
+				type: "end",
+				data: {
+					type: "error",
+					ipcError: e instanceof Error ? e.message : `Unable to delete config ${name}`
+				}
+			});
+		}
+	});
 };
 //#endregion
 //#region src/handlers/build-history.ts
@@ -8843,6 +8881,35 @@ async function serveCommand(options, version, _dirname) {
 	let rawAssetFolder;
 	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(`
@@ -8926,11 +8993,13 @@ async function withLock(key, fn) {
 * 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"
@@ -8941,7 +9010,10 @@ async function fetchPackage(packageName, versionOrRange, options) {
 	const ctx = options.context;
 	const baseDir = ctx.getPackagesPath(packageName);
 	let resolvedVersion;
-	console.log(`[Fetcher] Resolving ${packageName}@${versionOrRange || "latest"}...`);
+	let resolvedVersionOrRange = versionOrRange;
+	if (resolvedVersionOrRange === "local") resolvedVersionOrRange = "latest";
+	console.log(`[Fetcher] Resolving ${packageName}@${resolvedVersionOrRange || "latest"}...`);
+	const resolveStart = Date.now();
 	try {
 		const cachePath = join(ctx.userDataPath, "cache", "pacote");
 		let packumentPromise = packumentRequests.get(packageName);
@@ -8951,26 +9023,36 @@ async function fetchPackage(packageName, versionOrRange, options) {
 		}
 		const packument = await packumentPromise;
 		const versions = Object.keys(packument.versions);
-		const range = versionOrRange || "latest";
+		const range = resolvedVersionOrRange || "latest";
 		const foundVersion = packument["dist-tags"]?.[range] || semver.maxSatisfying(versions, range);
 		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;
+		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 = join(ctx.userDataPath, "cache", "pacote");
 	const packageDir = join(baseDir, resolvedVersion);
-	if (options?.installDeps ? isPackageComplete(packageDir) && isDependenciesInstalledSync(packageDir) : isPackageComplete(packageDir)) 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 (!isPackageComplete(packageDir)) {
 			console.log(`[Fetcher] ${packageName}@${resolvedVersion}: Downloading to ${packageDir}...`);
+			const downloadStart = Date.now();
 			const tempDir = join(baseDir, `.tmp-${resolvedVersion}-${Math.random().toString(36).slice(2)}`);
 			await mkdir(tempDir, { recursive: true });
 			try {
@@ -8986,6 +9068,7 @@ async function fetchPackage(packageName, versionOrRange, options) {
 					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,
@@ -8994,8 +9077,15 @@ async function fetchPackage(packageName, versionOrRange, options) {
 				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,
@@ -9034,10 +9124,14 @@ 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 (isNodeJSComplete(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 (isNodeJSComplete(finalNodePath)) return finalNodePath;
 		const arch = process.arch === "x64" ? "x64" : process.arch === "arm64" ? "arm64" : "x86";
@@ -9049,9 +9143,12 @@ async function ensureNodeJS(context, version = DEFAULT_NODE_VERSION) {
 		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);
@@ -9076,6 +9173,7 @@ async function ensureNodeJS(context, version = DEFAULT_NODE_VERSION) {
 				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,
@@ -9086,6 +9184,7 @@ async function ensureNodeJS(context, version = DEFAULT_NODE_VERSION) {
 				force: true
 			}).catch(() => {});
 		}
+		console.log(`[Environment] Node.js set up complete in ${Date.now() - checkStart}ms`);
 		return finalNodePath;
 	});
 }
@@ -9093,16 +9192,22 @@ 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 (isDependenciesInstalledSync(packageDir)) {
 		console.log(`[Fetcher] ${packageName}: Dependencies already installed, skipping.`);
@@ -9113,18 +9218,21 @@ async function installDependencies(packageDir, packageName, options) {
 	try {
 		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}`);
 		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.`);
+		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}`);
@@ -9226,22 +9334,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;
 }
@@ -9275,50 +9388,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();
@@ -9404,26 +9473,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}`, options.context.releaseTag, {
+		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}`);
@@ -9432,32 +9530,142 @@ 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");
 	(async () => {
-		for (const id of DEFAULT_PLUGIN_IDS) {
-			sendStartupProgress(`Loading plugin: ${id}`);
-			const plugin = await loadPipelabPlugin(id, options);
-			if (plugin) {
-				registerPlugins([plugin]);
-				webSocketServer.broadcast("plugin:loaded", { plugin });
+		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 { setupConfigFile } = await import("./config-CEkOf95p.mjs");
+			const settingsPlugins = (await (await setupConfigFile("settings", { context: 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);
+		}
+		console.log(`[Plugins] Total plugins to load on startup:`, Array.from(pluginsToLoad.entries()));
+		for (const [packageName, version] of pluginsToLoad.entries()) {
+			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);
 			}
 		}
-		console.log("[Plugins] All default plugins loaded.");
+		console.log(`[Plugins] All startup plugins loaded in ${Date.now() - totalStart}ms.`);
 		sendStartupProgress("All plugins loaded.");
 		setTimeout(() => {
 			webSocketServer.broadcast("startup:progress", { type: "ready" });
@@ -9472,10 +9680,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)
@@ -9621,7 +9825,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: [],
@@ -9629,8 +9833,9 @@ const c3toSteamPreset = async () => {
 				triggers: [{
 					type: "event",
 					origin: {
-						pluginId: "system",
-						nodeId: "manual"
+						pluginId: "@pipelab/plugin-system",
+						nodeId: "manual",
+						version: "latest"
 					},
 					uid: "manual-start",
 					params: {}
@@ -9641,7 +9846,8 @@ const c3toSteamPreset = async () => {
 						type: "action",
 						origin: {
 							nodeId: "export-construct-project",
-							pluginId: "construct"
+							pluginId: "@pipelab/plugin-construct",
+							version: "latest"
 						},
 						params: {
 							file: {
@@ -9679,7 +9885,8 @@ const c3toSteamPreset = async () => {
 						type: "action",
 						origin: {
 							nodeId: "unzip-file-node",
-							pluginId: "filesystem"
+							pluginId: "@pipelab/plugin-filesystem",
+							version: "latest"
 						},
 						params: { file: {
 							editor: "editor",
@@ -9691,7 +9898,8 @@ const c3toSteamPreset = async () => {
 						type: "action",
 						origin: {
 							nodeId: "electron:package:v2",
-							pluginId: "electron"
+							pluginId: "@pipelab/plugin-electron",
+							version: "latest"
 						},
 						params: {
 							arch: {
@@ -9821,7 +10029,8 @@ const c3toSteamPreset = async () => {
 						type: "action",
 						origin: {
 							nodeId: "steam-upload",
-							pluginId: "steam"
+							pluginId: "@pipelab/plugin-steam",
+							version: "latest"
 						},
 						params: {
 							sdk: {
@@ -9864,7 +10073,8 @@ const c3toSteamPreset = async () => {
 						type: "action",
 						origin: {
 							nodeId: "fs:open-in-explorer",
-							pluginId: "filesystem"
+							pluginId: "@pipelab/plugin-filesystem",
+							version: "latest"
 						},
 						params: { path: {
 							editor: "editor",
@@ -9883,7 +10093,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: [],
@@ -9891,8 +10101,9 @@ const newProjectPreset = async () => {
 				triggers: [{
 					type: "event",
 					origin: {
-						pluginId: "system",
-						nodeId: "manual"
+						pluginId: "@pipelab/plugin-system",
+						nodeId: "manual",
+						version: "latest"
 					},
 					uid: "manual-start",
 					params: {}
@@ -9908,7 +10119,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: [],
@@ -9916,8 +10127,9 @@ const moreToCome = async () => {
 				triggers: [{
 					type: "event",
 					origin: {
-						pluginId: "system",
-						nodeId: "manual"
+						pluginId: "@pipelab/plugin-system",
+						nodeId: "manual",
+						version: "latest"
 					},
 					uid: "manual-start",
 					params: {}
@@ -9961,10 +10173,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 {
@@ -10346,6 +10554,241 @@ const registerSystemHandlers = (options) => {
 	});
 };
 //#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 { pluginIds, plugins } = value;
+		const { plugins: registeredPlugins, registerPlugins } = usePlugins();
+		const loaded = [];
+		const failed = [];
+		const pluginsToEnsure = /* @__PURE__ */ new Set();
+		if (Array.isArray(pluginIds)) {
+			for (const id of pluginIds) if (id) pluginsToEnsure.add(id);
+		}
+		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: {
+					loaded,
+					failed
+				}
+			}
+		});
+	});
+};
+//#endregion
 //#region src/handlers/index.ts
 const registerAllHandlers = async (options) => {
 	const context = options.context;
@@ -10357,6 +10800,7 @@ const registerAllHandlers = async (options) => {
 	registerAgentsHandlers(context);
 	registerAuthHandlers(context);
 	registerSystemHandlers(options);
+	registerPluginsHandlers(context);
 	const { registerPlugins } = usePlugins();
 	builtInPlugins({ context });
 };
@@ -52704,15 +53148,54 @@ 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: {
+		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"
+			} });
+			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"
 		} });
 		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"
+			} });
+			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 [];
@@ -52755,6 +53238,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, DEFAULT_NODE_VERSION, DEFAULT_PNPM_VERSION, PipelabContext, WebSocketServer, builtInPlugins, downloadFile, ensure, ensureNodeJS, ensurePNPM, executeGraphWithHistory, extractTarGz, extractZip, fetchLatestDesktopRelease, fetchLatestPackageRelease, fetchPackage, fetchPackageReleases, fetchPipelabAsset, fetchPipelabCli, fetchPipelabPlugin, findInstalledPlugins, generateTempFolder, getDefaultUserDataPath, getFinalPlugins, getFolderSize, getMigrator, handleActionExecute, isDev, loadCustomPlugin, loadPipelabPlugin, projectRoot, registerAgentsHandlers, registerAllHandlers, registerConfigHandlers, registerEngineHandlers, registerFsHandlers, registerHistoryHandlers, registerMigrationHandlers, registerShellHandlers, runPipelineCommand, runPnpm, runWithLiveLogs, sendStartupProgress, sendStartupReady, serveCommand, setupConfigFile, useAPI, usePluginAPI, webSocketServer, zipFolder };
 
 //# sourceMappingURL=index.mjs.map