@rudderhq/cli 0.2.8-canary.1 → 0.2.8-canary.2

package/dist/index.js

@@ -6449,6 +6449,7 @@ import { homedir, tmpdir } from "node:os";
 import path11 from "node:path";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
+import { clearTimeout as clearTimeout2, setTimeout as setTimeout2 } from "node:timers";
 import { setTimeout as delay } from "node:timers/promises";
 import * as p13 from "@clack/prompts";
 import pc8 from "picocolors";
@@ -6693,7 +6694,7 @@ function compareStableSemver(a, b) {
 }
 async function fetchLatestCliVersion() {
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 2e3);
+  const timeout = setTimeout2(() => controller.abort(), 2e3);
   try {
     const response = await fetch(CLI_REGISTRY_LATEST_URL, {
       signal: controller.signal,
@@ -6705,7 +6706,7 @@ async function fetchLatestCliVersion() {
   } catch {
     return null;
   } finally {
-    clearTimeout(timeout);
+    clearTimeout2(timeout);
   }
 }
 async function getCliUpdateNotice(currentVersion) {
@@ -6723,6 +6724,9 @@ function resolveDesktopReleaseTag(version) {
     `Desktop release lookup requires a release version like 0.1.0 or 0.1.0-canary.0. Received ${version}.`
   );
 }
+function isExactRuntimePackageSpec(version, packageSpec) {
+  return version !== "latest" && packageSpec === resolveRuntimePackageSpec(version);
+}
 function resolveDesktopAssetTarget(platform = process.platform, arch = process.arch) {
   if (platform === "darwin") {
     if (arch !== "x64" && arch !== "arm64") {
@@ -6782,6 +6786,7 @@ function scoreDesktopAsset(asset, target) {
   const expectedExtension = target.extension.toLowerCase();
   if (!normalized.endsWith(expectedExtension.toLowerCase())) return -1;
   if (normalized.includes("blockmap") || normalized.includes("shasum")) return -1;
+  if (normalized.includes("shell")) return -1;
   let score = 1;
   if (normalized.includes("rudder")) score += 2;
   if (normalized.includes(target.platform)) score += 4;
@@ -6808,18 +6813,77 @@ function selectDesktopAsset(assets, target) {
   const exactArch = equallyGood.find((item) => normalizeAssetName(item.asset.name).includes(target.arch));
   return exactArch?.asset ?? best.asset;
 }
+function selectDesktopShellAsset(assets, target) {
+  if (!resolveDesktopShellAssetName("", target)) return null;
+  const scored = assets.map((asset) => {
+    const normalized = normalizeAssetName(asset.name);
+    if (!normalized.endsWith(".zip")) return { asset, score: -1 };
+    if (!normalized.includes("shell")) return { asset, score: -1 };
+    if (!normalized.includes("rudder")) return { asset, score: -1 };
+    if (!normalized.includes(target.platform)) return { asset, score: -1 };
+    let score = 1;
+    if (target.arch === "arm64" && normalized.includes("arm64")) score += 4;
+    if (target.arch === "x64" && (normalized.includes("x64") || normalized.includes("amd64"))) score += 4;
+    if (target.platform === "macos" && target.arch === "x64" && normalized.includes("arm64")) score -= 10;
+    if (target.arch === "arm64" && normalized.includes("x64")) score -= 10;
+    return { asset, score };
+  }).filter((item) => item.score >= 0).sort((a, b) => b.score - a.score || a.asset.name.localeCompare(b.asset.name));
+  return scored[0]?.asset ?? null;
+}
+function resolveDesktopAssetCandidates(options) {
+  const candidates = [];
+  const deterministicShellName = options.directReleaseVersion ? resolveDesktopShellAssetName(options.directReleaseVersion, options.target) : null;
+  if (options.allowShellAssets !== false) {
+    const shellAsset = selectDesktopShellAsset(options.releaseAssets, options.target) ?? (options.releaseAssets.length === 0 && deterministicShellName ? buildGithubReleaseAsset(options.repo, options.tag, deterministicShellName) : null);
+    if (shellAsset) candidates.push({ asset: shellAsset, kind: "shell" });
+  }
+  const fullAsset = selectDesktopAsset(options.releaseAssets, options.target) ?? (options.directReleaseVersion ? buildGithubReleaseAsset(options.repo, options.tag, resolveDesktopAssetName(options.directReleaseVersion, options.target)) : null);
+  if (fullAsset) candidates.push({ asset: fullAsset, kind: "full" });
+  return candidates;
+}
+function selectChecksummedDesktopAssetCandidate(candidates, checksums) {
+  const warnings = [];
+  for (const candidate of candidates) {
+    try {
+      return {
+        ...candidate,
+        expectedChecksum: resolveAssetChecksum(checksums, candidate.asset.name),
+        warnings
+      };
+    } catch (error) {
+      if (candidate.kind === "shell") {
+        warnings.push(
+          `Layered Desktop shell asset is missing from ${DESKTOP_CHECKSUM_ASSET_NAME}; falling back to the full portable asset.`
+        );
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw new Error("No checksummed Rudder Desktop asset candidate is available.");
+}
 function selectChecksumAsset(assets) {
   return assets.find((asset) => asset.name.toLowerCase() === DESKTOP_CHECKSUM_ASSET_NAME.toLowerCase()) ?? null;
 }
+async function fetchWithTimeout(url, init, timeoutMs) {
+  const controller = new AbortController();
+  const timeout = setTimeout2(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout2(timeout);
+  }
+}
 function githubApiHeaders() {
   return {
     Accept: "application/vnd.github+json",
     "User-Agent": "rudder-cli-installer"
   };
 }
+var GITHUB_API_TIMEOUT_MS = 15e3;
 async function fetchGithubRelease(repo, tag) {
   const endpoint = tag === "latest" ? `https://api.github.com/repos/${repo}/releases/latest` : `https://api.github.com/repos/${repo}/releases/tags/${encodeURIComponent(tag)}`;
-  const response = await fetch(endpoint, { headers: githubApiHeaders() });
+  const response = await fetchWithTimeout(endpoint, { headers: githubApiHeaders() }, GITHUB_API_TIMEOUT_MS);
   if (!response.ok) {
     throw new Error(`GitHub Release ${tag} was not found in ${repo} (${response.status}).`);
   }
@@ -6838,6 +6902,11 @@ function resolveDesktopAssetName(version, target) {
   if (target.platform === "windows") return `${DESKTOP_APP_NAME}-${version}-windows-x64-portable.zip`;
   return `${DESKTOP_APP_NAME}-${version}-linux-x64.AppImage`;
 }
+function resolveDesktopShellAssetName(version, target) {
+  if (target.platform === "macos") return `${DESKTOP_APP_NAME}-${version}-macos-${target.arch}-shell.zip`;
+  if (target.platform === "windows") return `${DESKTOP_APP_NAME}-${version}-windows-x64-shell.zip`;
+  return null;
+}
 function encodeReleaseTagForDownloadUrl(tag) {
   return tag.split("/").map((segment) => encodeURIComponent(segment)).join("/");
 }
@@ -6852,7 +6921,7 @@ function buildGithubReleaseAsset(repo, tag, assetName) {
   };
 }
 function uniqueAssetDownloadUrls(asset) {
-  const urls = [asset.url, asset.browser_download_url].filter((url) => Boolean(url));
+  const urls = [asset.browser_download_url, asset.url].filter((url) => Boolean(url));
   return Array.from(new Set(urls));
 }
 function downloadHeadersForAssetUrl(asset, url) {
@@ -6880,13 +6949,16 @@ function contentLengthFromHeaders(headers) {
 async function downloadAsset(asset, outputDir, progressFactory = createByteProgress) {
   mkdirSync(outputDir, { recursive: true });
   const outputPath = path11.join(outputDir, path11.basename(asset.name));
+  const ASSET_DOWNLOAD_TIMEOUT_MS = 6e5;
   let response = null;
   const failures = [];
   for (const url of uniqueAssetDownloadUrls(asset)) {
     try {
-      const candidate = await fetch(url, {
-        headers: downloadHeadersForAssetUrl(asset, url)
-      });
+      const candidate = await fetchWithTimeout(
+        url,
+        { headers: downloadHeadersForAssetUrl(asset, url) },
+        ASSET_DOWNLOAD_TIMEOUT_MS
+      );
       if (candidate.ok && candidate.body) {
         response = candidate;
         break;
@@ -7323,13 +7395,14 @@ function launchDesktop(paths, target) {
   }
   spawn(paths.executablePath, [], { detached: true, stdio: "ignore" }).unref();
 }
-async function writeInstallMetadata(paths, releaseTag, assetName, assetChecksum) {
+async function writeInstallMetadata(paths, releaseTag, assetName, assetChecksum, assetKind = "full") {
   mkdirSync(path11.dirname(paths.metadataPath), { recursive: true });
   const metadata = {
     version: 1,
     releaseTag,
     assetName,
     assetChecksum,
+    assetKind,
     installedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   mkdirSync(paths.installRoot, { recursive: true });
@@ -7369,6 +7442,7 @@ async function startCommand(opts) {
   const version = opts.targetVersion?.trim() || opts.version?.trim() || resolveCurrentCliVersion();
   const dryRun = opts.dryRun === true;
   const desktopProgressJson = opts.desktopProgressJson === true;
+  let runtimeSupportsShellAssets = false;
   if (desktopProgressJson) {
     process.stdout.on("error", (error) => {
       if (error.code !== "EPIPE") throw error;
@@ -7391,9 +7465,13 @@ async function startCommand(opts) {
       spinner3.start("Installing or reusing Rudder runtime...");
       try {
         const runtime = await ensureRuntimeInstalled({ version });
+        runtimeSupportsShellAssets = isExactRuntimePackageSpec(version, runtime.packageSpec);
         spinner3.stop(
           runtime.status === "hit" ? `Rudder runtime cache hit at ${pc8.cyan(runtime.cacheDir)}.` : `Rudder runtime installed at ${pc8.cyan(runtime.cacheDir)}.`
         );
+        if (!runtimeSupportsShellAssets && installDesktop) {
+          p13.log.warn("Rudder runtime did not resolve to the exact Desktop version; the full portable Desktop asset will be used.");
+        }
       } catch (error) {
         spinner3.stop(pc8.red("Rudder runtime installation failed."));
         if (error instanceof RuntimeInstallError && error.output) {
@@ -7466,15 +7544,31 @@ async function startCommand(opts) {
     if (!releaseTag) {
       throw new Error(`Unable to resolve Rudder Desktop release tag for ${repo}@${tag}.`);
     }
-    const asset = selectDesktopAsset(release?.assets ?? [], target) ?? (directReleaseVersion ? buildGithubReleaseAsset(repo, tag, resolveDesktopAssetName(directReleaseVersion, target)) : null);
-    if (!asset) {
+    const assetCandidates = resolveDesktopAssetCandidates({
+      releaseAssets: release?.assets ?? [],
+      target,
+      repo,
+      tag,
+      directReleaseVersion,
+      allowShellAssets: runtimeSupportsShellAssets
+    });
+    if (assetCandidates.length === 0) {
       throw new Error(`No Rudder Desktop portable asset found for ${target.platform}/${target.arch} in ${repo}@${releaseTag}.`);
     }
     const checksumAsset = selectChecksumAsset(release?.assets ?? []) ?? (directReleaseVersion ? buildGithubReleaseAsset(repo, tag, DESKTOP_CHECKSUM_ASSET_NAME) : null);
     const checksums = await downloadChecksums(checksumAsset, outputDir, progressFactory);
-    const expectedChecksum = resolveAssetChecksum(checksums, asset.name);
+    let selectedCandidate;
+    try {
+      selectedCandidate = selectChecksummedDesktopAssetCandidate(assetCandidates, checksums);
+    } catch (error) {
+      throw new Error(`No checksummed Rudder Desktop asset found for ${target.platform}/${target.arch} in ${repo}@${releaseTag}.`);
+    }
+    for (const warning of selectedCandidate.warnings) p13.log.warn(warning);
+    let selectedAsset = selectedCandidate.asset;
+    let selectedAssetKind = selectedCandidate.kind;
+    let expectedChecksum = selectedCandidate.expectedChecksum;
     const metadata = await readInstallMetadata(installPaths.metadataPath);
-    if (isInstalledDesktopCurrent(metadata, releaseTag, asset.name, expectedChecksum) && await pathExists(installPaths.executablePath)) {
+    if (isInstalledDesktopCurrent(metadata, releaseTag, selectedAsset.name, expectedChecksum) && await pathExists(installPaths.executablePath)) {
       p13.log.success(`Rudder Desktop is already installed at ${pc8.cyan(installPaths.appPath)}.`);
       await runStartPhase(
         "Refreshing Desktop launchers...",
@@ -7486,16 +7580,32 @@ async function startCommand(opts) {
         desktopProgressJson ? "preparing_restart" : null
       );
     } else {
-      const cachedAsset = await downloadDesktopAssetWithCache(asset, expectedChecksum, {
-        outputDir,
-        progressFactory
-      });
+      let cachedAsset;
+      try {
+        cachedAsset = await downloadDesktopAssetWithCache(selectedAsset, expectedChecksum, {
+          outputDir,
+          progressFactory
+        });
+      } catch (error) {
+        const fullCandidate = assetCandidates.find((candidate) => candidate.kind === "full");
+        if (selectedAssetKind !== "shell" || !fullCandidate) throw error;
+        p13.log.warn(
+          `Layered Desktop shell asset download failed; falling back to the full portable asset. ${formatFetchError(error)}`
+        );
+        selectedAsset = fullCandidate.asset;
+        selectedAssetKind = fullCandidate.kind;
+        expectedChecksum = resolveAssetChecksum(checksums, selectedAsset.name);
+        cachedAsset = await downloadDesktopAssetWithCache(selectedAsset, expectedChecksum, {
+          outputDir,
+          progressFactory
+        });
+      }
       if (cachedAsset.cacheStatus === "hit") {
         p13.log.success(`Desktop asset cache hit at ${pc8.cyan(cachedAsset.path)}.`);
         if (desktopProgressJson) {
           writeDesktopProgress({
             phase: "downloading_asset",
-            message: `Desktop asset cache hit for ${asset.name}.`,
+            message: `Desktop asset cache hit for ${selectedAsset.name}.`,
             percent: 100
           });
         }
@@ -7539,7 +7649,7 @@ async function startCommand(opts) {
         },
         desktopProgressJson ? "preparing_restart" : null
       );
-      await writeInstallMetadata(installPaths, releaseTag, asset.name, checksum);
+      await writeInstallMetadata(installPaths, releaseTag, selectedAsset.name, checksum, selectedAssetKind);
     }
     if (opts.open !== false) {
       await runStartPhase(