@pipelab/core-node 1.0.0-beta.13 → 1.0.0-beta.15

package/src/utils/github.test.ts

@@ -0,0 +1,213 @@
+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/remote.test.ts

@@ -0,0 +1,200 @@
+import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
+import { isOnline, fetchPackage, fetchPipelabPlugin } from "./remote";
+import dns from "node:dns/promises";
+import pacote from "pacote";
+import { vol } from "memfs";
+import { PipelabContext } from "../context";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { existsSync } from "node:fs";
+
+vi.mock("node:dns/promises", () => ({
+  default: {
+    lookup: vi.fn(),
+  },
+}));
+
+vi.mock("node:fs", async () => {
+  const memfs = await import("memfs");
+  return {
+    ...memfs.fs,
+    default: memfs.fs,
+    existsSync: (p: string) => memfs.fs.existsSync(p),
+  };
+});
+
+vi.mock("node:fs/promises", async () => {
+  const memfs = await import("memfs");
+  return {
+    ...memfs.fs.promises,
+    default: memfs.fs.promises,
+  };
+});
+
+vi.mock("pacote", () => ({
+  default: {
+    packument: vi.fn(),
+    extract: vi.fn(),
+  },
+}));
+
+describe("remote utilities & offline mode", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vol.reset();
+    vi.restoreAllMocks();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  test("isOnline returns true when dns.lookup succeeds", async () => {
+    vi.spyOn(dns, "lookup").mockResolvedValue({ address: "1.2.3.4", family: 4 } as any);
+    const online = await isOnline();
+    expect(online).toBe(true);
+  });
+
+  test("isOnline returns false when dns.lookup throws", async () => {
+    vi.advanceTimersByTime(11000); // Bypass 10s caching
+    vi.spyOn(dns, "lookup").mockRejectedValue(new Error("ENOTFOUND"));
+    const online = await isOnline();
+    expect(online).toBe(false);
+  });
+
+  test("fetchPackage falls back to local packages when offline", async () => {
+    // 1. Force offline status
+    vi.advanceTimersByTime(11000); // Bypass 10s caching
+    vi.spyOn(dns, "lookup").mockRejectedValue(new Error("Offline"));
+
+    const context = new PipelabContext({ userDataPath: "/tmp/pipelab-test-remote" });
+    const packageName = "my-plugin";
+    const packageBaseDir = context.getPackagesPath(packageName);
+    const cachedVersionDir = path.join(packageBaseDir, "1.0.0");
+
+    await fs.mkdir(cachedVersionDir, { recursive: true });
+    await fs.writeFile(
+      path.join(cachedVersionDir, "package.json"),
+      JSON.stringify({
+        name: packageName,
+        version: "1.0.0",
+        main: "index.mjs",
+      }),
+    );
+
+    // 2. Call fetchPackage
+    const result = await fetchPackage(packageName, "latest", { context });
+
+    // 3. Verify it resolved to local cached version without calling pacote
+    expect(result.resolvedVersion).toBe("1.0.0");
+    expect(result.packageDir).toBe(cachedVersionDir);
+    expect(pacote.packument).not.toHaveBeenCalled();
+  });
+
+  test("fetchPipelabPlugin maps latest to releaseTag for official plugins", async () => {
+    vi.advanceTimersByTime(30000); // Bypass 10s caching
+    const context = new PipelabContext({ userDataPath: "/tmp/pipelab-test-remote", releaseTag: "beta" });
+    const pluginName = "@pipelab/plugin-poki";
+    const packageBaseDir = context.getPackagesPath(pluginName);
+    const cachedVersionDir = path.join(packageBaseDir, "1.0.0-beta.15");
+
+    vi.spyOn(dns, "lookup").mockResolvedValue({ address: "1.2.3.4", family: 4 } as any);
+    
+    vi.mocked(pacote.packument).mockResolvedValue({
+      name: pluginName,
+      versions: {
+        "1.0.0-beta.15": {},
+      },
+      "dist-tags": {
+        beta: "1.0.0-beta.15",
+      },
+    } as any);
+
+    await fs.mkdir(cachedVersionDir, { recursive: true });
+    await fs.writeFile(
+      path.join(cachedVersionDir, "package.json"),
+      JSON.stringify({
+        name: pluginName,
+        version: "1.0.0-beta.15",
+        main: "dist/index.mjs",
+      }),
+    );
+
+    const result = await fetchPipelabPlugin(pluginName, "latest", { context });
+
+    expect(pacote.packument).toHaveBeenCalledWith(pluginName, expect.any(Object));
+    expect(result.packageDir).toBe(cachedVersionDir);
+  });
+
+  test("fetchPipelabPlugin maps latest to releaseTag for custom plugins and falls back to latest if tag is missing", async () => {
+    vi.advanceTimersByTime(40000); // Bypass 10s caching
+    const context = new PipelabContext({ userDataPath: "/tmp/pipelab-test-remote-custom", releaseTag: "beta" });
+    const pluginName = "custom-cool-plugin";
+    const packageBaseDir = context.getPackagesPath(pluginName);
+    const cachedVersionDir = path.join(packageBaseDir, "2.0.0");
+
+    vi.spyOn(dns, "lookup").mockResolvedValue({ address: "1.2.3.4", family: 4 } as any);
+    
+    vi.mocked(pacote.packument).mockResolvedValue({
+      name: pluginName,
+      versions: {
+        "2.0.0": {},
+      },
+      "dist-tags": {
+        latest: "2.0.0",
+      },
+    } as any);
+
+    await fs.mkdir(cachedVersionDir, { recursive: true });
+    await fs.writeFile(
+      path.join(cachedVersionDir, "package.json"),
+      JSON.stringify({
+        name: pluginName,
+        version: "2.0.0",
+        main: "dist/index.mjs",
+      }),
+    );
+
+    const result = await fetchPipelabPlugin(pluginName, "latest", { context });
+
+    expect(pacote.packument).toHaveBeenCalledWith(pluginName, expect.any(Object));
+    expect(result.packageDir).toBe(cachedVersionDir);
+  });
+
+  test("fetchPipelabPlugin maps latest to releaseTag for custom plugins and falls back to latest if beta is stale", async () => {
+    vi.advanceTimersByTime(50000); // Bypass 10s caching
+    const context = new PipelabContext({ userDataPath: "/tmp/pipelab-test-remote-stale", releaseTag: "beta" });
+    const pluginName = "stale-beta-plugin";
+    const packageBaseDir = context.getPackagesPath(pluginName);
+    const cachedVersionDir = path.join(packageBaseDir, "2.0.0");
+
+    vi.spyOn(dns, "lookup").mockResolvedValue({ address: "1.2.3.4", family: 4 } as any);
+    
+    vi.mocked(pacote.packument).mockResolvedValue({
+      name: pluginName,
+      versions: {
+        "1.0.0-beta.1": {},
+        "2.0.0": {},
+      },
+      "dist-tags": {
+        beta: "1.0.0-beta.1",
+        latest: "2.0.0",
+      },
+    } as any);
+
+    await fs.mkdir(cachedVersionDir, { recursive: true });
+    await fs.writeFile(
+      path.join(cachedVersionDir, "package.json"),
+      JSON.stringify({
+        name: pluginName,
+        version: "2.0.0",
+        main: "dist/index.mjs",
+      }),
+    );
+
+    const result = await fetchPipelabPlugin(pluginName, "latest", { context });
+
+    expect(pacote.packument).toHaveBeenCalledWith(pluginName, expect.any(Object));
+    expect(result.packageDir).toBe(cachedVersionDir);
+  });
+});

package/src/utils/remote.ts

@@ -1,5 +1,4 @@
 import { dirname, delimiter, join } from "node:path";
-import { tmpdir } from "node:os";
 import {
   mkdir,
   readdir,
@@ -12,15 +11,15 @@ import {
   rename,
 } from "node:fs/promises";
 import { existsSync, constants, statSync, readdirSync } from "node:fs";
+import dns from "node:dns/promises";
 import pacote from "pacote";
 import semver from "semver";
 import { isDev, projectRoot, PipelabContext } from "../context";
 import { execa } from "execa";
 import { sendStartupProgress } from "../server";
-import { downloadFile, extractZip, extractTarGz, generateTempFolder } from "./fs-extras";
+import { downloadFile, extractZip, extractTarGz } from "./fs-extras";
 
-export const DEFAULT_NODE_VERSION = "24.14.1";
-export const DEFAULT_PNPM_VERSION = "10.12.0";
+import { DEFAULT_NODE_VERSION, DEFAULT_PNPM_VERSION } from "@pipelab/constants";
 
 function isPackageComplete(packageDir: string): boolean {
   return existsSync(join(packageDir, "package.json"));
@@ -70,6 +69,27 @@ async function withLock<T>(key: string, fn: () => Promise<T>): Promise<T> {
   return promise;
 }
 
+let isOnlineCached: boolean | null = null;
+let lastCheckTime = 0;
+
+export async function isOnline(): Promise<boolean> {
+  const now = Date.now();
+  if (isOnlineCached !== null && now - lastCheckTime < 10000) {
+    return isOnlineCached;
+  }
+  try {
+    await Promise.race([
+      dns.lookup("registry.npmjs.org"),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), 1500)),
+    ]);
+    isOnlineCached = true;
+  } catch {
+    isOnlineCached = false;
+  }
+  lastCheckTime = now;
+  return isOnlineCached;
+}
+
 export type FetchOptions = {
   installDeps?: boolean;
   signal?: AbortSignal;
@@ -120,39 +140,15 @@ export async function fetchPackage(
   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
-    const cachePath = join(ctx.userDataPath, "cache", "pacote");
-    let packumentPromise = packumentRequests.get(packageName);
-    if (!packumentPromise) {
-      packumentPromise = pacote.packument(packageName, { cache: cachePath });
-      packumentRequests.set(packageName, packumentPromise);
-    }
-
-    const packument = await packumentPromise;
-    const versions = Object.keys(packument.versions);
-    const range = resolvedVersionOrRange || "latest";
-
-    // Prioritize tags (like 'latest', 'beta', etc.) over semver ranges
-    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 (${Date.now() - resolveStart}ms)`,
-    );
-  } catch (error) {
+  const online = await isOnline();
+  if (!online) {
     console.warn(
-      `[Fetcher] ${packageName}: remote resolution failed (${Date.now() - resolveStart}ms), trying local fallback...`,
+      `[Fetcher] ${packageName}: offline mode detected (${Date.now() - resolveStart}ms), trying local fallback...`,
     );
     const fallbackStart = Date.now();
     const fallbackVersion = await tryLocalFallback(
       resolvedVersionOrRange,
-      error,
+      new Error("Offline"),
       baseDir,
       packageName,
     );
@@ -162,7 +158,72 @@ export async function fetchPackage(
         `[Fetcher] ${packageName}: Resolved to local fallback ${resolvedVersion} (${Date.now() - fallbackStart}ms)`,
       );
     } else {
-      throw error;
+      throw new Error(`Offline and no local fallback version available for ${packageName}`);
+    }
+  } else {
+    try {
+      // 1. Resolve version/range using npm with session-wide memoization and disk cache
+      const cachePath = join(ctx.userDataPath, "cache", "pacote");
+      let packumentPromise = packumentRequests.get(packageName);
+      if (!packumentPromise) {
+        packumentPromise = pacote.packument(packageName, { cache: cachePath });
+        packumentRequests.set(packageName, packumentPromise);
+      }
+
+      const packument = await packumentPromise;
+      const versions = Object.keys(packument.versions);
+      const range = resolvedVersionOrRange || "latest";
+
+      // Prioritize tags (like 'latest', 'beta', etc.) over semver ranges
+      let foundVersion = packument["dist-tags"]?.[range] || semver.maxSatisfying(versions, range);
+
+      // If we are in a non-latest releaseTag channel (like "beta" or "dev"),
+      // and we are resolving "latest", we prefer the releaseTag version if it exists
+      // and is newer than (or equal to) the latest stable version.
+      if (range === "latest" && ctx.releaseTag && ctx.releaseTag !== "latest") {
+        const releaseTagVersion = packument["dist-tags"]?.[ctx.releaseTag];
+        if (releaseTagVersion && semver.valid(releaseTagVersion)) {
+          if (!foundVersion || (semver.valid(foundVersion) && semver.gte(releaseTagVersion, foundVersion))) {
+            console.log(
+              `[Fetcher] Using release tag "${ctx.releaseTag}" (${releaseTagVersion}) instead of "latest" (${foundVersion || "none"}) for ${packageName}`,
+            );
+            foundVersion = releaseTagVersion;
+          } else if (foundVersion) {
+            console.warn(
+              `[Fetcher] Tag "${ctx.releaseTag}" (${releaseTagVersion}) is older than "latest" (${foundVersion}) for ${packageName}, keeping "latest"`,
+            );
+          }
+        }
+      }
+
+      if (!foundVersion) {
+        throw new Error(
+          `Package ${packageName}@${range} not found on npm (available tags: ${Object.keys(packument["dist-tags"] || {}).join(", ")})`,
+        );
+      }
+      resolvedVersion = foundVersion;
+      console.log(
+        `[Fetcher] ${packageName}: Resolved to v${resolvedVersion} via npm (${Date.now() - resolveStart}ms)`,
+      );
+    } catch (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;
+      }
     }
   }
 
@@ -324,7 +385,7 @@ export async function ensureNodeJS(context: PipelabContext, version = DEFAULT_NO
 
     const fileName = `node-v${version}-${downloadPlatform}-${arch}.${extension}`;
     const downloadUrl = `https://nodejs.org/dist/v${version}/${fileName}`;
-    const tempDir = await generateTempFolder(tmpdir());
+    const tempDir = await context.createTempFolder("node-download-");
     const archivePath = join(tempDir, fileName);
 
     sendStartupProgress(`Downloading Node.js v${version}...`);

package/src/utils.ts

@@ -18,7 +18,7 @@ import { constants, existsSync } from "node:fs";
 import { handleActionExecute } from "./handler-func";
 import { BuildHistoryStorage } from "./handlers/build-history";
 
-import { ensure, generateTempFolder, extractTarGz, extractZip, zipFolder } from "./utils/fs-extras";
+import { ensure, extractTarGz, extractZip, zipFolder } from "./utils/fs-extras";
 import { fetchPipelabAsset } from "./utils/remote";
 import { loadPipelabPlugin } from "./plugins-registry";
 import { setupConfigFile } from "./config";
@@ -120,7 +120,7 @@ export const executeGraphWithHistory = async ({
   }
 
   const logs: any[] = [];
-  const sandboxPath = await generateTempFolder(cachePath);
+  const sandboxPath = await ctx.createTempFolder("pipeline-sandbox-");
   const { logger } = useLogger();
   let completedSteps = 0;
   let failedSteps = 0;