@rudderhq/cli 0.2.10-canary.23 → 0.2.10-canary.25

package/dist/index.js

@@ -4291,10 +4291,10 @@ var init_install = __esm({
     init_home();
     RUNTIME_NPM_PACKAGE_NAME = "@rudderhq/server";
     RUNTIME_METADATA_FILE = "runtime.json";
-    DEFAULT_RUNTIME_CACHE_MAX_ENTRIES = 5;
+    DEFAULT_RUNTIME_CACHE_MAX_ENTRIES = 2;
     DEFAULT_RUNTIME_CACHE_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
     DEFAULT_RUNTIME_CACHE_MAX_BYTES = 2 * 1024 * 1024 * 1024;
-    DEFAULT_RUNTIME_CACHE_KEEP_PREVIOUS = 1;
+    DEFAULT_RUNTIME_CACHE_KEEP_PREVIOUS = 0;
     RUNTIME_NPM_INSTALL_FLAGS = ["--omit=dev", "--include=optional", "--no-audit", "--no-fund"];
     RuntimeInstallError = class extends Error {
       cacheDir;
@@ -6546,7 +6546,7 @@ init_install();
 import { spawn, spawnSync as spawnSync3 } from "node:child_process";
 import { createHash } from "node:crypto";
 import { constants as fsConstants, createWriteStream, mkdirSync, readFileSync as readFileSync2 } from "node:fs";
-import { access, chmod, copyFile, cp, mkdtemp, mkdir as mkdir2, readFile as readFile2, readdir as readdir2, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { access, chmod, copyFile, cp, mkdtemp, mkdir as mkdir2, readFile as readFile2, readdir as readdir2, rm as rm2, stat as stat2, utimes, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import path11 from "node:path";
 import { Readable, Transform } from "node:stream";
@@ -6677,6 +6677,10 @@ var DESKTOP_METADATA_FILE = ".rudder-desktop-install.json";
 var DESKTOP_CHECKSUM_ASSET_NAME = "SHASUMS256.txt";
 var DESKTOP_ASSET_CACHE_DIR = "desktop-assets";
 var GITHUB_ASSET_DOWNLOAD_ACCEPT = "application/octet-stream";
+var DEFAULT_DESKTOP_ASSET_CACHE_MAX_ENTRIES = 2;
+var DEFAULT_DESKTOP_ASSET_CACHE_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+var DEFAULT_DESKTOP_ASSET_CACHE_MAX_BYTES = 768 * 1024 * 1024;
+var DEFAULT_DESKTOP_ASSET_CACHE_KEEP_PREVIOUS = 1;
 function normalizeProgressTotal(totalBytes) {
   return typeof totalBytes === "number" && Number.isFinite(totalBytes) && totalBytes > 0 ? totalBytes : null;
 }
@@ -7141,12 +7145,158 @@ function resolveDesktopAssetCacheDir(assetChecksum, homeDir = resolveRudderHomeD
 function resolveDesktopCachedAssetPath(assetName, assetChecksum, homeDir = resolveRudderHomeDir()) {
   return path11.join(resolveDesktopAssetCacheDir(assetChecksum, homeDir), path11.basename(assetName));
 }
+async function pruneDesktopAssetCache(options = {}) {
+  const homeDir = options.homeDir ?? resolveRudderHomeDir();
+  const entries = await scanDesktopAssetCacheEntries(homeDir);
+  const protectedChecksums = resolveProtectedDesktopAssetChecksums(entries, {
+    protectedChecksums: options.protectedChecksums ?? [],
+    keepPreviousEntries: options.keepPreviousEntries ?? DEFAULT_DESKTOP_ASSET_CACHE_KEEP_PREVIOUS
+  });
+  const protectedSet = new Set(protectedChecksums);
+  const deletions = planDesktopAssetCacheDeletions(entries, {
+    nowMs: (options.now ?? /* @__PURE__ */ new Date()).getTime(),
+    protectedChecksums: protectedSet,
+    maxEntries: options.maxEntries ?? DEFAULT_DESKTOP_ASSET_CACHE_MAX_ENTRIES,
+    maxAgeMs: options.maxAgeMs ?? DEFAULT_DESKTOP_ASSET_CACHE_MAX_AGE_MS,
+    maxTotalBytes: options.maxTotalBytes ?? DEFAULT_DESKTOP_ASSET_CACHE_MAX_BYTES
+  });
+  const deleted = [];
+  const warnings = [];
+  for (const entry of deletions) {
+    try {
+      await rm2(entry.cacheDir, { recursive: true, force: true });
+      deleted.push({
+        cacheDir: entry.cacheDir,
+        checksum: entry.checksum,
+        sizeBytes: entry.sizeBytes
+      });
+    } catch (error) {
+      warnings.push(
+        `Failed to remove Desktop asset cache ${entry.cacheDir}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return {
+    scanned: entries.length,
+    deleted,
+    protectedChecksums,
+    freedBytes: deleted.reduce((total, entry) => total + entry.sizeBytes, 0),
+    warnings
+  };
+}
+async function maybePruneDesktopAssetCache(options) {
+  const result = await pruneDesktopAssetCache(options);
+  return result.deleted.length > 0 || result.warnings.length > 0 ? result : null;
+}
+async function scanDesktopAssetCacheEntries(homeDir) {
+  const cacheRoot = path11.join(homeDir, DESKTOP_ASSET_CACHE_DIR);
+  const dirents = await readdir2(cacheRoot, { withFileTypes: true }).catch(() => null);
+  if (!dirents) return [];
+  const entries = [];
+  for (const dirent of dirents) {
+    if (!dirent.isDirectory()) continue;
+    let checksum;
+    try {
+      checksum = normalizeDesktopAssetChecksum(dirent.name);
+    } catch {
+      continue;
+    }
+    const cacheDir = path11.join(cacheRoot, dirent.name);
+    const stats = await desktopCacheDirectoryStats(cacheDir);
+    entries.push({
+      cacheDir,
+      checksum,
+      lastUsedAtMs: stats.lastUsedAtMs,
+      sizeBytes: stats.sizeBytes
+    });
+  }
+  return entries;
+}
+async function desktopCacheDirectoryStats(targetPath) {
+  const fallbackStat = await stat2(targetPath).catch(() => null);
+  const dirents = await readdir2(targetPath, { withFileTypes: true }).catch(() => null);
+  if (!dirents) {
+    return {
+      sizeBytes: 0,
+      lastUsedAtMs: Number(fallbackStat?.mtimeMs ?? 0)
+    };
+  }
+  let sizeBytes = 0;
+  let lastUsedAtMs = Number(fallbackStat?.mtimeMs ?? 0);
+  for (const dirent of dirents) {
+    if (dirent.isSymbolicLink()) continue;
+    const entryPath = path11.join(targetPath, dirent.name);
+    const entryStat = await stat2(entryPath).catch(() => null);
+    if (!entryStat) continue;
+    lastUsedAtMs = Math.max(lastUsedAtMs, Number(entryStat.mtimeMs ?? 0));
+    if (dirent.isDirectory()) {
+      const nested = await desktopCacheDirectoryStats(entryPath);
+      sizeBytes += nested.sizeBytes;
+      lastUsedAtMs = Math.max(lastUsedAtMs, nested.lastUsedAtMs);
+      continue;
+    }
+    sizeBytes += Number(entryStat.size ?? 0);
+  }
+  return { sizeBytes, lastUsedAtMs };
+}
+function resolveProtectedDesktopAssetChecksums(entries, options) {
+  const protectedChecksums = /* @__PURE__ */ new Set();
+  for (const checksum of options.protectedChecksums) {
+    try {
+      protectedChecksums.add(normalizeDesktopAssetChecksum(checksum));
+    } catch {
+      continue;
+    }
+  }
+  const previousEntries = [...entries].filter((entry) => !protectedChecksums.has(entry.checksum)).sort((a, b) => b.lastUsedAtMs - a.lastUsedAtMs);
+  for (const entry of previousEntries.slice(0, Math.max(0, options.keepPreviousEntries))) {
+    protectedChecksums.add(entry.checksum);
+  }
+  return [...protectedChecksums].sort();
+}
+function planDesktopAssetCacheDeletions(entries, options) {
+  const deletions = /* @__PURE__ */ new Set();
+  const oldestFirst = [...entries].sort((a, b) => a.lastUsedAtMs - b.lastUsedAtMs);
+  const canDelete = (entry) => !options.protectedChecksums.has(entry.checksum) && !deletions.has(entry.cacheDir);
+  const mark = (entry) => {
+    if (canDelete(entry)) deletions.add(entry.cacheDir);
+  };
+  if (options.maxAgeMs >= 0) {
+    for (const entry of oldestFirst) {
+      if (options.nowMs - entry.lastUsedAtMs > options.maxAgeMs) mark(entry);
+    }
+  }
+  if (options.maxEntries > 0) {
+    for (const entry of oldestFirst) {
+      if (entries.length - deletions.size <= options.maxEntries) break;
+      mark(entry);
+    }
+  }
+  if (options.maxTotalBytes > 0) {
+    let remainingBytes = entries.reduce((total, entry) => total + entry.sizeBytes, 0) - [...deletions].reduce((total, cacheDir) => total + (entries.find((entry) => entry.cacheDir === cacheDir)?.sizeBytes ?? 0), 0);
+    for (const entry of oldestFirst) {
+      if (remainingBytes <= options.maxTotalBytes) break;
+      if (!canDelete(entry)) continue;
+      deletions.add(entry.cacheDir);
+      remainingBytes -= entry.sizeBytes;
+    }
+  }
+  return entries.filter((entry) => deletions.has(entry.cacheDir));
+}
+async function touchDesktopCachedAsset(cachePath) {
+  try {
+    const now = /* @__PURE__ */ new Date();
+    await utimes(cachePath, now, now);
+  } catch {
+  }
+}
 async function downloadDesktopAssetWithCache(asset, expectedChecksum, options = {}) {
   const normalizedChecksum = normalizeDesktopAssetChecksum(expectedChecksum);
   const cachePath = resolveDesktopCachedAssetPath(asset.name, normalizedChecksum, options.homeDir);
   if (await pathExists(cachePath)) {
     try {
       const checksum = assertChecksumMatch(cachePath, normalizedChecksum);
+      await touchDesktopCachedAsset(cachePath);
       return { path: cachePath, checksum, cacheStatus: "hit" };
     } catch {
       await rm2(cachePath, { force: true });
@@ -7753,6 +7903,17 @@ async function startCommand(opts) {
       );
       await writeInstallMetadata(installPaths, releaseTag, selectedAsset.name, checksum, selectedAssetKind);
     }
+    const desktopAssetPrune = await maybePruneDesktopAssetCache({
+      protectedChecksums: [expectedChecksum]
+    });
+    if (desktopAssetPrune) {
+      if (desktopAssetPrune.deleted.length > 0) {
+        p13.log.success(
+          `Pruned ${desktopAssetPrune.deleted.length} old Desktop asset cache(s), freed ${formatBytes(desktopAssetPrune.freedBytes)}.`
+        );
+      }
+      for (const warning of desktopAssetPrune.warnings) p13.log.warn(warning);
+    }
     if (opts.open !== false) {
       await runStartPhase(
         "Launching Rudder Desktop...",
@@ -8858,7 +9019,7 @@ function registerContextCommands(program) {
 }
 
 // src/commands/client/company.ts
-import { mkdir as mkdir3, readdir as readdir3, readFile as readFile3, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir3, readdir as readdir3, readFile as readFile3, stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
 import path15 from "node:path";
 import * as p15 from "@clack/prompts";
 import pc14 from "picocolors";
@@ -9593,7 +9754,7 @@ function normalizeGithubImportSource(input, refOverride) {
 }
 async function pathExists2(inputPath) {
   try {
-    await stat2(path15.resolve(inputPath));
+    await stat3(path15.resolve(inputPath));
     return true;
   } catch {
     return false;
@@ -9616,7 +9777,7 @@ async function collectPackageFiles(root, current, files) {
 }
 async function resolveInlineSourceFromPath(inputPath) {
   const resolved = path15.resolve(inputPath);
-  const resolvedStat = await stat2(resolved);
+  const resolvedStat = await stat3(resolved);
   if (resolvedStat.isFile() && path15.extname(resolved).toLowerCase() === ".zip") {
     const archive = await readZipArchive(await readFile3(resolved));
     const filteredFiles = Object.fromEntries(
@@ -9652,7 +9813,7 @@ async function writeExportToFolder(outDir, exported) {
 }
 async function confirmOverwriteExportDirectory(outDir) {
   const root = path15.resolve(outDir);
-  const stats = await stat2(root).catch(() => null);
+  const stats = await stat3(root).catch(() => null);
   if (!stats) return;
   if (!stats.isDirectory()) {
     throw new Error(`Export output path ${root} exists and is not a directory.`);
@@ -10079,7 +10240,7 @@ ${organizationUrl}`);
 
 // src/commands/client/issue.ts
 init_dist();
-import { readFile as readFile4, stat as stat3 } from "node:fs/promises";
+import { readFile as readFile4, stat as stat4 } from "node:fs/promises";
 import path16 from "node:path";
 
 // src/agent-v1-registry.ts
@@ -11199,7 +11360,7 @@ ${imageBlock}` : imageBlock;
 }
 async function uploadIssueCommentImage(ctx, issue, imagePath) {
   const resolvedPath = path16.resolve(process.cwd(), imagePath);
-  const stats = await stat3(resolvedPath).catch((err) => {
+  const stats = await stat4(resolvedPath).catch((err) => {
     throw new Error(`Unable to read image ${imagePath}: ${err instanceof Error ? err.message : String(err)}`);
   });
   if (!stats.isFile()) {