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

package/src/presets/test-c3-unzip.ts

@@ -7,7 +7,7 @@ export const testC3Unzip: PresetFn = async () => {
   const steamUpload = "steam-upload-node";
 
   const data: SavedFile = {
-    version: "3.0.0",
+    version: "5.0.0",
     name: "From Construct to Steam",
     description: "Export from Construct, package with Electron, then upload to Steam",
     variables: [],
@@ -16,8 +16,9 @@ export const testC3Unzip: PresetFn = async () => {
         {
           type: "event",
           origin: {
-            pluginId: "system",
+            pluginId: "@pipelab/plugin-system",
             nodeId: "manual",
+            version: "latest",
           },
           uid: "manual-start",
           params: {},
@@ -29,7 +30,8 @@ export const testC3Unzip: PresetFn = async () => {
           type: "action",
           origin: {
             nodeId: "export-construct-project",
-            pluginId: "construct",
+            pluginId: "@pipelab/plugin-construct",
+            version: "latest",
           },
           params: {
             file: {
@@ -59,7 +61,8 @@ export const testC3Unzip: PresetFn = async () => {
           type: "action",
           origin: {
             nodeId: "unzip-file-node",
-            pluginId: "filesystem",
+            pluginId: "@pipelab/plugin-filesystem",
+            version: "latest",
           },
           params: {
             file: {
@@ -73,15 +76,22 @@ export const testC3Unzip: PresetFn = async () => {
           type: "action",
           origin: {
             nodeId: "electron:package",
-            pluginId: "electron",
+            pluginId: "@pipelab/plugin-electron",
+            version: "latest",
           },
           params: {
             "input-folder": {
               editor: "editor",
               value: `steps['${unzipFileId}']['outputs']['output']`,
             },
-            arch: undefined,
-            platform: undefined,
+            arch: {
+              editor: "simple",
+              value: undefined,
+            },
+            platform: {
+              editor: "simple",
+              value: undefined,
+            },
           },
         },
         {
@@ -89,7 +99,8 @@ export const testC3Unzip: PresetFn = async () => {
           type: "action",
           origin: {
             nodeId: "steam-upload",
-            pluginId: "steam",
+            pluginId: "@pipelab/plugin-steam",
+            version: "latest",
           },
           params: {
             folder: {

package/src/runner.ts

@@ -1,12 +1,9 @@
 import { executeGraphWithHistory } from "./utils";
 import { setupConfigFile } from "./config";
-import { isDev, PipelabContext } from "./context";
+import { isDev, PipelabContext, CacheFolder } from "./context";
 import { readFile, access, writeFile, mkdir } from "node:fs/promises";
 import { resolve, isAbsolute, join, dirname } from "node:path";
-import { tmpdir } from "node:os";
 import { savedFileMigrator } from "@pipelab/shared";
-import type { AppConfig } from "@pipelab/shared";
-import { registerMigrationHandlers } from "./migrations";
 import { registerAllHandlers } from "./handlers/index";
 
 export interface RunOptions {
@@ -66,11 +63,8 @@ export async function runPipelineCommand(file: string, options: RunOptions, vers
   });
 
   await registerAllHandlers({ version, context });
-  registerMigrationHandlers(context);
 
-  const settings = await setupConfigFile<AppConfig>("settings", { context });
-  const config = await settings.getConfig();
-  const cachePath = join(context.userDataPath, "cache");
+  const cachePath = context.getCachePath(CacheFolder.Pipelines, effectivePipelineId);
   await mkdir(cachePath, { recursive: true });
 
   const abortController = new AbortController();

package/src/server.ts

@@ -9,10 +9,9 @@ import {
 import { getUiDevServerMissingWarning, uiDevPort } from "@pipelab/constants";
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { join } from "node:path";
 import http from "http";
+// @ts-expect-error serve-handler has no type definitions
 import handler from "serve-handler";
-import { registerMigrationHandlers } from "./migrations";
 
 export interface ServeOptions {
   port: string | number;
@@ -38,16 +37,58 @@ export const sendStartupReady = () => {
 
 export async function serveCommand(options: ServeOptions, version: string, _dirname: string) {
   if (!options.userData) throw new Error("userDataPath is required for serveCommand");
+  const releaseTag = version.includes("beta") ? "beta" : "latest";
   const context = new PipelabContext({
     userDataPath: options.userData,
+    releaseTag,
   });
 
   let rawAssetFolder: string | undefined;
   if (!isDev) {
-    rawAssetFolder = await fetchPipelabAsset("@pipelab/ui", "latest", { context });
+    rawAssetFolder = await fetchPipelabAsset("@pipelab/ui", releaseTag, { context });
   }
 
   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(`
@@ -73,6 +114,7 @@ export async function serveCommand(options: ServeOptions, version: string, _dirn
 
     return handler(request, response, {
       public: rawAssetFolder,
+      rewrites: [{ source: "/**", destination: "/index.html" }],
     });
   });
 
@@ -91,7 +133,6 @@ export async function serveCommand(options: ServeOptions, version: string, _dirn
     version,
     context,
   });
-  registerMigrationHandlers(context);
 
   sendStartupReady();
 

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,
 };
@@ -45,6 +35,7 @@ export type ActionRunnerData<ACTION extends Action> = {
   setMeta: (callback: (data: ACTION["meta"]) => ACTION["meta"]) => void;
   meta: ACTION["meta"];
   cwd: string;
+  /** @deprecated Use `context` instead to resolve sandboxed folders and binary paths. */
   paths: {
     cache: string;
     pnpm: string;
@@ -60,25 +51,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 +70,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

@@ -1,17 +1,7 @@
-import { mkdir, createWriteStream, createReadStream } from "node:fs";
+import { createWriteStream } from "node:fs";
 import { execa, Options, Subprocess } from "execa";
-import {
-  mkdir as mkdirP,
-  access,
-  writeFile,
-  realpath,
-  mkdtemp,
-  chmod,
-  stat,
-  readdir,
-} from "node:fs/promises";
+import { mkdir as mkdirP, writeFile, stat, readdir } from "node:fs/promises";
 import { join, dirname } from "node:path";
-import { tmpdir } from "node:os";
 import tar from "tar";
 import yauzl from "yauzl";
 import archiver from "archiver";
@@ -23,23 +13,15 @@ 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);
   }
 };
 
-/**
- * Generates a unique temporary folder.
- */
-export const generateTempFolder = async (base?: string) => {
-  const targetBase = base || tmpdir();
-  await mkdirP(targetBase, { recursive: true });
-  const realPath = await realpath(targetBase);
-  const tempFolder = await mkdtemp(join(realPath, "pipelab-"));
-  return tempFolder;
-};
-
 /**
  * Extracts a .tar.gz archive.
  */

package/src/utils/github.test.ts

@@ -0,0 +1,211 @@
+import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
+import {
+  fetchPackageReleases,
+  fetchLatestPackageRelease,
+  fetchLatestDesktopRelease,
+} from "./github";
+
+describe("GitHub Release Updates API", () => {
+  let fetchSpy: any;
+
+  beforeEach(() => {
+    fetchSpy = vi.spyOn(global, "fetch");
+    // Clean up environment variables
+    delete process.env.PIPELAB_OVERRIDE_RELEASE;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("fetchPackageReleases - returns empty array when git matching-refs fails", async () => {
+    fetchSpy.mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+      statusText: "Not Found",
+    } as any);
+
+    const releases = await fetchPackageReleases("@pipelab/app");
+    expect(releases).toEqual([]);
+    expect(fetchSpy).toHaveBeenCalledWith(
+      expect.stringContaining("matching-refs/tags/%40pipelab%2Fapp"),
+      expect.any(Object),
+    );
+  });
+
+  test("fetchPackageReleases - returns empty array when no tags match package", async () => {
+    fetchSpy.mockResolvedValueOnce({
+      ok: true,
+      json: async () => [],
+    } as any);
+
+    const releases = await fetchPackageReleases("@pipelab/app");
+    expect(releases).toEqual([]);
+  });
+
+  test("fetchPackageReleases - correctly filters prereleases when allowPrerelease is false", async () => {
+    // 1. mock matching refs
+    fetchSpy.mockResolvedValueOnce({
+      ok: true,
+      json: async () => [
+        { ref: "refs/tags/@pipelab/app@1.0.0-beta.1" },
+        { ref: "refs/tags/@pipelab/app@1.0.0" },
+      ],
+    } as any);
+
+    // 2. mock tag lookup for 1.0.0 (since 1.0.0-beta.1 is filtered out)
+    fetchSpy.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        tag_name: "@pipelab/app@1.0.0",
+        prerelease: false,
+        published_at: "2026-06-04T00:00:00Z",
+        html_url: "https://github.com/CynToolkit/pipelab/releases/tag/%40pipelab%2Fapp%401.0.0",
+        assets: [],
+      }),
+    } as any);
+
+    const releases = await fetchPackageReleases("@pipelab/app", { allowPrerelease: false });
+    expect(releases).toHaveLength(1);
+    expect(releases[0].tag_name).toBe("@pipelab/app@1.0.0");
+  });
+
+  test("fetchPackageReleases - includes prereleases when allowPrerelease is true", async () => {
+    // 1. mock matching refs
+    fetchSpy.mockResolvedValueOnce({
+      ok: true,
+      json: async () => [
+        { ref: "refs/tags/@pipelab/app@1.0.0-beta.1" },
+        { ref: "refs/tags/@pipelab/app@1.0.0" },
+      ],
+    } as any);
+
+    // 2. mock tag lookup for 1.0.0 (since sorting puts 1.0.0 first)
+    fetchSpy.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        tag_name: "@pipelab/app@1.0.0",
+        prerelease: false,
+        published_at: "2026-06-04T00:00:00Z",
+        html_url: "https://github.com/CynToolkit/pipelab/releases/tag/%40pipelab%2Fapp%401.0.0",
+        assets: [],
+      }),
+    } as any);
+
+    const releases = await fetchPackageReleases("@pipelab/app", { allowPrerelease: true });
+    expect(releases).toHaveLength(1);
+    expect(releases[0].tag_name).toBe("@pipelab/app@1.0.0");
+  });
+
+  test("fetchPackageReleases - handles tag that has no release (skips and falls back to older tag)", async () => {
+    // 1. mock matching refs
+    fetchSpy.mockResolvedValueOnce({
+      ok: true,
+      json: async () => [
+        { ref: "refs/tags/@pipelab/app@1.1.0" },
+        { ref: "refs/tags/@pipelab/app@1.0.0" },
+      ],
+    } as any);
+
+    // 2. mock tag lookup for 1.1.0 (returns 404 - no release yet, tag exists)
+    fetchSpy.mockResolvedValueOnce({
+      status: 404,
+      ok: false,
+      statusText: "Not Found",
+    } as any);
+
+    // 3. mock tag lookup for 1.0.0 (returns 200 - release exists)
+    fetchSpy.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        tag_name: "@pipelab/app@1.0.0",
+        prerelease: false,
+        published_at: "2026-06-04T00:00:00Z",
+        assets: [],
+      }),
+    } as any);
+
+    const releases = await fetchPackageReleases("@pipelab/app");
+    expect(releases).toHaveLength(1);
+    expect(releases[0].tag_name).toBe("@pipelab/app@1.0.0");
+  });
+
+  test("fetchPackageReleases - handles environment variable PIPELAB_OVERRIDE_RELEASE override", async () => {
+    process.env.PIPELAB_OVERRIDE_RELEASE = "1.2.3";
+
+    // Mock direct tag retrieval
+    fetchSpy.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        tag_name: "@pipelab/app@1.2.3",
+        prerelease: false,
+        published_at: "2026-06-04T00:00:00Z",
+        assets: [],
+      }),
+    } as any);
+
+    const releases = await fetchPackageReleases("@pipelab/app");
+    expect(releases).toHaveLength(1);
+    expect(releases[0].tag_name).toBe("@pipelab/app@1.2.3");
+    expect(fetchSpy).toHaveBeenCalledWith(
+      expect.stringContaining("releases/tags/%40pipelab%2Fapp%401.2.3"),
+      expect.any(Object),
+    );
+  });
+
+  test("fetchLatestPackageRelease - selects newest matching release", async () => {
+    // Mock matching refs
+    fetchSpy.mockResolvedValueOnce({
+      ok: true,
+      json: async () => [
+        { ref: "refs/tags/@pipelab/app@1.0.0" },
+        { ref: "refs/tags/@pipelab/app@2.0.0" },
+        { ref: "refs/tags/@pipelab/app@1.5.0" },
+      ],
+    } as any);
+
+    // Mock release lookup for 2.0.0 (since 2.0.0 is highest version)
+    fetchSpy.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        tag_name: "@pipelab/app@2.0.0",
+        prerelease: false,
+        published_at: "2026-06-04T00:00:00Z",
+        assets: [],
+      }),
+    } as any);
+
+    const latest = await fetchLatestPackageRelease("@pipelab/app");
+    expect(latest).not.toBeNull();
+    expect(latest?.tag_name).toBe("@pipelab/app@2.0.0");
+  });
+
+  test("fetchLatestDesktopRelease - queries the @pipelab/app package specifically", async () => {
+    // Mock matching refs
+    fetchSpy.mockResolvedValueOnce({
+      ok: true,
+      json: async () => [{ ref: "refs/tags/@pipelab/app@3.0.0" }],
+    } as any);
+
+    // Mock release lookup
+    fetchSpy.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        tag_name: "@pipelab/app@3.0.0",
+        prerelease: false,
+        published_at: "2026-06-04T00:00:00Z",
+        assets: [],
+      }),
+    } as any);
+
+    const latest = await fetchLatestDesktopRelease();
+    expect(latest).not.toBeNull();
+    expect(latest?.tag_name).toBe("@pipelab/app@3.0.0");
+  });
+});

package/src/utils/github.ts

@@ -25,30 +25,110 @@ 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",
+          },
+          signal: AbortSignal.timeout(10000),
+        },
+      );
+      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",
       },
+      signal: AbortSignal.timeout(10000),
     });
 
     if (!response.ok) {
       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",
+          },
+          signal: AbortSignal.timeout(10000),
+        },
+      );
+
+      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 [];