@rudderhq/cli 0.1.0-canary.18 → 0.1.0-canary.19

package/dist/index.js

@@ -10033,12 +10033,119 @@ import { constants as fsConstants, createWriteStream, mkdirSync as mkdirSync2, r
 import { access, chmod, copyFile, cp, mkdtemp, mkdir, readFile as readFile3, readdir as readdir2, rm, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import path10 from "node:path";
-import { Readable } from "node:stream";
+import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { setTimeout as delay } from "node:timers/promises";
 import * as p13 from "@clack/prompts";
 import pc8 from "picocolors";
 
+// src/utils/progress.ts
+var BYTE_UNITS = ["B", "KB", "MB", "GB", "TB"];
+function formatBytes(bytes) {
+  let value = Math.max(0, bytes);
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < BYTE_UNITS.length - 1) {
+    value /= 1024;
+    unitIndex += 1;
+  }
+  if (unitIndex === 0) return `${Math.round(value)} ${BYTE_UNITS[unitIndex]}`;
+  return `${value.toFixed(1)} ${BYTE_UNITS[unitIndex]}`;
+}
+function normalizeTotalBytes(totalBytes) {
+  if (typeof totalBytes !== "number" || !Number.isFinite(totalBytes) || totalBytes <= 0) {
+    return null;
+  }
+  return totalBytes;
+}
+function formatByteProgress(state) {
+  const width = Math.max(4, state.width ?? 20);
+  const receivedBytes = Math.max(0, state.receivedBytes);
+  const totalBytes = normalizeTotalBytes(state.totalBytes);
+  if (totalBytes === null) {
+    return `[downloaded ${formatBytes(receivedBytes)}]`;
+  }
+  const ratio = Math.max(0, Math.min(1, receivedBytes / totalBytes));
+  const filled = Math.round(ratio * width);
+  const percent = Math.floor(ratio * 100);
+  return `[${"#".repeat(filled)}${"-".repeat(width - filled)}] ${percent}% ${formatBytes(receivedBytes)}/${formatBytes(totalBytes)}`;
+}
+function progressSummary(receivedBytes, totalBytes) {
+  const total = normalizeTotalBytes(totalBytes);
+  if (total === null) return formatBytes(receivedBytes);
+  return `${formatBytes(receivedBytes)}/${formatBytes(total)}`;
+}
+function createByteProgress(label, options = {}) {
+  const stream = options.stream ?? process.stdout;
+  const isTty = options.isTty ?? Boolean(stream.isTTY);
+  const width = options.width ?? 20;
+  const minIntervalMs = options.minIntervalMs ?? 80;
+  const now = options.now ?? (() => Date.now());
+  let started = false;
+  let finished = false;
+  let lastRenderAt = 0;
+  let lastLineLength = 0;
+  let latestReceivedBytes = 0;
+  let latestTotalBytes = null;
+  function render(receivedBytes, totalBytes, force = false) {
+    if (finished) return;
+    latestReceivedBytes = receivedBytes;
+    latestTotalBytes = totalBytes;
+    if (!isTty) return;
+    const currentTime = now();
+    const total = normalizeTotalBytes(totalBytes);
+    const complete = total !== null && receivedBytes >= total;
+    if (!force && currentTime - lastRenderAt < minIntervalMs && !complete) return;
+    const line = `${label} ${formatByteProgress({ receivedBytes, totalBytes, width })}`;
+    const padding = lastLineLength > line.length ? " ".repeat(lastLineLength - line.length) : "";
+    stream.write(`\r${line}${padding}`);
+    lastLineLength = line.length;
+    lastRenderAt = currentTime;
+  }
+  function start(totalBytes) {
+    if (started || finished) return;
+    started = true;
+    latestTotalBytes = totalBytes;
+    if (isTty) {
+      render(0, totalBytes, true);
+    } else {
+      stream.write(`${label}...
+`);
+    }
+  }
+  function update(receivedBytes, totalBytes) {
+    if (!started) start(totalBytes);
+    render(receivedBytes, totalBytes, false);
+  }
+  function finish(receivedBytes = latestReceivedBytes, totalBytes = latestTotalBytes) {
+    if (finished) return;
+    if (!started) start(totalBytes);
+    if (isTty) {
+      render(receivedBytes, totalBytes, true);
+      stream.write("\n");
+    } else {
+      stream.write(`${label} complete (${progressSummary(receivedBytes, totalBytes)}).
+`);
+    }
+    finished = true;
+  }
+  function fail() {
+    if (finished) return;
+    if (isTty && started) {
+      stream.write("\n");
+    } else if (!isTty && started) {
+      stream.write(`${label} failed.
+`);
+    }
+    finished = true;
+  }
+  return {
+    start,
+    update,
+    finish,
+    fail
+  };
+}
+
 // src/version.ts
 import { existsSync as existsSync2, readFileSync } from "node:fs";
 import path9 from "node:path";
@@ -10263,7 +10370,13 @@ function buildGithubReleaseAsset(repo, tag, assetName) {
     browser_download_url: buildGithubReleaseAssetDownloadUrl(repo, tag, assetName)
   };
 }
-async function downloadAsset(asset, outputDir) {
+function contentLengthFromHeaders(headers) {
+  const raw = headers.get("content-length");
+  if (!raw) return null;
+  const value = Number(raw);
+  return Number.isFinite(value) && value > 0 ? value : null;
+}
+async function downloadAsset(asset, outputDir, progressFactory = createByteProgress) {
   mkdirSync2(outputDir, { recursive: true });
   const outputPath = path10.join(outputDir, path10.basename(asset.name));
   const response = await fetch(asset.browser_download_url, {
@@ -10272,7 +10385,24 @@ async function downloadAsset(asset, outputDir) {
   if (!response.ok || !response.body) {
     throw new Error(`Failed to download ${asset.name} from ${asset.browser_download_url} (${response.status}).`);
   }
-  await pipeline(Readable.fromWeb(response.body), createWriteStream(outputPath));
+  const totalBytes = contentLengthFromHeaders(response.headers);
+  const progress = progressFactory(`Downloading ${asset.name}`);
+  let receivedBytes = 0;
+  const monitor = new Transform({
+    transform(chunk, _encoding, callback) {
+      receivedBytes += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
+      progress.update(receivedBytes, totalBytes);
+      callback(null, chunk);
+    }
+  });
+  progress.start(totalBytes);
+  try {
+    await pipeline(Readable.fromWeb(response.body), monitor, createWriteStream(outputPath));
+    progress.finish(receivedBytes, totalBytes);
+  } catch (error) {
+    progress.fail();
+    throw error;
+  }
   return outputPath;
 }
 function checksumForFile(filePath) {
@@ -10303,11 +10433,11 @@ function assertChecksumMatch(filePath, expected) {
   }
   return actual;
 }
-async function downloadChecksums(checksumAsset, outputDir) {
+async function downloadChecksums(checksumAsset, outputDir, progressFactory = createByteProgress) {
   if (!checksumAsset) {
     throw new Error("Desktop release is missing SHASUMS256.txt.");
   }
-  const checksumPath = await downloadAsset(checksumAsset, outputDir);
+  const checksumPath = await downloadAsset(checksumAsset, outputDir, progressFactory);
   return parseChecksumFile(readFileSync2(checksumPath, "utf8"));
 }
 async function pathExists(targetPath) {
@@ -10571,6 +10701,18 @@ async function writeInstallMetadata(paths, releaseTag, assetName, assetChecksum)
   await writeFile2(paths.metadataPath, `${JSON.stringify(metadata, null, 2)}
 `, "utf8");
 }
+async function runStartPhase(message, successMessage, task) {
+  const spinner5 = p13.spinner();
+  spinner5.start(message);
+  try {
+    const result = await task();
+    spinner5.stop(successMessage);
+    return result;
+  } catch (error) {
+    spinner5.stop(pc8.red(`${message} failed.`));
+    throw error;
+  }
+}
 async function startCommand(opts) {
   const installCli = opts.cli !== false;
   const installDesktop = opts.desktop !== false;
@@ -10596,12 +10738,21 @@ async function startCommand(opts) {
       p13.log.message(`[dry-run] ${command}`);
     } else {
       p13.log.message(pc8.dim(`Running: ${command}`));
-      const result = installPersistentCli({ installSpec });
+      const spinner5 = p13.spinner();
+      spinner5.start("Installing persistent CLI...");
+      let result;
+      try {
+        result = installPersistentCli({ installSpec });
+      } catch (error) {
+        spinner5.stop(pc8.red("Persistent CLI installation failed."));
+        throw error;
+      }
       if (!result.ok) {
+        spinner5.stop(pc8.red("Persistent CLI installation failed."));
         if (result.output) p13.log.message(pc8.dim(result.output));
         throw new Error(`Persistent CLI installation failed. Re-run manually: ${result.command}`);
       }
-      p13.log.success(`${pc8.cyan("rudder")} CLI installed.`);
+      spinner5.stop(`${pc8.cyan("rudder")} CLI installed.`);
     }
   }
   if (installDesktop) {
@@ -10620,7 +10771,12 @@ async function startCommand(opts) {
       return;
     }
     const directReleaseVersion = resolveDesktopReleaseVersion(tag);
-    const release = directReleaseVersion ? null : await fetchGithubRelease(repo, tag);
+    const progressFactory = createByteProgress;
+    const release = directReleaseVersion ? null : await runStartPhase(
+      "Resolving Desktop release...",
+      "Desktop release resolved.",
+      () => fetchGithubRelease(repo, tag)
+    );
     const releaseTag = directReleaseVersion ? tag : release?.tag_name;
     if (!releaseTag) {
       throw new Error(`Unable to resolve Rudder Desktop release tag for ${repo}@${tag}.`);
@@ -10630,28 +10786,52 @@ async function startCommand(opts) {
       throw new Error(`No Rudder Desktop portable asset found for ${target.platform}/${target.arch} in ${repo}@${releaseTag}.`);
     }
     const checksumAsset = directReleaseVersion ? buildGithubReleaseAsset(repo, tag, DESKTOP_CHECKSUM_ASSET_NAME) : selectChecksumAsset(release?.assets ?? []);
-    const checksums = await downloadChecksums(checksumAsset, outputDir);
+    const checksums = await downloadChecksums(checksumAsset, outputDir, progressFactory);
     const expectedChecksum = resolveAssetChecksum(checksums, asset.name);
     const metadata = await readInstallMetadata(installPaths.metadataPath);
     if (isInstalledDesktopCurrent(metadata, releaseTag, asset.name, expectedChecksum) && await pathExists(installPaths.executablePath)) {
       p13.log.success(`Rudder Desktop is already installed at ${pc8.cyan(installPaths.appPath)}.`);
-      await removeMacQuarantine(installPaths, target);
-      await createPlatformLaunchers(installPaths, target);
+      await runStartPhase(
+        "Refreshing Desktop launchers...",
+        "Desktop launchers ready.",
+        async () => {
+          await removeMacQuarantine(installPaths, target);
+          await createPlatformLaunchers(installPaths, target);
+        }
+      );
     } else {
-      const installerPath = await downloadAsset(asset, outputDir);
-      const checksum = assertChecksumMatch(installerPath, expectedChecksum);
-      p13.log.success(`Downloaded and verified ${pc8.cyan(path10.basename(installerPath))}`);
-      p13.log.message("Replacing existing Rudder Desktop if needed.");
-      await prepareForDesktopReplace(installPaths, target);
-      await installPortableDesktop(installerPath, installPaths, target);
-      await removeMacQuarantine(installPaths, target);
-      await createPlatformLaunchers(installPaths, target);
+      const installerPath = await downloadAsset(asset, outputDir, progressFactory);
+      const checksum = await runStartPhase(
+        "Verifying Desktop checksum...",
+        `Verified ${pc8.cyan(path10.basename(installerPath))}.`,
+        () => assertChecksumMatch(installerPath, expectedChecksum)
+      );
+      await runStartPhase(
+        "Replacing existing Rudder Desktop if needed...",
+        "Existing Desktop install is ready for replacement.",
+        () => prepareForDesktopReplace(installPaths, target)
+      );
+      await runStartPhase(
+        "Installing portable Desktop app...",
+        `Installed Rudder Desktop to ${pc8.cyan(installPaths.appPath)}.`,
+        () => installPortableDesktop(installerPath, installPaths, target)
+      );
+      await runStartPhase(
+        "Preparing Desktop launchers...",
+        "Desktop launchers ready.",
+        async () => {
+          await removeMacQuarantine(installPaths, target);
+          await createPlatformLaunchers(installPaths, target);
+        }
+      );
       await writeInstallMetadata(installPaths, releaseTag, asset.name, checksum);
-      p13.log.success(`Installed Rudder Desktop to ${pc8.cyan(installPaths.appPath)}.`);
     }
     if (opts.open !== false) {
-      launchDesktop(installPaths, target);
-      p13.log.success("Rudder Desktop launched.");
+      await runStartPhase(
+        "Launching Rudder Desktop...",
+        "Rudder Desktop launched.",
+        () => launchDesktop(installPaths, target)
+      );
     }
   }
   p13.outro(pc8.green("Rudder start complete."));
@@ -12657,8 +12837,8 @@ async function dbBackupCommand(opts) {
   p15.log.message(pc20.dim(`Connection source: ${connection.source}`));
   p15.log.message(pc20.dim(`Backup dir: ${backupDir}`));
   p15.log.message(pc20.dim(`Retention: ${retentionDays} day(s)`));
-  const spinner4 = p15.spinner();
-  spinner4.start("Creating database backup...");
+  const spinner5 = p15.spinner();
+  spinner5.start("Creating database backup...");
   try {
     const result = await runDatabaseBackup({
       connectionString: connection.value,
@@ -12666,7 +12846,7 @@ async function dbBackupCommand(opts) {
       retentionDays,
       filenamePrefix
     });
-    spinner4.stop(`Backup saved: ${formatDatabaseBackupResult(result)}`);
+    spinner5.stop(`Backup saved: ${formatDatabaseBackupResult(result)}`);
     if (opts.json) {
       console.log(
         JSON.stringify(
@@ -12685,7 +12865,7 @@ async function dbBackupCommand(opts) {
     }
     p15.outro(pc20.green("Backup completed."));
   } catch (err) {
-    spinner4.stop(pc20.red("Backup failed."));
+    spinner5.stop(pc20.red("Backup failed."));
     throw err;
   }
 }
@@ -16925,8 +17105,8 @@ async function runWorktreeInit(opts) {
         `Cannot seed worktree database because source config was not found at ${sourceConfigPath}. Use --no-seed or provide --from-config.`
       );
     }
-    const spinner4 = p17.spinner();
-    spinner4.start(`Seeding isolated worktree database from source instance (${seedMode})...`);
+    const spinner5 = p17.spinner();
+    spinner5.start(`Seeding isolated worktree database from source instance (${seedMode})...`);
     try {
       const seeded = await seedWorktreeDatabase({
         sourceConfigPath,
@@ -16938,9 +17118,9 @@ async function runWorktreeInit(opts) {
       });
       seedSummary = seeded.backupSummary;
       reboundWorkspaceSummary = seeded.reboundWorkspaces;
-      spinner4.stop(`Seeded isolated worktree database (${seedMode}).`);
+      spinner5.stop(`Seeded isolated worktree database (${seedMode}).`);
     } catch (error) {
-      spinner4.stop(pc23.red("Failed to seed worktree database."));
+      spinner5.stop(pc23.red("Failed to seed worktree database."));
       throw error;
     }
   }
@@ -17006,16 +17186,16 @@ async function worktreeMakeCommand(nameArg, opts) {
     branchExists: !startPoint && localBranchExists(sourceCwd, name),
     startPoint
   });
-  const spinner4 = p17.spinner();
-  spinner4.start(`Creating git worktree at ${targetPath}...`);
+  const spinner5 = p17.spinner();
+  spinner5.start(`Creating git worktree at ${targetPath}...`);
   try {
     execFileSync2("git", worktreeArgs, {
       cwd: sourceCwd,
       stdio: ["ignore", "pipe", "pipe"]
     });
-    spinner4.stop(`Created git worktree at ${targetPath}.`);
+    spinner5.stop(`Created git worktree at ${targetPath}.`);
   } catch (error) {
-    spinner4.stop(pc23.red("Failed to create git worktree."));
+    spinner5.stop(pc23.red("Failed to create git worktree."));
     throw new Error(extractExecSyncErrorMessage(error) ?? String(error));
   }
   const installSpinner = p17.spinner();
@@ -17183,9 +17363,9 @@ async function worktreeCleanupCommand(nameArg, opts) {
   }
   if (linkedWorktree) {
     const worktreeDirExists = existsSync3(linkedWorktree.worktree);
-    const spinner4 = p17.spinner();
+    const spinner5 = p17.spinner();
     if (worktreeDirExists) {
-      spinner4.start(`Removing git worktree at ${linkedWorktree.worktree}...`);
+      spinner5.start(`Removing git worktree at ${linkedWorktree.worktree}...`);
       try {
         const removeArgs = ["worktree", "remove", linkedWorktree.worktree];
         if (opts.force) removeArgs.push("--force");
@@ -17193,18 +17373,18 @@ async function worktreeCleanupCommand(nameArg, opts) {
           cwd: sourceCwd,
           stdio: ["ignore", "pipe", "pipe"]
         });
-        spinner4.stop(`Removed git worktree at ${linkedWorktree.worktree}.`);
+        spinner5.stop(`Removed git worktree at ${linkedWorktree.worktree}.`);
       } catch (error) {
-        spinner4.stop(pc23.yellow(`Could not remove worktree cleanly, will prune instead.`));
+        spinner5.stop(pc23.yellow(`Could not remove worktree cleanly, will prune instead.`));
         p17.log.warning(extractExecSyncErrorMessage(error) ?? String(error));
       }
     } else {
-      spinner4.start("Pruning stale worktree entry...");
+      spinner5.start("Pruning stale worktree entry...");
       execFileSync2("git", ["worktree", "prune"], {
         cwd: sourceCwd,
         stdio: ["ignore", "pipe", "pipe"]
       });
-      spinner4.stop("Pruned stale worktree entry.");
+      spinner5.stop("Pruned stale worktree entry.");
     }
   } else {
     execFileSync2("git", ["worktree", "prune"], {
@@ -17213,31 +17393,31 @@ async function worktreeCleanupCommand(nameArg, opts) {
     });
   }
   if (existsSync3(targetPath)) {
-    const spinner4 = p17.spinner();
-    spinner4.start(`Removing worktree directory ${targetPath}...`);
+    const spinner5 = p17.spinner();
+    spinner5.start(`Removing worktree directory ${targetPath}...`);
     rmSync(targetPath, { recursive: true, force: true });
-    spinner4.stop(`Removed worktree directory ${targetPath}.`);
+    spinner5.stop(`Removed worktree directory ${targetPath}.`);
   }
   if (localBranchExists(sourceCwd, name)) {
-    const spinner4 = p17.spinner();
-    spinner4.start(`Deleting local branch "${name}"...`);
+    const spinner5 = p17.spinner();
+    spinner5.start(`Deleting local branch "${name}"...`);
     try {
       const deleteFlag = opts.force ? "-D" : "-d";
       execFileSync2("git", ["branch", deleteFlag, name], {
         cwd: sourceCwd,
         stdio: ["ignore", "pipe", "pipe"]
       });
-      spinner4.stop(`Deleted local branch "${name}".`);
+      spinner5.stop(`Deleted local branch "${name}".`);
     } catch (error) {
-      spinner4.stop(pc23.yellow(`Could not delete branch "${name}".`));
+      spinner5.stop(pc23.yellow(`Could not delete branch "${name}".`));
       p17.log.warning(extractExecSyncErrorMessage(error) ?? String(error));
     }
   }
   if (existsSync3(instanceRoot)) {
-    const spinner4 = p17.spinner();
-    spinner4.start(`Removing instance data at ${instanceRoot}...`);
+    const spinner5 = p17.spinner();
+    spinner5.start(`Removing instance data at ${instanceRoot}...`);
     rmSync(instanceRoot, { recursive: true, force: true });
-    spinner4.stop(`Removed instance data at ${instanceRoot}.`);
+    spinner5.stop(`Removed instance data at ${instanceRoot}.`);
   }
   p17.outro(pc23.green("Cleanup complete."));
 }