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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipelab/core-node",
-  "version": "1.0.0-beta.14",
+  "version": "1.0.0-beta.15",
   "private": false,
   "description": "The Pipelab automation engine for Node.js",
   "license": "FSL-1.1-MIT",
@@ -40,8 +40,8 @@
     "type-fest": "4.39.0",
     "ws": "8.18.3",
     "yauzl": "2.10.0",
-    "@pipelab/constants": "1.0.0-beta.12",
-    "@pipelab/shared": "1.0.0-beta.10"
+    "@pipelab/constants": "1.0.0-beta.13",
+    "@pipelab/shared": "1.0.0-beta.11"
   },
   "devDependencies": {
     "@types/adm-zip": "0.5.7",
@@ -56,7 +56,7 @@
     "tsdown": "0.21.2",
     "typescript": "^5.0.0",
     "vitest": "3.1.4",
-    "@pipelab/tsconfig": "1.0.0-beta.10"
+    "@pipelab/tsconfig": "1.0.0-beta.11"
   },
   "scripts": {
     "build": "tsdown",

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

@@ -11,6 +11,7 @@ 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";
@@ -68,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;
@@ -118,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,
     );
@@ -160,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;
+      }
     }
   }