@pipelab/core-node 1.0.0-beta.11 → 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

@@ -112,7 +112,12 @@ 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 {
@@ -126,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);
@@ -145,7 +150,12 @@ export async function fetchPackage(
       `[Fetcher] ${packageName}: remote resolution failed (${Date.now() - resolveStart}ms), trying local fallback...`,
     );
     const fallbackStart = Date.now();
-    const fallbackVersion = await tryLocalFallback(versionOrRange, error, baseDir, packageName);
+    const fallbackVersion = await tryLocalFallback(
+      resolvedVersionOrRange,
+      error,
+      baseDir,
+      packageName,
+    );
     if (fallbackVersion) {
       resolvedVersion = fallbackVersion;
       console.log(
@@ -596,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,
-  };
-};

package/src/presets/loop.ts

@@ -1,65 +0,0 @@
-// @ts-nocheck
-
-import { PresetFn, SavedFile } from "@pipelab/shared";
-
-export const loopPreset: PresetFn = async () => {
-  const forId = "forId";
-  const arrayId = "arrayId";
-
-  const logStepId = "logStepId";
-  const logExitId = "logExitId";
-
-  const data: SavedFile = {
-    version: "1.0.0",
-    name: "Loop demo",
-    description: "Loop demo",
-    variables: [
-      {
-        id: arrayId,
-        description: "An array",
-        name: "Array",
-        type: "array",
-        of: "string",
-        value: [],
-      },
-    ],
-    canvas: {
-      blocks: [
-        {
-          type: "loop",
-          origin: {
-            pluginId: "system",
-            nodeId: "for",
-          },
-
-          params: {},
-          children: [
-            {
-              type: "action",
-              origin: {
-                pluginId: "system",
-                nodeId: "log",
-              },
-              params: {},
-              uid: logStepId,
-            },
-          ],
-          uid: forId,
-        },
-        {
-          type: "action",
-          origin: {
-            pluginId: "system",
-            nodeId: "log",
-          },
-          params: {},
-          uid: logExitId,
-        },
-      ],
-    },
-  };
-
-  return {
-    data,
-  };
-};