@rudderhq/cli 0.2.2-canary.9 → 0.2.3

package/dist/index.js

@@ -10,7 +10,7 @@ var __export = (target, all) => {
 };
 
 // ../packages/shared/src/constants.ts
-var ORGANIZATION_STATUSES, DEPLOYMENT_MODES, DEPLOYMENT_EXPOSURES, AUTH_BASE_URL_MODES, AGENT_STATUSES, AGENT_RUNTIME_TYPES, AGENT_ROLES, AGENT_ICON_NAMES, ISSUE_STATUSES, ISSUE_PRIORITIES, CALENDAR_SOURCE_TYPES, CALENDAR_OWNER_TYPES, CALENDAR_VISIBILITIES, CALENDAR_SOURCE_STATUSES, CALENDAR_EVENT_KINDS, CALENDAR_EVENT_STATUSES, CALENDAR_SOURCE_MODES, CHAT_CONVERSATION_STATUSES, CHAT_ISSUE_CREATION_MODES, CHAT_MESSAGE_ROLES, CHAT_MESSAGE_KINDS, CHAT_MESSAGE_STATUSES, CHAT_CONTEXT_ENTITY_TYPES, GOAL_LEVELS, GOAL_STATUSES, PROJECT_STATUSES, ORGANIZATION_RESOURCE_KINDS, PROJECT_RESOURCE_ATTACHMENT_ROLES, AUTOMATION_STATUSES, AUTOMATION_CONCURRENCY_POLICIES, AUTOMATION_CATCH_UP_POLICIES, AUTOMATION_TRIGGER_SIGNING_MODES, PROJECT_COLORS, APPROVAL_TYPES, SECRET_PROVIDERS, STORAGE_PROVIDERS, BILLING_TYPES, FINANCE_EVENT_KINDS, FINANCE_DIRECTIONS, FINANCE_UNITS, BUDGET_SCOPE_TYPES, BUDGET_METRICS, BUDGET_WINDOW_KINDS, BUDGET_INCIDENT_RESOLUTION_ACTIONS, INVITE_JOIN_TYPES, JOIN_REQUEST_TYPES, JOIN_REQUEST_STATUSES, PERMISSION_KEYS, PLUGIN_STATUSES, PLUGIN_CATEGORIES, PLUGIN_CAPABILITIES, PLUGIN_UI_SLOT_TYPES, PLUGIN_RESERVED_COMPANY_ROUTE_SEGMENTS, PLUGIN_LAUNCHER_PLACEMENT_ZONES, PLUGIN_LAUNCHER_ACTIONS, PLUGIN_LAUNCHER_BOUNDS, PLUGIN_LAUNCHER_RENDER_ENVIRONMENTS, PLUGIN_UI_SLOT_ENTITY_TYPES, PLUGIN_STATE_SCOPE_KINDS;
+var ORGANIZATION_STATUSES, DEPLOYMENT_MODES, DEPLOYMENT_EXPOSURES, AUTH_BASE_URL_MODES, AGENT_STATUSES, AGENT_RUNTIME_TYPES, AGENT_ROLES, AGENT_ICON_NAMES, AGENT_DICEBEAR_NOTIONISTS_ICON_PREFIX, AGENT_AVATAR_BACKGROUND_PRESET_IDS, ISSUE_STATUSES, ISSUE_PRIORITIES, CALENDAR_SOURCE_TYPES, CALENDAR_OWNER_TYPES, CALENDAR_VISIBILITIES, CALENDAR_SOURCE_STATUSES, CALENDAR_EVENT_KINDS, CALENDAR_EVENT_STATUSES, CALENDAR_SOURCE_MODES, CHAT_CONVERSATION_STATUSES, CHAT_ISSUE_CREATION_MODES, CHAT_MESSAGE_ROLES, CHAT_MESSAGE_KINDS, CHAT_MESSAGE_STATUSES, CHAT_CONTEXT_ENTITY_TYPES, GOAL_LEVELS, GOAL_STATUSES, PROJECT_STATUSES, ORGANIZATION_RESOURCE_KINDS, PROJECT_RESOURCE_ATTACHMENT_ROLES, AUTOMATION_STATUSES, AUTOMATION_CONCURRENCY_POLICIES, AUTOMATION_CATCH_UP_POLICIES, AUTOMATION_TRIGGER_SIGNING_MODES, PROJECT_COLORS, APPROVAL_TYPES, SECRET_PROVIDERS, STORAGE_PROVIDERS, BILLING_TYPES, FINANCE_EVENT_KINDS, FINANCE_DIRECTIONS, FINANCE_UNITS, BUDGET_SCOPE_TYPES, BUDGET_METRICS, BUDGET_WINDOW_KINDS, BUDGET_INCIDENT_RESOLUTION_ACTIONS, INVITE_JOIN_TYPES, JOIN_REQUEST_TYPES, JOIN_REQUEST_STATUSES, PERMISSION_KEYS, PLUGIN_STATUSES, PLUGIN_CATEGORIES, PLUGIN_CAPABILITIES, PLUGIN_UI_SLOT_TYPES, PLUGIN_RESERVED_COMPANY_ROUTE_SEGMENTS, PLUGIN_LAUNCHER_PLACEMENT_ZONES, PLUGIN_LAUNCHER_ACTIONS, PLUGIN_LAUNCHER_BOUNDS, PLUGIN_LAUNCHER_RENDER_ENVIRONMENTS, PLUGIN_UI_SLOT_ENTITY_TYPES, PLUGIN_STATE_SCOPE_KINDS;
 var init_constants = __esm({
   "../packages/shared/src/constants.ts"() {
     "use strict";
@@ -95,6 +95,15 @@ var init_constants = __esm({
       "pentagon",
       "fingerprint"
     ];
+    AGENT_DICEBEAR_NOTIONISTS_ICON_PREFIX = "dicebear:notionists:";
+    AGENT_AVATAR_BACKGROUND_PRESET_IDS = [
+      "mist",
+      "slate",
+      "sky",
+      "mint",
+      "peach",
+      "violet"
+    ];
     ISSUE_STATUSES = [
       "backlog",
       "todo",
@@ -632,9 +641,35 @@ var init_chat = __esm({
       question: z5.string().trim().min(1).max(240),
       options: z5.array(chatAskUserOptionSchema).min(2).max(3),
       allowFreeform: z5.boolean().optional()
+    }).superRefine((question, ctx) => {
+      const optionIds = /* @__PURE__ */ new Set();
+      question.options.forEach((option, index) => {
+        if (optionIds.has(option.id)) {
+          ctx.addIssue({
+            code: z5.ZodIssueCode.custom,
+            message: "Option ids must be unique within each question",
+            path: ["options", index, "id"]
+          });
+          return;
+        }
+        optionIds.add(option.id);
+      });
     });
     chatAskUserRequestSchema = z5.object({
       questions: z5.array(chatAskUserQuestionSchema).min(1).max(3)
+    }).superRefine((request, ctx) => {
+      const questionIds = /* @__PURE__ */ new Set();
+      request.questions.forEach((question, index) => {
+        if (questionIds.has(question.id)) {
+          ctx.addIssue({
+            code: z5.ZodIssueCode.custom,
+            message: "Question ids must be unique within requestUserInput",
+            path: ["questions", index, "id"]
+          });
+          return;
+        }
+        questionIds.add(question.id);
+      });
     });
     chatIssueRichReferenceSchema = z5.object({
       type: z5.literal("issue"),
@@ -1267,7 +1302,7 @@ var init_model_fallbacks = __esm({
 
 // ../packages/shared/src/validators/agent.ts
 import { z as z11 } from "zod";
-var agentPermissionsSchema, agentInstructionsBundleModeSchema, updateAgentInstructionsBundleSchema, upsertAgentInstructionsFileSchema, agentRuntimeConfigSchema, optionalAgentNameSchema, uploadedAgentIconSchema, customAgentIconSchema, agentIconSchema, createAgentSchema, createAgentHireSchema, updateAgentSchema, updateAgentInstructionsPathSchema, createAgentKeySchema, wakeAgentSchema, resetAgentSessionSchema, testAgentRuntimeEnvironmentSchema, updateAgentPermissionsSchema;
+var agentPermissionsSchema, agentInstructionsBundleModeSchema, updateAgentInstructionsBundleSchema, upsertAgentInstructionsFileSchema, agentRuntimeConfigSchema, optionalAgentNameSchema, uploadedAgentIconSchema, diceBearNotionistsAgentIconSchema, agentIconSchema, createAgentSchema, createAgentHireSchema, updateAgentSchema, updateAgentInstructionsPathSchema, createAgentKeySchema, wakeAgentSchema, resetAgentSessionSchema, testAgentRuntimeEnvironmentSchema, updateAgentPermissionsSchema;
 var init_agent = __esm({
   "../packages/shared/src/validators/agent.ts"() {
     "use strict";
@@ -1312,10 +1347,19 @@ var init_agent = __esm({
       z11.string().trim().min(1).optional()
     );
     uploadedAgentIconSchema = z11.string().regex(
-      /^asset:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+      new RegExp(
+        `^asset:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}(?:\\?bg=(?:${AGENT_AVATAR_BACKGROUND_PRESET_IDS.join("|")}))?$`,
+        "i"
+      ),
       "Invalid uploaded avatar reference"
     );
-    customAgentIconSchema = z11.string().trim().min(1).max(24).refine((value) => !value.toLowerCase().startsWith("asset:"), "Invalid uploaded avatar reference").refine((value) => !/[<>\u0000-\u001f\u007f]/u.test(value), "Icon cannot contain markup or control characters");
+    diceBearNotionistsAgentIconSchema = z11.string().regex(
+      new RegExp(
+        `^${AGENT_DICEBEAR_NOTIONISTS_ICON_PREFIX}[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}(?:\\?bg=(?:${AGENT_AVATAR_BACKGROUND_PRESET_IDS.join("|")}))?$`,
+        "i"
+      ),
+      "Invalid DiceBear avatar reference"
+    );
     agentIconSchema = z11.preprocess(
       (value) => {
         if (typeof value !== "string") return value;
@@ -1325,7 +1369,7 @@ var init_agent = __esm({
       z11.union([
         z11.enum(AGENT_ICON_NAMES),
         uploadedAgentIconSchema,
-        customAgentIconSchema
+        diceBearNotionistsAgentIconSchema
       ]).nullable()
     );
     createAgentSchema = z11.object({
@@ -3716,7 +3760,7 @@ var init_server = __esm({
 
 // src/runtime/install.ts
 import { spawnSync } from "node:child_process";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import path6 from "node:path";
 import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
@@ -3745,6 +3789,21 @@ async function readRuntimeInstallMetadata(cacheDir) {
     return null;
   }
 }
+async function writeRuntimeInstallMetadata(cacheDir, metadata) {
+  await writeFile(path6.join(cacheDir, RUNTIME_METADATA_FILE), `${JSON.stringify(metadata, null, 2)}
+`, "utf8");
+}
+async function touchRuntimeInstallMetadata(cacheDir) {
+  try {
+    const metadata = await readRuntimeInstallMetadata(cacheDir);
+    if (!metadata) return;
+    await writeRuntimeInstallMetadata(cacheDir, {
+      ...metadata,
+      lastUsedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  } catch {
+  }
+}
 async function isRuntimeCacheHit(options) {
   const packageName = options.packageName ?? RUNTIME_NPM_PACKAGE_NAME;
   const packageVersion = resolveRuntimePackageVersion(options.version);
@@ -3767,7 +3826,14 @@ async function ensureRuntimeInstalled(options) {
   const packageSpec = resolveRuntimePackageSpec(packageVersion, packageName);
   const command = `npm install --prefix ${cacheDir} --omit=dev --no-audit --no-fund ${packageSpec}`;
   if (await isRuntimeCacheHit({ cacheDir, version: packageVersion, packageName })) {
-    return { status: "hit", cacheDir, packageSpec, command, output: "" };
+    await touchRuntimeInstallMetadata(cacheDir);
+    const prune2 = await maybePruneRuntimeCache({
+      homeDir: options.homeDir,
+      requestedVersion: packageVersion,
+      enabled: options.pruneRuntimeCache !== false,
+      retention: options.retention
+    });
+    return { status: "hit", cacheDir, packageSpec, command, output: "", ...prune2 ? { prune: prune2 } : {} };
   }
   await mkdir(cacheDir, { recursive: true });
   await writeFile(path6.join(cacheDir, "package.json"), `${JSON.stringify({ private: true, type: "module" }, null, 2)}
@@ -3785,11 +3851,17 @@ async function ensureRuntimeInstalled(options) {
     version: 1,
     packageName,
     packageVersion,
-    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastUsedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile(path6.join(cacheDir, RUNTIME_METADATA_FILE), `${JSON.stringify(metadata, null, 2)}
-`, "utf8");
-  return { status: "installed", cacheDir, packageSpec, command, output };
+  await writeRuntimeInstallMetadata(cacheDir, metadata);
+  const prune = await maybePruneRuntimeCache({
+    homeDir: options.homeDir,
+    requestedVersion: packageVersion,
+    enabled: options.pruneRuntimeCache !== false,
+    retention: options.retention
+  });
+  return { status: "installed", cacheDir, packageSpec, command, output, ...prune ? { prune } : {} };
 }
 function resolveRuntimeServerEntrypoint(cacheDir, packageName = RUNTIME_NPM_PACKAGE_NAME) {
   return createRequire(path6.join(cacheDir, "package.json")).resolve(packageName);
@@ -3812,13 +3884,238 @@ function runNpmRuntimeInstall(spawnSyncImpl, cacheDir, packageSpec) {
 function collectSpawnOutput(result) {
   return [result.stdout, result.stderr, result.error instanceof Error ? result.error.message : null].filter((value) => typeof value === "string" && value.trim().length > 0).join("\n").trim();
 }
-var RUNTIME_NPM_PACKAGE_NAME, RUNTIME_METADATA_FILE, RuntimeInstallError;
+async function maybePruneRuntimeCache(options) {
+  if (!options.enabled) return null;
+  return pruneRuntimeCache({
+    ...options.retention,
+    homeDir: options.homeDir,
+    requestedVersion: options.retention?.requestedVersion ?? options.requestedVersion
+  });
+}
+async function pruneRuntimeCache(options = {}) {
+  const homeDir = options.homeDir ?? resolveRudderHomeDir();
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const entries = await scanRuntimeCacheEntries(homeDir);
+  const activeVersions = await readActiveRuntimeVersions(homeDir);
+  const protectedVersions = resolveProtectedRuntimeVersions(entries, {
+    requestedVersion: options.requestedVersion,
+    protectedVersions: [...options.protectedVersions ?? [], ...activeVersions],
+    keepPreviousEntries: options.keepPreviousEntries ?? DEFAULT_RUNTIME_CACHE_KEEP_PREVIOUS
+  });
+  const protectedSet = new Set(protectedVersions);
+  const maxEntries = options.maxEntries ?? DEFAULT_RUNTIME_CACHE_MAX_ENTRIES;
+  const maxAgeMs = options.maxAgeMs ?? DEFAULT_RUNTIME_CACHE_MAX_AGE_MS;
+  const maxTotalBytes = options.maxTotalBytes ?? DEFAULT_RUNTIME_CACHE_MAX_BYTES;
+  const deletions = planRuntimeCacheDeletions(entries, {
+    nowMs: now.getTime(),
+    protectedVersions: protectedSet,
+    maxEntries,
+    maxAgeMs,
+    maxTotalBytes
+  });
+  const deleted = [];
+  const warnings = [];
+  for (const entry of deletions) {
+    try {
+      await rm(entry.cacheDir, { recursive: true, force: true });
+      deleted.push({
+        cacheDir: entry.cacheDir,
+        packageVersion: entry.packageVersion,
+        sizeBytes: entry.sizeBytes
+      });
+    } catch (error) {
+      warnings.push(
+        `Failed to remove runtime cache ${entry.cacheDir}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return {
+    scanned: entries.length,
+    deleted,
+    protectedVersions,
+    freedBytes: deleted.reduce((total, entry) => total + entry.sizeBytes, 0),
+    warnings
+  };
+}
+async function scanRuntimeCacheEntries(homeDir) {
+  const runtimesDir = path6.join(homeDir, "runtimes");
+  const dirents = await readdir(runtimesDir, { withFileTypes: true }).catch(() => null);
+  if (!dirents) return [];
+  const entries = [];
+  for (const dirent of dirents) {
+    if (!dirent.isDirectory()) continue;
+    const cacheDir = path6.join(runtimesDir, dirent.name);
+    const metadata = await readRuntimeInstallMetadata(cacheDir);
+    if (!metadata) continue;
+    const fallbackStat = await safeStat(cacheDir);
+    const installedAtMs = parseTimestampMs(metadata.installedAt) ?? Number(fallbackStat?.mtimeMs ?? 0);
+    const lastUsedAtMs = parseTimestampMs(metadata.lastUsedAt) ?? installedAtMs;
+    entries.push({
+      cacheDir,
+      packageVersion: metadata.packageVersion,
+      installedAtMs,
+      lastUsedAtMs,
+      sizeBytes: await directorySizeBytes(cacheDir)
+    });
+  }
+  return entries;
+}
+function parseTimestampMs(value) {
+  if (!value) return null;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : null;
+}
+async function safeStat(targetPath) {
+  try {
+    return await stat(targetPath);
+  } catch {
+    return null;
+  }
+}
+async function directorySizeBytes(targetPath) {
+  const dirents = await readdir(targetPath, { withFileTypes: true }).catch(() => null);
+  if (!dirents) return 0;
+  let total = 0;
+  for (const dirent of dirents) {
+    const entryPath = path6.join(targetPath, dirent.name);
+    if (dirent.isSymbolicLink()) continue;
+    if (dirent.isDirectory()) {
+      total += await directorySizeBytes(entryPath);
+      continue;
+    }
+    const entryStat = await safeStat(entryPath);
+    total += Number(entryStat?.size ?? 0);
+  }
+  return total;
+}
+async function readActiveRuntimeVersions(homeDir) {
+  const instancesDir = path6.join(homeDir, "instances");
+  const dirents = await readdir(instancesDir, { withFileTypes: true }).catch(() => null);
+  if (!dirents) return [];
+  const versions = /* @__PURE__ */ new Set();
+  for (const dirent of dirents) {
+    if (!dirent.isDirectory()) continue;
+    try {
+      const descriptorPath = path6.join(instancesDir, dirent.name, "runtime", "server.json");
+      const parsed = JSON.parse(await readFile(descriptorPath, "utf8"));
+      if (typeof parsed.version !== "string") continue;
+      if (typeof parsed.pid === "number" && Number.isInteger(parsed.pid) && parsed.pid > 0 && isPidRunning(parsed.pid)) {
+        versions.add(parsed.version);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return [...versions];
+}
+function isPidRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveProtectedRuntimeVersions(entries, options) {
+  const protectedVersions = /* @__PURE__ */ new Set();
+  const requestedVersion = options.requestedVersion ? resolveRuntimePackageVersion(options.requestedVersion) : null;
+  if (requestedVersion) protectedVersions.add(requestedVersion);
+  for (const version of options.protectedVersions) {
+    const normalized = version.trim();
+    if (normalized) protectedVersions.add(normalized);
+  }
+  const latestStable = latestRuntimeVersion(entries.filter((entry) => isStableVersion(entry.packageVersion)));
+  if (latestStable) protectedVersions.add(latestStable);
+  const latestCanary = latestRuntimeVersion(entries.filter((entry) => isCanaryVersion(entry.packageVersion)));
+  if (latestCanary) protectedVersions.add(latestCanary);
+  const previousEntries = [...entries].filter((entry) => entry.packageVersion !== requestedVersion).sort((a, b) => b.lastUsedAtMs - a.lastUsedAtMs);
+  for (const entry of previousEntries.slice(0, Math.max(0, options.keepPreviousEntries))) {
+    protectedVersions.add(entry.packageVersion);
+  }
+  return [...protectedVersions].sort();
+}
+function planRuntimeCacheDeletions(entries, options) {
+  const deletions = /* @__PURE__ */ new Set();
+  const oldestFirst = [...entries].sort((a, b) => a.lastUsedAtMs - b.lastUsedAtMs);
+  const canDelete = (entry) => !options.protectedVersions.has(entry.packageVersion) && !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));
+}
+function latestRuntimeVersion(entries) {
+  let latest = null;
+  for (const entry of entries) {
+    if (!latest || compareRuntimeVersions(entry.packageVersion, latest) > 0) {
+      latest = entry.packageVersion;
+    }
+  }
+  return latest;
+}
+function isStableVersion(version) {
+  return /^\d+\.\d+\.\d+$/.test(version);
+}
+function isCanaryVersion(version) {
+  return /^\d+\.\d+\.\d+-canary\.\d+$/.test(version);
+}
+function compareRuntimeVersions(a, b) {
+  const parsedA = parseRuntimeVersion(a);
+  const parsedB = parseRuntimeVersion(b);
+  if (!parsedA || !parsedB) return a.localeCompare(b);
+  for (const key of ["major", "minor", "patch"]) {
+    if (parsedA[key] !== parsedB[key]) return parsedA[key] - parsedB[key];
+  }
+  if (parsedA.prerelease === null && parsedB.prerelease !== null) return 1;
+  if (parsedA.prerelease !== null && parsedB.prerelease === null) return -1;
+  if (parsedA.canaryNumber !== null && parsedB.canaryNumber !== null) {
+    return parsedA.canaryNumber - parsedB.canaryNumber;
+  }
+  return (parsedA.prerelease ?? "").localeCompare(parsedB.prerelease ?? "");
+}
+function parseRuntimeVersion(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(version);
+  if (!match) return null;
+  const prerelease = match[4] ?? null;
+  const canaryMatch = prerelease ? /^canary\.(\d+)$/.exec(prerelease) : null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease,
+    canaryNumber: canaryMatch ? Number(canaryMatch[1]) : null
+  };
+}
+var RUNTIME_NPM_PACKAGE_NAME, RUNTIME_METADATA_FILE, DEFAULT_RUNTIME_CACHE_MAX_ENTRIES, DEFAULT_RUNTIME_CACHE_MAX_AGE_MS, DEFAULT_RUNTIME_CACHE_MAX_BYTES, DEFAULT_RUNTIME_CACHE_KEEP_PREVIOUS, RuntimeInstallError;
 var init_install = __esm({
   "src/runtime/install.ts"() {
     "use strict";
     init_home();
     RUNTIME_NPM_PACKAGE_NAME = "@rudderhq/server";
     RUNTIME_METADATA_FILE = "runtime.json";
+    DEFAULT_RUNTIME_CACHE_MAX_ENTRIES = 5;
+    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;
     RuntimeInstallError = class extends Error {
       cacheDir;
       command;
@@ -6047,11 +6344,12 @@ ${err instanceof Error ? err.message : String(err)}`
 
 // src/commands/start.ts
 init_install2();
+init_home();
 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, rm, 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, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import path11 from "node:path";
 import { Readable, Transform } from "node:stream";
@@ -6177,6 +6475,7 @@ var CLI_REGISTRY_LATEST_URL = "https://registry.npmjs.org/@rudderhq%2fcli/latest
 var DESKTOP_APP_NAME = "Rudder";
 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";
 function normalizeProgressTotal(totalBytes) {
   return typeof totalBytes === "number" && Number.isFinite(totalBytes) && totalBytes > 0 ? totalBytes : null;
@@ -6558,6 +6857,44 @@ async function downloadChecksums(checksumAsset, outputDir, progressFactory = cre
   const checksumPath = await downloadAsset(checksumAsset, outputDir, progressFactory);
   return parseChecksumFile(readFileSync2(checksumPath, "utf8"));
 }
+function normalizeDesktopAssetChecksum(checksum) {
+  const normalized = checksum.trim().toLowerCase();
+  if (!/^[a-f0-9]{64}$/.test(normalized)) {
+    throw new Error("Desktop asset cache requires a SHA-256 checksum.");
+  }
+  return normalized;
+}
+function resolveDesktopAssetCacheDir(assetChecksum, homeDir = resolveRudderHomeDir()) {
+  return path11.join(homeDir, DESKTOP_ASSET_CACHE_DIR, normalizeDesktopAssetChecksum(assetChecksum));
+}
+function resolveDesktopCachedAssetPath(assetName, assetChecksum, homeDir = resolveRudderHomeDir()) {
+  return path11.join(resolveDesktopAssetCacheDir(assetChecksum, homeDir), path11.basename(assetName));
+}
+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);
+      return { path: cachePath, checksum, cacheStatus: "hit" };
+    } catch {
+      await rm2(cachePath, { force: true });
+    }
+  }
+  const outputDir = options.outputDir ?? await mkdtemp(path11.join(tmpdir(), "rudder-desktop-installer."));
+  const removeOutputDir = options.outputDir ? false : true;
+  try {
+    const downloadedPath = await downloadAsset(asset, outputDir, options.progressFactory);
+    const checksum = assertChecksumMatch(downloadedPath, normalizedChecksum);
+    await mkdir2(path11.dirname(cachePath), { recursive: true });
+    if (path11.resolve(downloadedPath) !== path11.resolve(cachePath)) {
+      await copyFile(downloadedPath, cachePath);
+    }
+    return { path: cachePath, checksum, cacheStatus: "miss" };
+  } finally {
+    if (removeOutputDir) await rm2(outputDir, { recursive: true, force: true });
+  }
+}
 async function pathExists(targetPath) {
   try {
     await access(targetPath, fsConstants.F_OK);
@@ -6596,7 +6933,7 @@ function isSuccessfulRobocopyExitCode(status) {
   return typeof status === "number" && status >= 0 && status <= 7;
 }
 async function extractZip(zipPath, outputDir, target) {
-  await rm(outputDir, { recursive: true, force: true });
+  await rm2(outputDir, { recursive: true, force: true });
   await mkdir2(outputDir, { recursive: true });
   if (target.platform === "macos") {
     runChecked("ditto", ["-x", "-k", zipPath, outputDir]);
@@ -6611,7 +6948,7 @@ async function extractZip(zipPath, outputDir, target) {
 }
 async function findPath(root, predicate, maxDepth = 5) {
   async function visit(dir, depth) {
-    const entries = await readdir(dir, { withFileTypes: true });
+    const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path11.join(dir, entry.name);
       if (predicate(fullPath, entry.isDirectory())) return fullPath;
@@ -6686,13 +7023,13 @@ async function requestDesktopQuit(executablePath, target) {
   try {
     return await waitForUpdateQuitResponse(responsePath);
   } finally {
-    await rm(responsePath, { force: true });
+    await rm2(responsePath, { force: true });
   }
 }
 async function removePathWithRetry(targetPath, attempts = 5) {
   for (let attempt = 0; attempt < attempts; attempt += 1) {
     try {
-      await rm(targetPath, { recursive: true, force: true });
+      await rm2(targetPath, { recursive: true, force: true });
       if (!await pathExists(targetPath)) return true;
     } catch {
     }
@@ -6746,7 +7083,7 @@ async function installPortableDesktop(installerPath, paths, target) {
     await mkdir2(path11.dirname(paths.installRoot), { recursive: true });
     await copyPortableAppBundle(appSource, paths.installRoot);
   } finally {
-    await rm(extractDir, { recursive: true, force: true });
+    await rm2(extractDir, { recursive: true, force: true });
   }
 }
 async function copyPortableAppBundle(sourcePath, destinationPath) {
@@ -6997,11 +7334,24 @@ async function startCommand(opts) {
         desktopProgressJson ? "preparing_restart" : null
       );
     } else {
-      const installerPath = await downloadAsset(asset, outputDir, progressFactory);
+      const cachedAsset = await downloadDesktopAssetWithCache(asset, 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}.`,
+            percent: 100
+          });
+        }
+      }
       const checksum = await runStartPhase(
         "Verifying Desktop checksum...",
-        `Verified ${pc8.cyan(path11.basename(installerPath))}.`,
-        () => assertChecksumMatch(installerPath, expectedChecksum),
+        `Verified ${pc8.cyan(path11.basename(cachedAsset.path))}.`,
+        () => assertChecksumMatch(cachedAsset.path, expectedChecksum),
         desktopProgressJson ? "verifying_checksum" : null
       );
       if (desktopProgressJson && opts.desktopWaitForApply === true) {
@@ -7025,7 +7375,7 @@ async function startCommand(opts) {
       await runStartPhase(
         "Installing portable Desktop app...",
         `Installed Rudder Desktop to ${pc8.cyan(installPaths.appPath)}.`,
-        () => installPortableDesktop(installerPath, installPaths, target),
+        () => installPortableDesktop(cachedAsset.path, installPaths, target),
         desktopProgressJson ? "preparing_restart" : null
       );
       await runStartPhase(
@@ -8144,7 +8494,7 @@ function registerContextCommands(program) {
 }
 
 // src/commands/client/company.ts
-import { mkdir as mkdir3, readdir as readdir2, readFile as readFile3, stat, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir3, readdir as readdir3, readFile as readFile3, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
 import path15 from "node:path";
 import * as p15 from "@clack/prompts";
 import pc14 from "picocolors";
@@ -8879,14 +9229,14 @@ function normalizeGithubImportSource(input, refOverride) {
 }
 async function pathExists2(inputPath) {
   try {
-    await stat(path15.resolve(inputPath));
+    await stat2(path15.resolve(inputPath));
     return true;
   } catch {
     return false;
   }
 }
 async function collectPackageFiles(root, current, files) {
-  const entries = await readdir2(current, { withFileTypes: true });
+  const entries = await readdir3(current, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name.startsWith(".git")) continue;
     const absolutePath = path15.join(current, entry.name);
@@ -8902,7 +9252,7 @@ async function collectPackageFiles(root, current, files) {
 }
 async function resolveInlineSourceFromPath(inputPath) {
   const resolved = path15.resolve(inputPath);
-  const resolvedStat = await stat(resolved);
+  const resolvedStat = await stat2(resolved);
   if (resolvedStat.isFile() && path15.extname(resolved).toLowerCase() === ".zip") {
     const archive = await readZipArchive(await readFile3(resolved));
     const filteredFiles = Object.fromEntries(
@@ -8938,12 +9288,12 @@ async function writeExportToFolder(outDir, exported) {
 }
 async function confirmOverwriteExportDirectory(outDir) {
   const root = path15.resolve(outDir);
-  const stats = await stat(root).catch(() => null);
+  const stats = await stat2(root).catch(() => null);
   if (!stats) return;
   if (!stats.isDirectory()) {
     throw new Error(`Export output path ${root} exists and is not a directory.`);
   }
-  const entries = await readdir2(root);
+  const entries = await readdir3(root);
   if (entries.length === 0) return;
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
     throw new Error(`Export output directory ${root} already contains files. Re-run interactively or choose an empty directory.`);
@@ -9365,7 +9715,7 @@ ${organizationUrl}`);
 
 // src/commands/client/issue.ts
 init_src();
-import { readFile as readFile4, stat as stat2 } from "node:fs/promises";
+import { readFile as readFile4, stat as stat3 } from "node:fs/promises";
 import path16 from "node:path";
 
 // src/agent-v1-registry.ts
@@ -10260,7 +10610,7 @@ ${imageBlock}` : imageBlock;
 }
 async function uploadIssueCommentImage(ctx, issue, imagePath) {
   const resolvedPath = path16.resolve(process.cwd(), imagePath);
-  const stats = await stat2(resolvedPath).catch((err) => {
+  const stats = await stat3(resolvedPath).catch((err) => {
     throw new Error(`Unable to read image ${imagePath}: ${err instanceof Error ? err.message : String(err)}`);
   });
   if (!stats.isFile()) {