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

package/src/server.ts

@@ -50,6 +50,46 @@ export async function serveCommand(options: ServeOptions, version: string, _dirn
   }
 
   const server = http.createServer(async (request, response) => {
+    // Serve local media files securely via HTTP
+    if (request.url?.startsWith("/media-file/")) {
+      const prefix = "/media-file/";
+      const encodedPath = request.url.substring(prefix.length);
+      const filePath = decodeURIComponent(encodedPath);
+      // Strip leading slash on Windows if followed by a drive letter (e.g. /C:/...)
+      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(`

package/src/types/runner.ts

@@ -2,32 +2,22 @@ import type { BrowserWindow } from "electron";
 import type { PipelabContext } from "../context";
 import type {
   Action,
-  Condition,
-  Loop,
   Expression,
   Event,
   SetOutputActionFn,
-  SetOutputLoopFn,
   SetOutputExpressionFn,
   ExtractInputsFromAction,
-  ExtractInputsFromCondition,
-  ExtractInputsFromLoop,
   ExtractInputsFromEvent,
   ExtractInputsFromExpression,
 } from "@pipelab/shared";
 
 export type {
   Action,
-  Condition,
-  Loop,
   Expression,
   Event,
   SetOutputActionFn,
-  SetOutputLoopFn,
   SetOutputExpressionFn,
   ExtractInputsFromAction,
-  ExtractInputsFromCondition,
-  ExtractInputsFromLoop,
   ExtractInputsFromEvent,
   ExtractInputsFromExpression,
 };
@@ -60,25 +50,6 @@ export type ActionRunnerData<ACTION extends Action> = {
 
 export type ActionRunner<ACTION extends Action> = (data: ActionRunnerData<ACTION>) => Promise<void>;
 
-export type ConditionRunner<CONDITION extends Condition> = (data: {
-  log: typeof console.log;
-  inputs: ExtractInputsFromCondition<CONDITION>;
-  setMeta: (callback: (data: CONDITION["meta"]) => CONDITION["meta"]) => void;
-  meta: CONDITION["meta"];
-  cwd: string;
-  context: PipelabContext;
-}) => Promise<boolean>;
-
-export type LoopRunner<LOOP extends Loop> = (data: {
-  log: typeof console.log;
-  setOutput: SetOutputLoopFn<LOOP>;
-  inputs: ExtractInputsFromLoop<LOOP>;
-  setMeta: (callback: (data: LOOP["meta"]) => LOOP["meta"]) => void;
-  meta: LOOP["meta"];
-  cwd: string;
-  context: PipelabContext;
-}) => Promise<"step" | "exit">;
-
 export type ExpressionRunner<EXPRESSION extends Expression> = (data: {
   log: typeof console.log;
   setOutput: SetOutputExpressionFn<EXPRESSION>;
@@ -98,4 +69,4 @@ export type EventRunner<EVENT extends Event> = (data: {
   context: PipelabContext;
 }) => Promise<void>;
 
-export type Runner = ActionRunner<any> | LoopRunner<any> | EventRunner<any> | ConditionRunner<any>;
+export type Runner = ActionRunner<any> | EventRunner<any>;

package/src/utils/fs-extras.ts

@@ -23,7 +23,10 @@ import { pipeline } from "node:stream/promises";
 export const ensure = async (filesPath: string, defaultContent = "{}") => {
   await mkdirP(dirname(filesPath), { recursive: true });
   try {
-    await access(filesPath);
+    const s = await stat(filesPath);
+    if (s.size === 0) {
+      await writeFile(filesPath, defaultContent);
+    }
   } catch {
     await writeFile(filesPath, defaultContent);
   }

package/src/utils/github.ts

@@ -25,12 +25,32 @@ export async function fetchPackageReleases(
   options: FetchReleaseOptions = {},
 ): Promise<GitHubRelease[]> {
   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, {
+    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) {
+        const release: GitHubRelease = await response.json();
+        return [release];
+      }
+      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",
@@ -41,14 +61,71 @@ export async function fetchPackageReleases(
       throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
     }
 
-    const releases: GitHubRelease[] = await response.json();
+    const refs = await response.json();
+    if (!Array.isArray(refs)) {
+      return [];
+    }
 
-    // Filter for releases that follow the {packageName}@X.Y.Z tag pattern
-    const packageReleases = releases
-      .filter((r) => r.tag_name.startsWith(`${packageName}@`))
-      .filter((r) => allowPrerelease || !r.prerelease);
+    // Extract tags matching the packageName@ pattern
+    const matchingTags = refs
+      .map((r: any) => r.ref.replace("refs/tags/", ""))
+      .filter((tag: string) => tag.startsWith(`${packageName}@`));
+
+    // Filter by semver and prerelease options
+    const filteredTags = matchingTags.filter((tag: string) => {
+      const version = tag.split("@").pop();
+      if (!version || !semver.valid(version)) {
+        return false;
+      }
+      const isPrerelease = semver.prerelease(version) !== null;
+      return allowPrerelease || !isPrerelease;
+    });
 
-    return packageReleases;
+    if (filteredTags.length === 0) {
+      return [];
+    }
+
+    // Sort by version (newest/highest first)
+    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);
+    });
+
+    // Walk tags from newest to oldest, skipping any that have no GitHub Release attached.
+    // A bare git tag (no release) returns 404 from the releases/tags endpoint.
+    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) {
+        // Tag exists but no Release was published for it — skip and try older tag
+        console.warn(`[GitHub] Tag "${tag}" has no associated Release, skipping.`);
+        continue;
+      }
+
+      if (!releaseResponse.ok) {
+        throw new Error(
+          `GitHub API error: ${releaseResponse.status} ${releaseResponse.statusText}`,
+        );
+      }
+
+      const release: GitHubRelease = await releaseResponse.json();
+      return [release];
+    }
+
+    // All tags were bare (no Release found)
+    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 [];

package/src/utils/remote.ts

@@ -1,6 +1,16 @@
 import { dirname, delimiter, join } from "node:path";
 import { tmpdir } from "node:os";
-import { mkdir, readdir, readFile, writeFile, access, chmod, rm, cp, rename } from "node:fs/promises";
+import {
+  mkdir,
+  readdir,
+  readFile,
+  writeFile,
+  access,
+  chmod,
+  rm,
+  cp,
+  rename,
+} from "node:fs/promises";
 import { existsSync, constants, statSync, readdirSync } from "node:fs";
 import pacote from "pacote";
 import semver from "semver";
@@ -80,12 +90,16 @@ export async function fetchPackage(
   isLocal?: boolean;
   entryPoint?: string;
 }> {
+  const start = Date.now();
   // 0. Check for local monorepo package in development
   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",
@@ -98,7 +112,13 @@ export async function fetchPackage(
   const baseDir = ctx.getPackagesPath(packageName);
   let resolvedVersion: string;
 
-  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 {
     // 1. Resolve version/range using npm with session-wide memoization and disk cache
@@ -111,7 +131,7 @@ export async function fetchPackage(
 
     const packument = await packumentPromise;
     const versions = Object.keys(packument.versions);
-    const range = versionOrRange || "latest";
+    const range = resolvedVersionOrRange || "latest";
 
     // Prioritize tags (like 'latest', 'beta', etc.) over semver ranges
     const foundVersion = packument["dist-tags"]?.[range] || semver.maxSatisfying(versions, range);
@@ -122,12 +142,25 @@ export async function fetchPackage(
       );
     }
     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);
+    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;
     }
@@ -136,12 +169,17 @@ export async function fetchPackage(
   const cachePath = join(ctx.userDataPath, "cache", "pacote");
   const packageDir = join(baseDir, resolvedVersion);
 
+  const checkStart = Date.now();
   // If the package already exists and we don't need to install dependencies (or they are already installed), return immediately
   const isInstalled = options?.installDeps
-    ? (isPackageComplete(packageDir) && isDependenciesInstalledSync(packageDir))
+    ? 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 };
   }
 
@@ -149,8 +187,12 @@ export async function fetchPackage(
   return withLock(lockKey, async () => {
     if (!isPackageComplete(packageDir)) {
       console.log(`[Fetcher] ${packageName}@${resolvedVersion}: Downloading to ${packageDir}...`);
-      
-      const tempDir = join(baseDir, `.tmp-${resolvedVersion}-${Math.random().toString(36).slice(2)}`);
+      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, {
@@ -175,6 +217,9 @@ export async function fetchPackage(
             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;
@@ -182,12 +227,23 @@ export async function fetchPackage(
     }
 
     // 2. Resolve entry point from package.json for downloaded package
+    const entryStart = Date.now();
     const entryPoint = await resolveEntryPoint(packageDir, packageName);
+    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, entryPoint };
   });
 }
@@ -245,11 +301,15 @@ export async function runPnpm(
  * Installs a specific version of Node.js if not already present.
  */
 export async function ensureNodeJS(context: PipelabContext, 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)) {
+    console.log(
+      `[Environment] Node.js check took ${Date.now() - checkStart}ms (found at ${finalNodePath})`,
+    );
     return finalNodePath;
   }
 
@@ -269,10 +329,13 @@ export async function ensureNodeJS(context: PipelabContext, version = DEFAULT_NO
 
     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 });
 
@@ -290,7 +353,10 @@ export async function ensureNodeJS(context: PipelabContext, version = DEFAULT_NO
     const parentDir = dirname(nodeDir);
     await mkdir(parentDir, { recursive: true });
 
-    const tempNodeDir = join(parentDir, `.tmp-node-${version}-${Math.random().toString(36).slice(2)}`);
+    const tempNodeDir = join(
+      parentDir,
+      `.tmp-node-${version}-${Math.random().toString(36).slice(2)}`,
+    );
     await mkdir(tempNodeDir, { recursive: true });
 
     try {
@@ -313,11 +379,13 @@ export async function ensureNodeJS(context: PipelabContext, version = DEFAULT_NO
           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;
   });
 }
@@ -326,10 +394,14 @@ export async function ensureNodeJS(context: PipelabContext, version = DEFAULT_NO
  * Installs the PNPM package from npm if not already present.
  */
 export async function ensurePNPM(context: PipelabContext, version = DEFAULT_PNPM_VERSION) {
+  const checkStart = Date.now();
   const pnpmDir = context.getPackagesPath("pnpm", version);
   const pnpmPath = join(pnpmDir, "bin", "pnpm.cjs");
 
   if (existsSync(pnpmPath)) {
+    console.log(
+      `[Environment] PNPM check took ${Date.now() - checkStart}ms (found at ${pnpmPath})`,
+    );
     return pnpmPath;
   }
 
@@ -340,11 +412,13 @@ export async function ensurePNPM(context: PipelabContext, version = DEFAULT_PNPM
     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: string, packageName: string, options: FetchOptions) {
+  const start = Date.now();
   const nodeModulesPath = join(packageDir, "node_modules");
 
   if (isDependenciesInstalledSync(packageDir)) {
@@ -359,12 +433,14 @@ async function installDependencies(packageDir: string, packageName: string, opti
   try {
     // Copy package.json to tempDir so pnpm can install dependencies
     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}`);
 
@@ -373,8 +449,11 @@ async function installDependencies(packageDir: string, packageName: string, opti
     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: any) {
     console.error(
       `[Fetcher] ${packageName}: CRITICAL ERROR during dependency installation: ${err.message}`,
@@ -527,30 +606,42 @@ async function crawlMonorepoPackages(): Promise<Record<string, string>> {
   return cache;
 }
 
-async function findLatestLocalVersion(baseDir: string): Promise<string | null> {
+async function tryLocalFallback(
+  versionOrRange: string | undefined,
+  _error: unknown,
+  baseDir: string,
+  logPrefix: string,
+): Promise<string | null> {
   if (!existsSync(baseDir)) return null;
   try {
     const entries = await readdir(baseDir, { withFileTypes: true });
-    const versions = entries
+    const localVersions = entries
       .filter((e) => e.isDirectory() || e.isSymbolicLink())
       .map((e) => e.name)
-      .sort((a, b) => b.localeCompare(a, undefined, { numeric: true, sensitivity: "base" }));
-    return versions[0] || null;
-  } catch {
-    return null;
-  }
-}
+      .filter((name) => !!semver.valid(name));
 
-async function tryLocalFallback(
-  _version: string | undefined,
-  _error: unknown,
-  baseDir: string,
-  logPrefix: string,
-): Promise<string | null> {
-  const latestLocal = await findLatestLocalVersion(baseDir);
-  if (latestLocal) {
-    console.info(`[Fetcher] ${logPrefix}: Using locally cached version: ${latestLocal}`);
-    return latestLocal;
+    if (localVersions.length === 0) return null;
+
+    const range = versionOrRange || "latest";
+
+    if (range === "latest") {
+      const sorted = localVersions.sort((a, b) => semver.rcompare(a, b));
+      const latestLocal = sorted[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;
 }

package/src/utils.ts

@@ -1,24 +1,27 @@
 import { nanoid } from "nanoid";
-import { usePlugins } from "@pipelab/shared";
-import { RendererPluginDefinition } from "@pipelab/shared";
+import {
+  usePlugins,
+  RendererPluginDefinition,
+  processGraph,
+  useLogger,
+  BuildHistoryEntry,
+  Variable,
+  AppConfig,
+  transformUrl,
+} from "@pipelab/shared";
 import { downloadFile, DownloadHooks } from "./utils/fs-extras";
 import { access, chmod, mkdir, rm, writeFile, readdir, cp } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { isDev, projectRoot, PipelabContext } from "./context";
 import { constants, existsSync } from "node:fs";
-import { processGraph } from "@pipelab/shared";
 import { handleActionExecute } from "./handler-func";
-import { useLogger } from "@pipelab/shared";
 import { BuildHistoryStorage } from "./handlers/build-history";
-import type { BuildHistoryEntry } from "@pipelab/shared";
-import type { Variable } from "@pipelab/shared";
 
 import { ensure, generateTempFolder, extractTarGz, extractZip, zipFolder } from "./utils/fs-extras";
 import { fetchPipelabAsset } from "./utils/remote";
 import { loadPipelabPlugin } from "./plugins-registry";
 import { setupConfigFile } from "./config";
-import { AppConfig } from "@pipelab/shared";
 
 export const getFinalPlugins = () => {
   const { plugins } = usePlugins();
@@ -29,13 +32,6 @@ export const getFinalPlugins = () => {
   for (const plugin of plugins.value) {
     const finalNodes = [];
 
-    const transformUrl = (url: string) => {
-      if (url.startsWith("file://")) {
-        return url.replace("file://", "media://");
-      }
-      return url;
-    };
-
     const finalIcon =
       plugin.icon?.type === "image"
         ? {

package/src/presets/if.ts

@@ -1,69 +0,0 @@
-// @ts-nocheck
-import { PresetFn, SavedFile } from "@pipelab/shared";
-
-export const ifPreset: PresetFn = async () => {
-  const branchId = "branchId";
-  const logOkId = "logOkId";
-  const logKoId = "logKoId";
-  const booleanId = "booleanId";
-
-  const data: SavedFile = {
-    version: "1.0.0",
-    name: "Condition demo",
-    description: "Condition demo",
-    variables: [
-      {
-        type: "boolean",
-        id: booleanId,
-        description: "The value of the conditon",
-        name: "Value",
-        value: true,
-      },
-    ],
-    canvas: {
-      blocks: [
-        {
-          type: "condition",
-          origin: {
-            pluginId: "system",
-            nodeId: "branch",
-          },
-          uid: branchId,
-          params: {
-            condition: "",
-          },
-          branchTrue: [
-            {
-              type: "action",
-              origin: {
-                pluginId: "system",
-                nodeId: "log",
-              },
-              uid: logOkId,
-              params: {
-                text: "OK",
-              },
-            },
-          ],
-          branchFalse: [
-            {
-              type: "action",
-              origin: {
-                pluginId: "system",
-                nodeId: "log",
-              },
-              uid: logKoId,
-              params: {
-                text: "KO",
-              },
-            },
-          ],
-        },
-      ],
-    },
-  };
-
-  return {
-    data,
-  };
-};