@rudderhq/cli 0.6.0 → 0.6.1

package/dist/index.js

@@ -2040,7 +2040,8 @@ var init_messenger = __esm({
       clientMutationId: uuid,
       placement: z4.discriminatedUnion("kind", [
         z4.object({ kind: z4.literal("anchor"), anchor: messengerSavedViewAnchorSchema }).strict(),
-        z4.object({ kind: z4.literal("group"), groupId: uuid }).strict()
+        z4.object({ kind: z4.literal("group"), groupId: uuid }).strict(),
+        z4.object({ kind: z4.literal("loose") }).strict()
       ])
     }).strict();
     updateMessengerSavedViewSchema = z4.object({
@@ -2048,6 +2049,7 @@ var init_messenger = __esm({
       title: savedViewMetadataShape.title.optional(),
       subtitle: savedViewMetadataShape.subtitle,
       favicon: savedViewMetadataShape.favicon,
+      primaryRailPinned: z4.boolean().optional(),
       // Compatibility-only escape hatch for legacy hidden rows. The current
       // group-only Saved View model has no operation that creates hidden rows.
       hidden: z4.literal(false).optional()
@@ -2066,7 +2068,8 @@ var init_messenger = __esm({
     listMessengerSavedViewsQuerySchema = z4.object({
       visibility: z4.enum(["visible", "hidden", "all"]).default("visible"),
       limit: z4.coerce.number().int().min(1).max(100).default(50),
-      offset: z4.coerce.number().int().min(0).default(0)
+      offset: z4.coerce.number().int().min(0).default(0),
+      primaryRailPinned: z4.union([z4.literal("true"), z4.literal(true)]).transform(() => true).optional()
     }).strict();
   }
 });
@@ -4968,11 +4971,32 @@ var init_env = __esm({
   }
 });
 
+// src/runtime/postgres-payload.ts
+import { cp, mkdir, stat } from "node:fs/promises";
+import path6 from "node:path";
+async function copyRuntimePostgresPayloadLibraries(sourceRuntimeDir, targetRuntimeDir) {
+  await mkdir(targetRuntimeDir, { recursive: true });
+  for (const directoryName of ["bin", "lib"]) {
+    const sourceDirectory = path6.join(sourceRuntimeDir, directoryName);
+    if (!await stat(sourceDirectory).catch(() => null)) continue;
+    await cp(
+      sourceDirectory,
+      path6.join(targetRuntimeDir, directoryName),
+      { recursive: true, dereference: true }
+    );
+  }
+}
+var init_postgres_payload = __esm({
+  "src/runtime/postgres-payload.ts"() {
+    "use strict";
+  }
+});
+
 // src/runtime/install.ts
 import { execFileSync, spawnSync as spawnSync2 } from "node:child_process";
-import { copyFile, cp, mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, stat, symlink, writeFile } from "node:fs/promises";
+import { copyFile, cp as cp2, mkdir as mkdir2, mkdtemp, readFile, readdir, realpath, rename, rm, stat as stat2, symlink, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
-import path6 from "node:path";
+import path7 from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function sanitizeRuntimeCacheSegment(value) {
   return encodeURIComponent(value.trim() || "latest").replaceAll("%", "_");
@@ -4982,7 +5006,7 @@ function resolveRuntimePackageVersion(version) {
   return normalized.length > 0 ? normalized : "latest";
 }
 function resolveRuntimeCacheDir(version, homeDir = resolveRudderHomeDir()) {
-  return path6.join(homeDir, "runtimes", sanitizeRuntimeCacheSegment(resolveRuntimePackageVersion(version)));
+  return path7.join(homeDir, "runtimes", sanitizeRuntimeCacheSegment(resolveRuntimePackageVersion(version)));
 }
 function resolveRuntimePackageSpec(version, packageName = RUNTIME_NPM_PACKAGE_NAME) {
   const packageVersion = resolveRuntimePackageVersion(version);
@@ -4990,7 +5014,7 @@ function resolveRuntimePackageSpec(version, packageName = RUNTIME_NPM_PACKAGE_NA
 }
 async function readRuntimeInstallMetadata(cacheDir) {
   try {
-    const raw = await readFile(path6.join(cacheDir, RUNTIME_METADATA_FILE), "utf8");
+    const raw = await readFile(path7.join(cacheDir, RUNTIME_METADATA_FILE), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1) return null;
     if (typeof parsed.packageName !== "string" || typeof parsed.packageVersion !== "string") return null;
@@ -5005,7 +5029,7 @@ async function readRuntimeInstallMetadata(cacheDir) {
   }
 }
 async function writeRuntimeInstallMetadata(cacheDir, metadata) {
-  await writeFile(path6.join(cacheDir, RUNTIME_METADATA_FILE), `${JSON.stringify(metadata, null, 2)}
+  await writeFile(path7.join(cacheDir, RUNTIME_METADATA_FILE), `${JSON.stringify(metadata, null, 2)}
 `, "utf8");
 }
 async function touchRuntimeInstallMetadata(cacheDir, postgresRuntime) {
@@ -5033,7 +5057,7 @@ function resolveEmbeddedPostgresPlatformPackage(platform = process.platform, arc
 }
 async function canResolveRuntimePackage(cacheDir, packageName) {
   try {
-    await readFile(path6.join(cacheDir, "node_modules", ...packageName.split("/"), "package.json"), "utf8");
+    await readFile(path7.join(cacheDir, "node_modules", ...packageName.split("/"), "package.json"), "utf8");
     return true;
   } catch {
     return false;
@@ -5045,9 +5069,9 @@ async function hasRequiredRuntimePlatformDependencies(cacheDir, metadata, postgr
   if (!platformPackage) return true;
   if (await canResolveRuntimePackage(cacheDir, platformPackage)) return true;
   const expectedSharedBinDir = resolveSharedRuntimePostgresPayloadBinDir(
-    path6.dirname(path6.dirname(cacheDir))
+    path7.dirname(path7.dirname(cacheDir))
   );
-  return metadata.postgresRuntime?.scope === "shared" && metadata.postgresRuntime.platform === process.platform && metadata.postgresRuntime.arch === process.arch && path6.resolve(metadata.postgresRuntime.binDir) === path6.resolve(expectedSharedBinDir) && await isRuntimePostgresPayloadUsable(
+  return metadata.postgresRuntime?.scope === "shared" && metadata.postgresRuntime.platform === process.platform && metadata.postgresRuntime.arch === process.arch && path7.resolve(metadata.postgresRuntime.binDir) === path7.resolve(expectedSharedBinDir) && await isRuntimePostgresPayloadUsable(
     cacheDir,
     metadata.postgresRuntime.binDir,
     postgresVersionProbe
@@ -5061,7 +5085,7 @@ async function isRuntimeCacheHit(options) {
     return false;
   }
   try {
-    const packageJsonPath = path6.join(options.cacheDir, "node_modules", ...packageName.split("/"), "package.json");
+    const packageJsonPath = path7.join(options.cacheDir, "node_modules", ...packageName.split("/"), "package.json");
     const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
     const packageVersionMatches = packageVersion === "latest" || packageJson.version === packageVersion;
     return packageVersionMatches && await hasRequiredRuntimePlatformDependencies(
@@ -5078,7 +5102,7 @@ async function ensureRuntimeInstalled(options) {
   const homeDir = options.homeDir ?? resolveRudderHomeDir();
   const cacheDir = resolveRuntimeCacheDir(packageVersion, homeDir);
   return withRuntimeFilesystemLock(
-    path6.join(homeDir, "runtime-payloads", ".postgres-runtime.lifecycle.lock"),
+    path7.join(homeDir, "runtime-payloads", ".postgres-runtime.lifecycle.lock"),
     async () => withRuntimeFilesystemLock(
       `${cacheDir}.install.lock`,
       async () => ensureRuntimeInstalledUnlocked(options)
@@ -5150,8 +5174,8 @@ async function ensureRuntimeInstalledUnlocked(options) {
     );
   }
   await rm(cacheDir, { recursive: true, force: true });
-  await mkdir(cacheDir, { recursive: true });
-  await writeFile(path6.join(cacheDir, "package.json"), `${JSON.stringify(RUNTIME_CACHE_PACKAGE_JSON, null, 2)}
+  await mkdir2(cacheDir, { recursive: true });
+  await writeFile(path7.join(cacheDir, "package.json"), `${JSON.stringify(RUNTIME_CACHE_PACKAGE_JSON, null, 2)}
 `, "utf8");
   const result = runNpmRuntimeInstall(spawnSyncImpl, cacheDir, packageSpec);
   let output = collectSpawnOutput(result);
@@ -5188,8 +5212,8 @@ async function ensureRuntimeInstalledUnlocked(options) {
           );
         }
         await rm(fallbackCacheDir, { recursive: true, force: true });
-        await mkdir(fallbackCacheDir, { recursive: true });
-        await writeFile(path6.join(fallbackCacheDir, "package.json"), `${JSON.stringify(RUNTIME_CACHE_PACKAGE_JSON, null, 2)}
+        await mkdir2(fallbackCacheDir, { recursive: true });
+        await writeFile(path7.join(fallbackCacheDir, "package.json"), `${JSON.stringify(RUNTIME_CACHE_PACKAGE_JSON, null, 2)}
 `, "utf8");
         const fallbackResult = runNpmRuntimeInstall(spawnSyncImpl, fallbackCacheDir, fallbackSpec);
         let fallbackOutput = collectSpawnOutput(fallbackResult);
@@ -5266,10 +5290,10 @@ async function ensureRuntimeInstalledUnlocked(options) {
   );
 }
 function resolveRuntimePostgresPayloadBinDir(cacheDir, platform = process.platform, arch = process.arch) {
-  return path6.join(cacheDir, RUNTIME_POSTGRES_PAYLOAD_DIR, runtimePostgresPlatformSegment(platform, arch), "bin");
+  return path7.join(cacheDir, RUNTIME_POSTGRES_PAYLOAD_DIR, runtimePostgresPlatformSegment(platform, arch), "bin");
 }
 function resolveSharedRuntimePostgresPayloadBinDir(homeDir = resolveRudderHomeDir(), platform = process.platform, arch = process.arch) {
-  return path6.join(
+  return path7.join(
     homeDir,
     "runtime-payloads",
     RUNTIME_POSTGRES_PAYLOAD_DIR,
@@ -5278,7 +5302,7 @@ function resolveSharedRuntimePostgresPayloadBinDir(homeDir = resolveRudderHomeDi
   );
 }
 function resolveRuntimeServerEntrypoint(cacheDir, packageName = RUNTIME_NPM_PACKAGE_NAME) {
-  return createRequire(path6.join(cacheDir, "package.json")).resolve(packageName);
+  return createRequire(path7.join(cacheDir, "package.json")).resolve(packageName);
 }
 async function importRuntimeServerModule(cacheDir, packageName = RUNTIME_NPM_PACKAGE_NAME) {
   const entrypoint = resolveRuntimeServerEntrypoint(cacheDir, packageName);
@@ -5299,7 +5323,7 @@ function formatRuntimeInstallCommand(cacheDir, packageSpec) {
   return `npm install --prefix ${cacheDir} ${RUNTIME_NPM_INSTALL_FLAGS.join(" ")} ${packageSpec}`;
 }
 function formatRuntimePlatformRepairCommand(cacheDir, packageSpec) {
-  return `npm pack ${packageSpec} --registry=${NPM_PUBLIC_REGISTRY_URL} --silent, then extract it into ${path6.join(cacheDir, "node_modules")}`;
+  return `npm pack ${packageSpec} --registry=${NPM_PUBLIC_REGISTRY_URL} --silent, then extract it into ${path7.join(cacheDir, "node_modules")}`;
 }
 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();
@@ -5316,7 +5340,7 @@ function withPostgresPayload(result, postgresPayload) {
   };
 }
 function runtimePackageJsonPath(cacheDir, packageName) {
-  return path6.join(cacheDir, "node_modules", ...packageName.split("/"), "package.json");
+  return path7.join(cacheDir, "node_modules", ...packageName.split("/"), "package.json");
 }
 async function readRuntimePackageJson(cacheDir, packageName) {
   try {
@@ -5361,8 +5385,8 @@ async function ensureRequiredEmbeddedPostgresPlatformPackage(spawnSyncImpl, cach
   );
 }
 async function installRuntimePackageInStaging(spawnSyncImpl, cacheDir, packageSpec, packageName) {
-  const stagingDir = path6.join(cacheDir, `.platform-repair-${process.pid}-${Date.now()}`);
-  await mkdir(stagingDir, { recursive: true });
+  const stagingDir = path7.join(cacheDir, `.platform-repair-${process.pid}-${Date.now()}`);
+  await mkdir2(stagingDir, { recursive: true });
   try {
     const packResult = runNpmPack(spawnSyncImpl, packageSpec, stagingDir);
     if (packResult.status !== 0) return packResult;
@@ -5370,11 +5394,11 @@ async function installRuntimePackageInStaging(spawnSyncImpl, cacheDir, packageSp
     if (!packFilename) {
       return createSyntheticSpawnResult(1, "", `Unable to parse npm pack output for ${packageSpec}.`);
     }
-    const archivePath = path6.join(stagingDir, packFilename);
-    const targetDir = path6.dirname(runtimePackageJsonPath(cacheDir, packageName));
-    await mkdir(path6.dirname(targetDir), { recursive: true });
+    const archivePath = path7.join(stagingDir, packFilename);
+    const targetDir = path7.dirname(runtimePackageJsonPath(cacheDir, packageName));
+    await mkdir2(path7.dirname(targetDir), { recursive: true });
     await rm(targetDir, { recursive: true, force: true });
-    await mkdir(targetDir, { recursive: true });
+    await mkdir2(targetDir, { recursive: true });
     const extractResult = runTarExtract(spawnSyncImpl, archivePath, targetDir);
     return combineSpawnResults(packResult, extractResult);
   } finally {
@@ -5423,8 +5447,8 @@ function combineSpawnResults(...results) {
 }
 async function removeRuntimeInstallLocks(cacheDir) {
   await Promise.all([
-    rm(path6.join(cacheDir, "package-lock.json"), { force: true }),
-    rm(path6.join(cacheDir, "node_modules", ".package-lock.json"), { force: true })
+    rm(path7.join(cacheDir, "package-lock.json"), { force: true }),
+    rm(path7.join(cacheDir, "node_modules", ".package-lock.json"), { force: true })
   ]);
 }
 function packageNameFromSpec(packageSpec) {
@@ -5448,42 +5472,42 @@ function runtimePostgresExecutableName(baseName) {
   return process.platform === "win32" ? `${baseName}.exe` : baseName;
 }
 function debianSharedirCandidate(binDir) {
-  const normalized = path6.resolve(binDir);
-  const parts = normalized.split(path6.sep);
+  const normalized = path7.resolve(binDir);
+  const parts = normalized.split(path7.sep);
   const libIndex = parts.lastIndexOf("lib");
   if (libIndex < 0) return null;
   if (parts[libIndex + 1] !== "postgresql") return null;
   const version = parts[libIndex + 2];
   if (!version || parts[libIndex + 3] !== "bin") return null;
-  const prefix = parts.slice(0, libIndex).join(path6.sep) || path6.sep;
-  return path6.join(prefix, "share", "postgresql", version);
+  const prefix = parts.slice(0, libIndex).join(path7.sep) || path7.sep;
+  return path7.join(prefix, "share", "postgresql", version);
 }
 async function resolveRuntimePostgresTemplateDir(binDir) {
   for (const candidatePath of [
-    path6.join(binDir, "..", "share", "postgresql", "postgres.bki"),
-    path6.join(binDir, "..", "share", "postgres.bki")
+    path7.join(binDir, "..", "share", "postgresql", "postgres.bki"),
+    path7.join(binDir, "..", "share", "postgres.bki")
   ]) {
     try {
-      await stat(candidatePath);
-      return path6.dirname(candidatePath);
+      await stat2(candidatePath);
+      return path7.dirname(candidatePath);
     } catch {
     }
   }
   const debianSharedir = debianSharedirCandidate(binDir);
   if (debianSharedir) {
     try {
-      await stat(path6.join(debianSharedir, "postgres.bki"));
+      await stat2(path7.join(debianSharedir, "postgres.bki"));
       return debianSharedir;
     } catch {
     }
   }
-  const pgConfigPath = path6.join(binDir, process.platform === "win32" ? "pg_config.exe" : "pg_config");
+  const pgConfigPath = path7.join(binDir, process.platform === "win32" ? "pg_config.exe" : "pg_config");
   try {
-    await stat(pgConfigPath);
+    await stat2(pgConfigPath);
     const sharedir = execFileSync(pgConfigPath, ["--sharedir"], { encoding: "utf8" }).trim();
     if (!sharedir) return null;
-    const candidatePath = path6.join(sharedir, "postgres.bki");
-    await stat(candidatePath);
+    const candidatePath = path7.join(sharedir, "postgres.bki");
+    await stat2(candidatePath);
     return sharedir;
   } catch {
     return null;
@@ -5493,21 +5517,21 @@ async function assertRuntimePostgresBinDirComplete(cacheDir, binDir) {
   const requiredBinaries = ["initdb", "pg_ctl", "postgres"];
   const missing = [];
   for (const binary of requiredBinaries) {
-    const binaryPath = path6.join(binDir, runtimePostgresExecutableName(binary));
+    const binaryPath = path7.join(binDir, runtimePostgresExecutableName(binary));
     try {
-      await stat(binaryPath);
+      await stat2(binaryPath);
     } catch {
       missing.push(binaryPath);
     }
   }
   const templateDir = await resolveRuntimePostgresTemplateDir(binDir);
   if (!templateDir) {
-    missing.push(path6.join(binDir, "..", "share", "postgresql", "postgres.bki"));
+    missing.push(path7.join(binDir, "..", "share", "postgresql", "postgres.bki"));
   } else {
     try {
-      await stat(path6.join(templateDir, "postgresql.conf.sample"));
+      await stat2(path7.join(templateDir, "postgresql.conf.sample"));
     } catch {
-      missing.push(path6.join(templateDir, "postgresql.conf.sample"));
+      missing.push(path7.join(templateDir, "postgresql.conf.sample"));
     }
   }
   if (missing.length > 0) {
@@ -5529,19 +5553,19 @@ async function isRuntimePostgresPayloadUsable(cacheDir, binDir, postgresVersionP
   }
 }
 function pathIsInside(candidatePath, rootPath) {
-  const relative = path6.relative(path6.resolve(rootPath), path6.resolve(candidatePath));
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path6.sep}`) && !path6.isAbsolute(relative);
+  const relative = path7.relative(path7.resolve(rootPath), path7.resolve(candidatePath));
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path7.sep}`) && !path7.isAbsolute(relative);
 }
 async function withRuntimeFilesystemLock(lockPath, task, options = {}) {
   const timeoutMs = options.timeoutMs ?? 3e4;
   const pollMs = options.pollMs ?? 50;
   const startedAt = Date.now();
   const lockId = `${process.pid}-${startedAt}-${Math.random().toString(16).slice(2)}`;
-  const ownerPath = path6.join(lockPath, "owner.json");
-  await mkdir(path6.dirname(lockPath), { recursive: true });
+  const ownerPath = path7.join(lockPath, "owner.json");
+  await mkdir2(path7.dirname(lockPath), { recursive: true });
   while (true) {
     try {
-      await mkdir(lockPath);
+      await mkdir2(lockPath);
       await writeFile(
         ownerPath,
         `${JSON.stringify({ pid: process.pid, lockId, createdAt: (/* @__PURE__ */ new Date()).toISOString() })}
@@ -5558,7 +5582,7 @@ async function withRuntimeFilesystemLock(lockPath, task, options = {}) {
           continue;
         }
       } catch {
-        const lockStats = await stat(lockPath).catch(() => null);
+        const lockStats = await stat2(lockPath).catch(() => null);
         if (lockStats && Date.now() - lockStats.mtimeMs > 5e3) {
           await rm(lockPath, { recursive: true, force: true });
           continue;
@@ -5567,7 +5591,7 @@ async function withRuntimeFilesystemLock(lockPath, task, options = {}) {
       if (Date.now() - startedAt >= timeoutMs) {
         throw new RuntimeInstallError(
           `Timed out waiting for PostgreSQL runtime install lock ${lockPath}`,
-          { cacheDir: path6.dirname(lockPath), command: "prepare shared PostgreSQL runtime", output: "" }
+          { cacheDir: path7.dirname(lockPath), command: "prepare shared PostgreSQL runtime", output: "" }
         );
       }
       await new Promise((resolve) => setTimeout(resolve, pollMs));
@@ -5587,29 +5611,29 @@ async function withRuntimeFilesystemLock(lockPath, task, options = {}) {
 }
 function isManagedRuntimePostgresBinDir(binDir, homeDir) {
   const managedBinDir = process.env[RUDDER_DESKTOP_MANAGED_POSTGRES_BIN_DIR_ENV]?.trim();
-  if (managedBinDir && path6.resolve(managedBinDir) === path6.resolve(binDir)) return true;
-  const runtimesRelative = path6.relative(
-    path6.join(homeDir, "runtimes"),
-    path6.resolve(binDir)
+  if (managedBinDir && path7.resolve(managedBinDir) === path7.resolve(binDir)) return true;
+  const runtimesRelative = path7.relative(
+    path7.join(homeDir, "runtimes"),
+    path7.resolve(binDir)
   );
-  const runtimeSegments = runtimesRelative.split(path6.sep);
-  if (runtimesRelative !== "" && runtimesRelative !== ".." && !runtimesRelative.startsWith(`..${path6.sep}`) && !path6.isAbsolute(runtimesRelative) && runtimeSegments.length === 4 && runtimeSegments[0]?.length > 0 && runtimeSegments[1] === RUNTIME_POSTGRES_PAYLOAD_DIR && runtimeSegments[2] === `${process.platform}-${process.arch}` && runtimeSegments[3] === "bin") {
+  const runtimeSegments = runtimesRelative.split(path7.sep);
+  if (runtimesRelative !== "" && runtimesRelative !== ".." && !runtimesRelative.startsWith(`..${path7.sep}`) && !path7.isAbsolute(runtimesRelative) && runtimeSegments.length === 4 && runtimeSegments[0]?.length > 0 && runtimeSegments[1] === RUNTIME_POSTGRES_PAYLOAD_DIR && runtimeSegments[2] === `${process.platform}-${process.arch}` && runtimeSegments[3] === "bin") {
     return true;
   }
-  const payloadsRelative = path6.relative(
-    path6.join(homeDir, "runtime-payloads"),
-    path6.resolve(binDir)
+  const payloadsRelative = path7.relative(
+    path7.join(homeDir, "runtime-payloads"),
+    path7.resolve(binDir)
   );
-  const payloadSegments = payloadsRelative.split(path6.sep);
-  return payloadsRelative !== "" && payloadsRelative !== ".." && !payloadsRelative.startsWith(`..${path6.sep}`) && !path6.isAbsolute(payloadsRelative) && payloadSegments.length === 3 && payloadSegments[0] === RUNTIME_POSTGRES_PAYLOAD_DIR && payloadSegments[1] === `${process.platform}-${process.arch}` && payloadSegments[2] === "bin";
+  const payloadSegments = payloadsRelative.split(path7.sep);
+  return payloadsRelative !== "" && payloadsRelative !== ".." && !payloadsRelative.startsWith(`..${path7.sep}`) && !path7.isAbsolute(payloadsRelative) && payloadSegments.length === 3 && payloadSegments[0] === RUNTIME_POSTGRES_PAYLOAD_DIR && payloadSegments[1] === `${process.platform}-${process.arch}` && payloadSegments[2] === "bin";
 }
 async function findLegacyRuntimePostgresBinDir(cacheDir, homeDir, postgresVersionProbe) {
-  const runtimesRoot = path6.join(homeDir, "runtimes");
+  const runtimesRoot = path7.join(homeDir, "runtimes");
   const entries = await readdir(runtimesRoot, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const candidateCacheDir = path6.join(runtimesRoot, entry.name);
-    if (path6.resolve(candidateCacheDir) === path6.resolve(cacheDir)) continue;
+    const candidateCacheDir = path7.join(runtimesRoot, entry.name);
+    if (path7.resolve(candidateCacheDir) === path7.resolve(cacheDir)) continue;
     const candidateBinDir = resolveRuntimePostgresPayloadBinDir(candidateCacheDir);
     if (await isRuntimePostgresPayloadUsable(cacheDir, candidateBinDir, postgresVersionProbe)) {
       return candidateBinDir;
@@ -5618,13 +5642,13 @@ async function findLegacyRuntimePostgresBinDir(cacheDir, homeDir, postgresVersio
   return null;
 }
 async function readLiveRuntimeDescriptors(homeDir) {
-  const instancesRoot = path6.join(homeDir, "instances");
+  const instancesRoot = path7.join(homeDir, "instances");
   const entries = await readdir(instancesRoot, { withFileTypes: true }).catch(() => []);
   const descriptors = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     try {
-      const raw = JSON.parse(await readFile(path6.join(instancesRoot, entry.name, "runtime", "server.json"), "utf8"));
+      const raw = JSON.parse(await readFile(path7.join(instancesRoot, entry.name, "runtime", "server.json"), "utf8"));
       if (typeof raw.pid !== "number" || !Number.isInteger(raw.pid) || !isPidRunning(raw.pid) || typeof raw.version !== "string") {
         continue;
       }
@@ -5642,13 +5666,13 @@ async function assertSharedPostgresPayloadNotLive(cacheDir, homeDir, sharedBinDi
   const sharedPhysicalBinDir = await realpath(sharedBinDir).catch(() => null);
   const mayReferenceSharedPayload = await Promise.all(liveDescriptors.map(async (descriptor) => {
     if (descriptor.postgresBinDir === void 0) return true;
-    if (path6.resolve(descriptor.postgresBinDir) === path6.resolve(sharedBinDir)) return true;
+    if (path7.resolve(descriptor.postgresBinDir) === path7.resolve(sharedBinDir)) return true;
     const descriptorPhysicalBinDir = await realpath(descriptor.postgresBinDir).catch(() => null);
-    if (descriptorPhysicalBinDir && sharedPhysicalBinDir && path6.resolve(descriptorPhysicalBinDir) === path6.resolve(sharedPhysicalBinDir)) {
+    if (descriptorPhysicalBinDir && sharedPhysicalBinDir && path7.resolve(descriptorPhysicalBinDir) === path7.resolve(sharedPhysicalBinDir)) {
       return true;
     }
     if (!descriptorPhysicalBinDir) {
-      return pathIsInside(descriptor.postgresBinDir, path6.join(homeDir, "runtimes")) || pathIsInside(descriptor.postgresBinDir, path6.join(homeDir, "runtime-payloads"));
+      return pathIsInside(descriptor.postgresBinDir, path7.join(homeDir, "runtimes")) || pathIsInside(descriptor.postgresBinDir, path7.join(homeDir, "runtime-payloads"));
     }
     return false;
   }));
@@ -5662,7 +5686,7 @@ async function assertSharedPostgresPayloadNotLive(cacheDir, homeDir, sharedBinDi
 async function validateRuntimePostgresVersion(cacheDir, binDir, postgresVersionProbe) {
   await assertRuntimePostgresBinDirComplete(cacheDir, binDir);
   for (const binary of ["initdb", "pg_ctl", "postgres"]) {
-    const binaryPath = path6.join(binDir, runtimePostgresExecutableName(binary));
+    const binaryPath = path7.join(binDir, runtimePostgresExecutableName(binary));
     const result = postgresVersionProbe(binaryPath);
     if (!/\bPostgreSQL\)?\s+18\.4\b/i.test(result)) {
       throw new RuntimeInstallError(
@@ -5728,23 +5752,23 @@ async function findRuntimePostgresBinDir(rootDir, cacheDir, postgresVersionProbe
     if (await isRuntimePostgresPayloadUsable(cacheDir, current, postgresVersionProbe)) return current;
     const entries = await readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
-      if (entry.isDirectory()) queue.push(path6.join(current, entry.name));
+      if (entry.isDirectory()) queue.push(path7.join(current, entry.name));
     }
   }
   return null;
 }
 async function reconcileSharedPostgresPayloadGenerations(cacheDir, sharedPlatformRoot, postgresVersionProbe, cleanupDownloads = false) {
-  const parentDir = path6.dirname(sharedPlatformRoot);
-  const baseName = path6.basename(sharedPlatformRoot);
+  const parentDir = path7.dirname(sharedPlatformRoot);
+  const baseName = path7.basename(sharedPlatformRoot);
   const entries = await readdir(parentDir, { withFileTypes: true }).catch(() => []);
-  const temporaryRoots = entries.filter((entry) => entry.name.startsWith(`${baseName}.tmp-`)).map((entry) => path6.join(parentDir, entry.name));
-  const previousRoots = entries.filter((entry) => entry.name.startsWith(`${baseName}.previous-`)).map((entry) => path6.join(parentDir, entry.name)).sort().reverse();
-  const downloadsRoot = path6.join(
-    path6.dirname(path6.dirname(sharedPlatformRoot)),
+  const temporaryRoots = entries.filter((entry) => entry.name.startsWith(`${baseName}.tmp-`)).map((entry) => path7.join(parentDir, entry.name));
+  const previousRoots = entries.filter((entry) => entry.name.startsWith(`${baseName}.previous-`)).map((entry) => path7.join(parentDir, entry.name)).sort().reverse();
+  const downloadsRoot = path7.join(
+    path7.dirname(path7.dirname(sharedPlatformRoot)),
     ".downloads"
   );
-  const staleDownloadRoots = cleanupDownloads ? (await readdir(downloadsRoot, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.name.startsWith("postgres-18.4-")).map((entry) => path6.join(downloadsRoot, entry.name)) : [];
-  const canonicalBinDir = path6.join(sharedPlatformRoot, "bin");
+  const staleDownloadRoots = cleanupDownloads ? (await readdir(downloadsRoot, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.name.startsWith("postgres-18.4-")).map((entry) => path7.join(downloadsRoot, entry.name)) : [];
+  const canonicalBinDir = path7.join(sharedPlatformRoot, "bin");
   if (!await isRuntimePostgresPayloadUsable(
     cacheDir,
     canonicalBinDir,
@@ -5753,7 +5777,7 @@ async function reconcileSharedPostgresPayloadGenerations(cacheDir, sharedPlatfor
     for (const previousRoot of previousRoots) {
       if (!await isRuntimePostgresPayloadUsable(
         cacheDir,
-        path6.join(previousRoot, "bin"),
+        path7.join(previousRoot, "bin"),
         postgresVersionProbe
       )) {
         continue;
@@ -5771,9 +5795,9 @@ async function reconcileSharedPostgresPayloadGenerations(cacheDir, sharedPlatfor
 }
 async function installSharedRuntimePostgresPayload(cacheDir, homeDir, sourceBinDir, postgresVersionProbe) {
   const sharedBinDir = resolveSharedRuntimePostgresPayloadBinDir(homeDir);
-  const sharedRuntimeDir = path6.dirname(sharedBinDir);
+  const sharedRuntimeDir = path7.dirname(sharedBinDir);
   const sharedPlatformRoot = sharedRuntimeDir;
-  const sourceRuntimeDir = path6.dirname(sourceBinDir);
+  const sourceRuntimeDir = path7.dirname(sourceBinDir);
   const sourceTemplateDir = await resolveRuntimePostgresTemplateDir(sourceBinDir);
   if (!sourceTemplateDir) {
     throw new RuntimeInstallError(
@@ -5792,7 +5816,7 @@ async function installSharedRuntimePostgresPayload(cacheDir, homeDir, sourceBinD
       return sharedBinDir;
     }
     await assertSharedPostgresPayloadNotLive(cacheDir, homeDir, sharedBinDir);
-    await mkdir(path6.dirname(sharedPlatformRoot), { recursive: true });
+    await mkdir2(path7.dirname(sharedPlatformRoot), { recursive: true });
     const temporaryPlatformRoot = `${sharedPlatformRoot}.tmp-${process.pid}-${Date.now()}`;
     const previousPlatformRoot = `${sharedPlatformRoot}.previous-${process.pid}-${Date.now()}`;
     let previousMoved = false;
@@ -5801,13 +5825,13 @@ async function installSharedRuntimePostgresPayload(cacheDir, homeDir, sourceBinD
     await rm(previousPlatformRoot, { recursive: true, force: true });
     try {
       const temporaryRuntimeDir = temporaryPlatformRoot;
-      await cp(sourceRuntimeDir, temporaryRuntimeDir, { recursive: true, dereference: true });
-      const temporaryShareDir = path6.join(temporaryRuntimeDir, "share");
-      const temporaryTemplateDir = path6.join(temporaryShareDir, "postgresql");
+      await copyRuntimePostgresPayloadLibraries(sourceRuntimeDir, temporaryRuntimeDir);
+      const temporaryShareDir = path7.join(temporaryRuntimeDir, "share");
+      const temporaryTemplateDir = path7.join(temporaryShareDir, "postgresql");
       await rm(temporaryShareDir, { recursive: true, force: true });
-      await mkdir(path6.dirname(temporaryTemplateDir), { recursive: true });
-      await cp(sourceTemplateDir, temporaryTemplateDir, { recursive: true });
-      const temporaryBinDir = path6.join(temporaryRuntimeDir, "bin");
+      await mkdir2(path7.dirname(temporaryTemplateDir), { recursive: true });
+      await cp2(sourceTemplateDir, temporaryTemplateDir, { recursive: true });
+      const temporaryBinDir = path7.join(temporaryRuntimeDir, "bin");
       await validateRuntimePostgresVersion(cacheDir, temporaryBinDir, postgresVersionProbe);
       try {
         await rename(sharedPlatformRoot, previousPlatformRoot);
@@ -5842,19 +5866,19 @@ async function downloadSharedRuntimePostgresPayload(cacheDir, homeDir, postgresV
   const archiveUrl = runtimePostgresArchiveUrl();
   if (!archiveUrl) return null;
   const sharedBinDir = resolveSharedRuntimePostgresPayloadBinDir(homeDir);
-  const sharedPlatformRoot = path6.dirname(sharedBinDir);
+  const sharedPlatformRoot = path7.dirname(sharedBinDir);
   const downloadLockPath = `${sharedPlatformRoot}.download.lock`;
   return withRuntimeFilesystemLock(downloadLockPath, async () => {
     if (await isRuntimePostgresPayloadUsable(cacheDir, sharedBinDir, postgresVersionProbe)) {
       return sharedBinDir;
     }
-    const workRoot = path6.join(homeDir, "runtime-payloads", ".downloads");
-    await mkdir(workRoot, { recursive: true });
-    const workDir = await mkdtemp(path6.join(workRoot, "postgres-18.4-"));
-    const archivePath = path6.join(workDir, "postgresql-18.4.zip");
-    const extractDir = path6.join(workDir, "extract");
+    const workRoot = path7.join(homeDir, "runtime-payloads", ".downloads");
+    await mkdir2(workRoot, { recursive: true });
+    const workDir = await mkdtemp(path7.join(workRoot, "postgres-18.4-"));
+    const archivePath = path7.join(workDir, "postgresql-18.4.zip");
+    const extractDir = path7.join(workDir, "extract");
     try {
-      await mkdir(extractDir, { recursive: true });
+      await mkdir2(extractDir, { recursive: true });
       await downloadRuntimePostgresArchive(archiveUrl, archivePath);
       extractRuntimePostgresArchive(archivePath, extractDir);
       const extractedBinDir = await findRuntimePostgresBinDir(
@@ -5880,20 +5904,20 @@ async function downloadSharedRuntimePostgresPayload(cacheDir, homeDir, postgresV
   });
 }
 async function ensureRuntimePostgresCompatibilityLink(cacheDir, homeDir, packageVersion) {
-  const compatibilityRoot = path6.join(cacheDir, RUNTIME_POSTGRES_PAYLOAD_DIR);
-  const sharedPayloadRoot = path6.join(homeDir, "runtime-payloads", RUNTIME_POSTGRES_PAYLOAD_DIR);
+  const compatibilityRoot = path7.join(cacheDir, RUNTIME_POSTGRES_PAYLOAD_DIR);
+  const sharedPayloadRoot = path7.join(homeDir, "runtime-payloads", RUNTIME_POSTGRES_PAYLOAD_DIR);
   const runtimeMetadata = await readRuntimeInstallMetadata(cacheDir);
   const liveDescriptors = await readLiveRuntimeDescriptors(homeDir);
   const compatibilityBinDir = resolveRuntimePostgresPayloadBinDir(cacheDir);
   const isProtected = liveDescriptors.some((descriptor) => descriptor.postgresBinDir && pathIsInside(descriptor.postgresBinDir, compatibilityRoot) || !descriptor.postgresBinDir && descriptor.version === (runtimeMetadata?.packageVersion ?? packageVersion));
   if (isProtected) return;
-  await mkdir(path6.dirname(compatibilityRoot), { recursive: true });
+  await mkdir2(path7.dirname(compatibilityRoot), { recursive: true });
   const temporaryRoot = `${compatibilityRoot}.next-${process.pid}-${Date.now()}`;
   const previousRoot = `${compatibilityRoot}.previous-${process.pid}-${Date.now()}`;
   await rm(temporaryRoot, { recursive: true, force: true });
   await rm(previousRoot, { recursive: true, force: true });
   await symlink(
-    process.platform === "win32" ? sharedPayloadRoot : path6.relative(path6.dirname(compatibilityRoot), sharedPayloadRoot),
+    process.platform === "win32" ? sharedPayloadRoot : path7.relative(path7.dirname(compatibilityRoot), sharedPayloadRoot),
     temporaryRoot,
     process.platform === "win32" ? "junction" : "dir"
   );
@@ -5926,7 +5950,7 @@ async function ensureRuntimePostgresCompatibilityLink(cacheDir, homeDir, package
 async function stageRuntimePostgresPayload(cacheDir, homeDir, packageVersion, enabled, postgresVersionProbe) {
   if (!enabled) return { output: "" };
   const explicitSourceBinDir = process.env[RUDDER_POSTGRES_BIN_DIR_ENV]?.trim();
-  const resolvedExplicitSourceBinDir = explicitSourceBinDir ? path6.resolve(explicitSourceBinDir) : null;
+  const resolvedExplicitSourceBinDir = explicitSourceBinDir ? path7.resolve(explicitSourceBinDir) : null;
   if (resolvedExplicitSourceBinDir && !isManagedRuntimePostgresBinDir(resolvedExplicitSourceBinDir, homeDir)) {
     await validateRuntimePostgresVersion(
       cacheDir,
@@ -5946,7 +5970,7 @@ async function stageRuntimePostgresPayload(cacheDir, homeDir, packageVersion, en
     };
   }
   const sharedBinDir = resolveSharedRuntimePostgresPayloadBinDir(homeDir);
-  const sharedPlatformRoot = path6.dirname(sharedBinDir);
+  const sharedPlatformRoot = path7.dirname(sharedBinDir);
   await withRuntimeFilesystemLock(
     `${sharedPlatformRoot}.install.lock`,
     async () => reconcileSharedPostgresPayloadGenerations(
@@ -6052,13 +6076,13 @@ async function pruneRuntimeCache(options = {}) {
   };
 }
 async function scanRuntimeCacheEntries(homeDir) {
-  const runtimesDir = path6.join(homeDir, "runtimes");
+  const runtimesDir = path7.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 cacheDir = path7.join(runtimesDir, dirent.name);
     const metadata = await readRuntimeInstallMetadata(cacheDir);
     if (!metadata) continue;
     const fallbackStat = await safeStat(cacheDir);
@@ -6081,7 +6105,7 @@ function parseTimestampMs(value) {
 }
 async function safeStat(targetPath) {
   try {
-    return await stat(targetPath);
+    return await stat2(targetPath);
   } catch {
     return null;
   }
@@ -6091,7 +6115,7 @@ async function directorySizeBytes(targetPath) {
   if (!dirents) return 0;
   let total = 0;
   for (const dirent of dirents) {
-    const entryPath = path6.join(targetPath, dirent.name);
+    const entryPath = path7.join(targetPath, dirent.name);
     if (dirent.isSymbolicLink()) continue;
     if (dirent.isDirectory()) {
       total += await directorySizeBytes(entryPath);
@@ -6103,14 +6127,14 @@ async function directorySizeBytes(targetPath) {
   return total;
 }
 async function readActiveRuntimeVersions(homeDir) {
-  const instancesDir = path6.join(homeDir, "instances");
+  const instancesDir = path7.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 descriptorPath = path7.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)) {
@@ -6224,6 +6248,7 @@ var init_install = __esm({
   "src/runtime/install.ts"() {
     "use strict";
     init_home();
+    init_postgres_payload();
     RUNTIME_NPM_PACKAGE_NAME = "@rudderhq/server";
     NPM_PUBLIC_REGISTRY_URL = "https://registry.npmjs.org";
     RUNTIME_METADATA_FILE = "runtime.json";
@@ -6267,7 +6292,7 @@ var init_install = __esm({
 
 // src/runtime/server-entry.ts
 import fs4 from "node:fs";
-import path7 from "node:path";
+import path8 from "node:path";
 import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL2 } from "node:url";
 function formatError(err) {
   if (err instanceof Error) {
@@ -6289,8 +6314,8 @@ function maybeEnableUiDevMiddleware(entrypoint) {
   }
 }
 function resolveDevServerEntry() {
-  const projectRoot = path7.resolve(path7.dirname(fileURLToPath4(import.meta.url)), "../../..");
-  return path7.resolve(projectRoot, "server/src/index.ts");
+  const projectRoot = path8.resolve(path8.dirname(fileURLToPath4(import.meta.url)), "../../..");
+  return path8.resolve(projectRoot, "server/src/index.ts");
 }
 async function loadServerRuntimeModule(options) {
   const devEntry = resolveDevServerEntry();
@@ -6430,21 +6455,21 @@ var init_auth_bootstrap_ceo = __esm({
 
 // src/utils/path-resolver.ts
 import fs9 from "node:fs";
-import path18 from "node:path";
+import path19 from "node:path";
 function unique(items) {
   return Array.from(new Set(items));
 }
 function resolveRuntimeLikePath(value, configPath) {
   const expanded = expandHomePrefix(value);
-  if (path18.isAbsolute(expanded)) return path18.resolve(expanded);
+  if (path19.isAbsolute(expanded)) return path19.resolve(expanded);
   const cwd = process.cwd();
-  const configDir = configPath ? path18.dirname(configPath) : null;
-  const workspaceRoot = configDir ? path18.resolve(configDir, "..") : cwd;
+  const configDir = configPath ? path19.dirname(configPath) : null;
+  const workspaceRoot = configDir ? path19.resolve(configDir, "..") : cwd;
   const candidates = unique([
-    ...configDir ? [path18.resolve(configDir, expanded)] : [],
-    path18.resolve(workspaceRoot, "server", expanded),
-    path18.resolve(workspaceRoot, expanded),
-    path18.resolve(cwd, expanded)
+    ...configDir ? [path19.resolve(configDir, expanded)] : [],
+    path19.resolve(workspaceRoot, "server", expanded),
+    path19.resolve(workspaceRoot, expanded),
+    path19.resolve(cwd, expanded)
   ]);
   return candidates.find((candidate) => fs9.existsSync(candidate)) ?? candidates[0];
 }
@@ -6458,7 +6483,7 @@ var init_path_resolver = __esm({
 // src/config/secrets-key.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 import fs10 from "node:fs";
-import path19 from "node:path";
+import path20 from "node:path";
 function ensureLocalSecretsKeyFile(config, configPath) {
   if (config.secrets.provider !== "local_encrypted") {
     return { status: "skipped_provider", path: null };
@@ -6473,7 +6498,7 @@ function ensureLocalSecretsKeyFile(config, configPath) {
   if (fs10.existsSync(keyFilePath)) {
     return { status: "existing", path: keyFilePath };
   }
-  fs10.mkdirSync(path19.dirname(keyFilePath), { recursive: true });
+  fs10.mkdirSync(path20.dirname(keyFilePath), { recursive: true });
   fs10.writeFileSync(keyFilePath, randomBytes2(32).toString("base64"), {
     encoding: "utf8",
     mode: 384
@@ -7559,7 +7584,7 @@ var init_port_check = __esm({
 // src/checks/secrets-check.ts
 import { randomBytes as randomBytes3 } from "node:crypto";
 import fs13 from "node:fs";
-import path20 from "node:path";
+import path21 from "node:path";
 function decodeMasterKey(raw) {
   const trimmed = raw.trim();
   if (!trimmed) return null;
@@ -7629,7 +7654,7 @@ function secretsCheck(config, configPath) {
         message: `Secrets key file does not exist yet: ${keyFilePath}`,
         canRepair: true,
         repair: () => {
-          fs13.mkdirSync(path20.dirname(keyFilePath), { recursive: true });
+          fs13.mkdirSync(path21.dirname(keyFilePath), { recursive: true });
           fs13.writeFileSync(keyFilePath, randomBytes3(32).toString("base64"), {
             encoding: "utf8",
             mode: 384
@@ -8202,7 +8227,7 @@ var init_run = __esm({
 
 // src/commands/onboard.ts
 import * as p14 from "@clack/prompts";
-import path21 from "node:path";
+import path22 from "node:path";
 import pc14 from "picocolors";
 function parseBooleanFromEnv(rawValue) {
   if (rawValue === void 0) return null;
@@ -8235,7 +8260,7 @@ function parseEnumFromEnv(rawValue, allowedValues) {
 }
 function resolvePathFromEnv(rawValue) {
   if (!rawValue || rawValue.trim().length === 0) return null;
-  return path21.resolve(expandHomePrefix(rawValue.trim()));
+  return path22.resolve(expandHomePrefix(rawValue.trim()));
 }
 function quickstartDefaultsFromEnv() {
   const instanceId = resolveRudderInstanceId();
@@ -11397,41 +11422,41 @@ var RudderApiClient = class {
     this.signal = opts.signal;
     this.recoverAuth = opts.recoverAuth;
   }
-  get(path24, opts) {
-    return this.request(path24, { method: "GET" }, opts);
+  get(path25, opts) {
+    return this.request(path25, { method: "GET" }, opts);
   }
-  post(path24, body, opts) {
-    return this.request(path24, {
+  post(path25, body, opts) {
+    return this.request(path25, {
       method: "POST",
       body: body === void 0 ? void 0 : JSON.stringify(body)
     }, opts);
   }
-  postForm(path24, form, opts) {
-    return this.request(path24, {
+  postForm(path25, form, opts) {
+    return this.request(path25, {
       method: "POST",
       body: form
     }, opts);
   }
-  patch(path24, body, opts) {
-    return this.request(path24, {
+  patch(path25, body, opts) {
+    return this.request(path25, {
       method: "PATCH",
       body: body === void 0 ? void 0 : JSON.stringify(body)
     }, opts);
   }
-  put(path24, body, opts) {
-    return this.request(path24, {
+  put(path25, body, opts) {
+    return this.request(path25, {
       method: "PUT",
       body: body === void 0 ? void 0 : JSON.stringify(body)
     }, opts);
   }
-  delete(path24, opts) {
-    return this.request(path24, { method: "DELETE" }, opts);
+  delete(path25, opts) {
+    return this.request(path25, { method: "DELETE" }, opts);
   }
   setApiKey(apiKey) {
     this.apiKey = apiKey?.trim() || void 0;
   }
-  async request(path24, init, opts, hasRetriedAuth = false) {
-    const url = buildUrl(this.apiBase, path24);
+  async request(path25, init, opts, hasRetriedAuth = false) {
+    const url = buildUrl(this.apiBase, path25);
     const headers = {
       accept: "application/json",
       ...toStringRecord(init.headers)
@@ -11462,13 +11487,13 @@ var RudderApiClient = class {
       const apiError = await toApiError(response);
       if (!hasRetriedAuth && this.recoverAuth) {
         const recoveredToken = await this.recoverAuth({
-          path: path24,
+          path: path25,
           method: String(init.method ?? "GET").toUpperCase(),
           error: apiError
         });
         if (recoveredToken) {
           this.setApiKey(recoveredToken);
-          return this.request(path24, init, opts, true);
+          return this.request(path25, init, opts, true);
         }
       }
       throw apiError;
@@ -11487,8 +11512,8 @@ function shouldAttachAgentContext(method) {
   const normalized = String(method ?? "GET").toUpperCase();
   return normalized !== "GET" && normalized !== "HEAD";
 }
-function buildUrl(apiBase, path24) {
-  const normalizedPath = path24.startsWith("/") ? path24 : `/${path24}`;
+function buildUrl(apiBase, path25) {
+  const normalizedPath = path25.startsWith("/") ? path25 : `/${path25}`;
   const [pathname, query] = normalizedPath.split("?");
   const url = new URL2(apiBase);
   url.pathname = `${url.pathname.replace(/\/+$/, "")}${pathname}`;
@@ -12782,7 +12807,7 @@ import pc4 from "picocolors";
 init_home();
 import { spawn as spawn2 } from "node:child_process";
 import fs5 from "node:fs";
-import path8 from "node:path";
+import path9 from "node:path";
 import pc3 from "picocolors";
 
 // src/client/command-label.ts
@@ -12805,8 +12830,8 @@ function normalizeApiBase(apiBase) {
   return apiBase.trim().replace(/\/+$/, "");
 }
 function resolveBoardAuthStorePath(overridePath) {
-  if (overridePath?.trim()) return path8.resolve(overridePath.trim());
-  if (process.env.RUDDER_AUTH_STORE?.trim()) return path8.resolve(process.env.RUDDER_AUTH_STORE.trim());
+  if (overridePath?.trim()) return path9.resolve(overridePath.trim());
+  if (process.env.RUDDER_AUTH_STORE?.trim()) return path9.resolve(process.env.RUDDER_AUTH_STORE.trim());
   return resolveDefaultCliAuthPath();
 }
 function readBoardAuthStore(storePath) {
@@ -12838,7 +12863,7 @@ function readBoardAuthStore(storePath) {
 }
 function writeBoardAuthStore(store, storePath) {
   const filePath = resolveBoardAuthStorePath(storePath);
-  fs5.mkdirSync(path8.dirname(filePath), { recursive: true });
+  fs5.mkdirSync(path9.dirname(filePath), { recursive: true });
   fs5.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}
 `, { mode: 384 });
 }
@@ -12986,26 +13011,26 @@ async function revokeStoredBoardCredential(params) {
 // src/client/context.ts
 init_home();
 import fs6 from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
 var DEFAULT_CONTEXT_BASENAME = "context.json";
 var DEFAULT_PROFILE = "default";
 function findContextFileFromAncestors(startDir) {
-  const absoluteStartDir = path9.resolve(startDir);
+  const absoluteStartDir = path10.resolve(startDir);
   let currentDir = absoluteStartDir;
   while (true) {
-    const candidate = path9.resolve(currentDir, ".rudder", DEFAULT_CONTEXT_BASENAME);
+    const candidate = path10.resolve(currentDir, ".rudder", DEFAULT_CONTEXT_BASENAME);
     if (fs6.existsSync(candidate)) {
       return candidate;
     }
-    const nextDir = path9.resolve(currentDir, "..");
+    const nextDir = path10.resolve(currentDir, "..");
     if (nextDir === currentDir) break;
     currentDir = nextDir;
   }
   return null;
 }
 function resolveContextPath(overridePath) {
-  if (overridePath) return path9.resolve(overridePath);
-  if (process.env.RUDDER_CONTEXT) return path9.resolve(process.env.RUDDER_CONTEXT);
+  if (overridePath) return path10.resolve(overridePath);
+  if (process.env.RUDDER_CONTEXT) return path10.resolve(process.env.RUDDER_CONTEXT);
   return findContextFileFromAncestors(process.cwd()) ?? resolveDefaultContextPath();
 }
 function defaultClientContext() {
@@ -13073,7 +13098,7 @@ function readContext(contextPath) {
 }
 function writeContext(context, contextPath) {
   const filePath = resolveContextPath(contextPath);
-  const dir = path9.dirname(filePath);
+  const dir = path10.dirname(filePath);
   fs6.mkdirSync(dir, { recursive: true });
   const normalized = normalizeContext(context);
   fs6.writeFileSync(filePath, `${JSON.stringify(normalized, null, 2)}
@@ -13402,8 +13427,8 @@ function registerActivityCommands(program) {
         if (opts.entityType) params.set("entityType", opts.entityType);
         if (opts.entityId) params.set("entityId", opts.entityId);
         const query = params.toString();
-        const path24 = `/api/orgs/${ctx.orgId}/activity${query ? `?${query}` : ""}`;
-        const rows = await ctx.api.get(path24) ?? [];
+        const path25 = `/api/orgs/${ctx.orgId}/activity${query ? `?${query}` : ""}`;
+        const rows = await ctx.api.get(path25) ?? [];
         if (ctx.json) {
           printOutput(rows, { json: true });
           return;
@@ -13435,7 +13460,7 @@ function registerActivityCommands(program) {
 
 // ../packages/agent-runtime-utils/dist/server-utils.cli.js
 import { promises as fs7 } from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 
 // ../packages/agent-runtime-utils/dist/server-utils.process.js
 var MAX_CAPTURE_BYTES = 4 * 1024 * 1024;
@@ -13685,8 +13710,8 @@ var RUDDER_AGENT_HEARTBEAT_INSTRUCTION = [
 // ../packages/agent-runtime-utils/dist/server-utils.cli.js
 async function resolveRudderSkillsDir(moduleDir, additionalCandidates = []) {
   const candidates = [
-    ...RUDDER_SKILL_ROOT_RELATIVE_CANDIDATES.map((relativePath) => path10.resolve(moduleDir, relativePath)),
-    ...additionalCandidates.map((candidate) => path10.resolve(candidate))
+    ...RUDDER_SKILL_ROOT_RELATIVE_CANDIDATES.map((relativePath) => path11.resolve(moduleDir, relativePath)),
+    ...additionalCandidates.map((candidate) => path11.resolve(candidate))
   ];
   const seenRoots = /* @__PURE__ */ new Set();
   for (const root of candidates) {
@@ -13703,26 +13728,26 @@ async function removeMaintainerOnlySkillSymlinks(skillsHome, allowedSkillNames)
   return removeUnselectedRudderSkillSymlinks(skillsHome, allowedSkillNames);
 }
 async function readRudderMaterializedSkillSource(target) {
-  const manifestPath = path10.join(target, ".rudder", "materialized-skill.json");
+  const manifestPath = path11.join(target, ".rudder", "materialized-skill.json");
   const raw = await fs7.readFile(manifestPath, "utf8").catch(() => null);
   if (!raw)
     return null;
   try {
     const parsed = parseObject(JSON.parse(raw));
     const sourcePath = asString(parsed.sourcePath, "").trim();
-    return sourcePath.length > 0 ? path10.resolve(sourcePath) : null;
+    return sourcePath.length > 0 ? path11.resolve(sourcePath) : null;
   } catch {
     return null;
   }
 }
 async function removeUnselectedRudderSkillSymlinks(skillsHome, allowedSkillNames, knownSkillSources = []) {
   const allowed = new Set(Array.from(allowedSkillNames));
-  const knownSources = new Set(Array.from(knownSkillSources).map((value) => value.trim()).filter(Boolean).map((value) => path10.resolve(value)));
+  const knownSources = new Set(Array.from(knownSkillSources).map((value) => value.trim()).filter(Boolean).map((value) => path11.resolve(value)));
   try {
     const entries = await fs7.readdir(skillsHome, { withFileTypes: true });
     const removed = [];
     for (const entry of entries) {
-      const target = path10.join(skillsHome, entry.name);
+      const target = path11.join(skillsHome, entry.name);
       const existing = await fs7.lstat(target).catch(() => null);
       if (!existing)
         continue;
@@ -13731,8 +13756,8 @@ async function removeUnselectedRudderSkillSymlinks(skillsHome, allowedSkillNames
         const linkedPath = await fs7.readlink(target).catch(() => null);
         if (!linkedPath)
           continue;
-        const resolvedLinkedPath = path10.isAbsolute(linkedPath) ? linkedPath : path10.resolve(path10.dirname(target), linkedPath);
-        isRudderManagedSkill = knownSources.has(path10.resolve(resolvedLinkedPath)) || isMaintainerOnlySkillTarget(linkedPath) || isMaintainerOnlySkillTarget(resolvedLinkedPath);
+        const resolvedLinkedPath = path11.isAbsolute(linkedPath) ? linkedPath : path11.resolve(path11.dirname(target), linkedPath);
+        isRudderManagedSkill = knownSources.has(path11.resolve(resolvedLinkedPath)) || isMaintainerOnlySkillTarget(linkedPath) || isMaintainerOnlySkillTarget(resolvedLinkedPath);
       } else if (existing.isDirectory()) {
         const materializedSource = await readRudderMaterializedSkillSource(target);
         isRudderManagedSkill = materializedSource !== null && knownSources.has(materializedSource);
@@ -13754,7 +13779,7 @@ async function removeUnselectedRudderSkillSymlinks(skillsHome, allowedSkillNames
 init_dist();
 import fs8 from "node:fs/promises";
 import os3 from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/commands/client/help.ts
@@ -13778,16 +13803,16 @@ function formatHelpExample(example) {
 }
 
 // src/commands/client/agent.ts
-var __moduleDir = path11.dirname(fileURLToPath5(import.meta.url));
+var __moduleDir = path12.dirname(fileURLToPath5(import.meta.url));
 function codexSkillsHome() {
   const fromEnv = process.env.CODEX_HOME?.trim();
-  const base = fromEnv && fromEnv.length > 0 ? fromEnv : path11.join(os3.homedir(), ".codex");
-  return path11.join(base, "skills");
+  const base = fromEnv && fromEnv.length > 0 ? fromEnv : path12.join(os3.homedir(), ".codex");
+  return path12.join(base, "skills");
 }
 function claudeSkillsHome() {
   const fromEnv = process.env.CLAUDE_HOME?.trim();
-  const base = fromEnv && fromEnv.length > 0 ? fromEnv : path11.join(os3.homedir(), ".claude");
-  return path11.join(base, "skills");
+  const base = fromEnv && fromEnv.length > 0 ? fromEnv : path12.join(os3.homedir(), ".claude");
+  return path12.join(base, "skills");
 }
 async function installSkillsForTarget(sourceSkillsDir, targetSkillsDir, tool) {
   const summary = {
@@ -13806,8 +13831,8 @@ async function installSkillsForTarget(sourceSkillsDir, targetSkillsDir, tool) {
   );
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const source = path11.join(sourceSkillsDir, entry.name);
-    const target = path11.join(targetSkillsDir, entry.name);
+    const source = path12.join(sourceSkillsDir, entry.name);
+    const target = path12.join(targetSkillsDir, entry.name);
     const existing = await fs8.lstat(target).catch(() => null);
     if (existing) {
       if (existing.isSymbolicLink()) {
@@ -13828,7 +13853,7 @@ async function installSkillsForTarget(sourceSkillsDir, targetSkillsDir, tool) {
             continue;
           }
         }
-        const resolvedLinkedPath = path11.isAbsolute(linkedPath) ? linkedPath : path11.resolve(path11.dirname(target), linkedPath);
+        const resolvedLinkedPath = path12.isAbsolute(linkedPath) ? linkedPath : path12.resolve(path12.dirname(target), linkedPath);
         const linkedTargetExists = await fs8.stat(resolvedLinkedPath).then(() => true).catch(() => false);
         if (!linkedTargetExists) {
           await fs8.unlink(target);
@@ -14055,7 +14080,7 @@ function registerAgentCommands(program) {
         if (opts.markdown && opts.markdownFile) {
           throw new Error("Pass only one of --markdown or --markdown-file.");
         }
-        const markdown = opts.markdownFile ? await fs8.readFile(path11.resolve(opts.markdownFile), "utf8") : opts.markdown;
+        const markdown = opts.markdownFile ? await fs8.readFile(path12.resolve(opts.markdownFile), "utf8") : opts.markdown;
         const payload = organizationSkillCreateSchema.parse({
           name: opts.name,
           slug: opts.slug?.trim() || null,
@@ -14234,7 +14259,7 @@ function registerAgentCommands(program) {
         }
         const installSummaries = [];
         if (opts.installSkills !== false) {
-          const skillsDir = await resolveRudderSkillsDir(__moduleDir, [path11.resolve(process.cwd(), "skills")]);
+          const skillsDir = await resolveRudderSkillsDir(__moduleDir, [path12.resolve(process.cwd(), "skills")]);
           if (!skillsDir) {
             throw new Error(
               "Could not locate local Rudder skills directory. Expected ./skills in the repo checkout."
@@ -14327,10 +14352,10 @@ async function buildAgentUpdatePatch(opts) {
   if (opts.capabilities !== void 0) rawPatch.capabilities = opts.capabilities;
   if (opts.description !== void 0) rawPatch.capabilities = opts.description;
   if (opts.capabilitiesFile !== void 0) {
-    rawPatch.capabilities = await fs8.readFile(path11.resolve(opts.capabilitiesFile), "utf8");
+    rawPatch.capabilities = await fs8.readFile(path12.resolve(opts.capabilitiesFile), "utf8");
   }
   if (opts.descriptionFile !== void 0) {
-    rawPatch.capabilities = await fs8.readFile(path11.resolve(opts.descriptionFile), "utf8");
+    rawPatch.capabilities = await fs8.readFile(path12.resolve(opts.descriptionFile), "utf8");
   }
   if (clearCapabilities) rawPatch.capabilities = null;
   return updateAgentSchema.parse(rawPatch);
@@ -14354,7 +14379,7 @@ function parseJsonObject(value, name) {
 // src/commands/client/approval.ts
 init_dist();
 import { readFile as readFile2 } from "node:fs/promises";
-import path12 from "node:path";
+import path13 from "node:path";
 function registerApprovalCommands(program) {
   const approval = program.command("approval").description("Approval operations");
   addCommonClientOptions(
@@ -14545,7 +14570,7 @@ async function readTextInputFile(inputPath, optionName) {
   if (inputPath === "-") {
     return readStdinText();
   }
-  const resolvedPath = path12.resolve(process.cwd(), inputPath);
+  const resolvedPath = path13.resolve(process.cwd(), inputPath);
   return readFile2(resolvedPath, "utf8").catch((err) => {
     throw new Error(`Unable to read ${optionName} ${inputPath}: ${err instanceof Error ? err.message : String(err)}`);
   });
@@ -15382,12 +15407,12 @@ async function readStdin() {
 
 // src/commands/client/company.ts
 import * as p3 from "@clack/prompts";
-import { mkdir as mkdir2, readdir as readdir2, readFile as readFile3, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
-import path14 from "node:path";
+import { mkdir as mkdir3, readdir as readdir2, readFile as readFile3, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
+import path15 from "node:path";
 import pc5 from "picocolors";
 
 // src/commands/client/zip.ts
-import path13 from "node:path";
+import path14 from "node:path";
 import { inflateRawSync } from "node:zlib";
 var textDecoder = new TextDecoder();
 var binaryContentTypeByExtension = {
@@ -15415,7 +15440,7 @@ function sharedArchiveRoot(paths) {
   return firstSegments.every((parts) => parts.length > 1 && parts[0] === candidate) ? candidate : null;
 }
 function bytesToPortableFileEntry(pathValue, bytes) {
-  const contentType = binaryContentTypeByExtension[path13.extname(pathValue).toLowerCase()];
+  const contentType = binaryContentTypeByExtension[path14.extname(pathValue).toLowerCase()];
   if (!contentType) return textDecoder.decode(bytes);
   return {
     encoding: "base64",
@@ -15503,7 +15528,7 @@ var IMPORT_INCLUDE_OPTIONS = [
 ];
 var IMPORT_PREVIEW_SAMPLE_LIMIT = 6;
 function readPortableFileEntry(filePath, contents) {
-  const contentType = binaryContentTypeByExtension[path14.extname(filePath).toLowerCase()];
+  const contentType = binaryContentTypeByExtension[path15.extname(filePath).toLowerCase()];
   if (!contentType) return contents.toString("utf8");
   return {
     encoding: "base64",
@@ -15558,10 +15583,10 @@ function normalizePortablePath(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function shouldIncludePortableFile(filePath) {
-  const baseName = path14.basename(filePath);
+  const baseName = path15.basename(filePath);
   const isMarkdown = baseName.endsWith(".md");
   const isPaperclipYaml = baseName === ".rudder.yaml" || baseName === ".rudder.yml";
-  const contentType = binaryContentTypeByExtension[path14.extname(baseName).toLowerCase()];
+  const contentType = binaryContentTypeByExtension[path15.extname(baseName).toLowerCase()];
   return isMarkdown || isPaperclipYaml || Boolean(contentType);
 }
 function findPortableExtensionPath(files) {
@@ -16116,7 +16141,7 @@ function normalizeGithubImportSource(input, refOverride) {
 }
 async function pathExists(inputPath) {
   try {
-    await stat2(path14.resolve(inputPath));
+    await stat3(path15.resolve(inputPath));
     return true;
   } catch {
     return false;
@@ -16126,45 +16151,45 @@ async function collectPackageFiles(root, current, files) {
   const entries = await readdir2(current, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name.startsWith(".git")) continue;
-    const absolutePath = path14.join(current, entry.name);
+    const absolutePath = path15.join(current, entry.name);
     if (entry.isDirectory()) {
       await collectPackageFiles(root, absolutePath, files);
       continue;
     }
     if (!entry.isFile()) continue;
-    const relativePath = path14.relative(root, absolutePath).replace(/\\/g, "/");
+    const relativePath = path15.relative(root, absolutePath).replace(/\\/g, "/");
     if (!shouldIncludePortableFile(relativePath)) continue;
     files[relativePath] = readPortableFileEntry(relativePath, await readFile3(absolutePath));
   }
 }
 async function resolveInlineSourceFromPath(inputPath) {
-  const resolved = path14.resolve(inputPath);
-  const resolvedStat = await stat2(resolved);
-  if (resolvedStat.isFile() && path14.extname(resolved).toLowerCase() === ".zip") {
+  const resolved = path15.resolve(inputPath);
+  const resolvedStat = await stat3(resolved);
+  if (resolvedStat.isFile() && path15.extname(resolved).toLowerCase() === ".zip") {
     const archive = await readZipArchive(await readFile3(resolved));
     const filteredFiles = Object.fromEntries(
       Object.entries(archive.files).filter(([relativePath]) => shouldIncludePortableFile(relativePath))
     );
     return {
-      rootPath: archive.rootPath ?? path14.basename(resolved, ".zip"),
+      rootPath: archive.rootPath ?? path15.basename(resolved, ".zip"),
       files: filteredFiles
     };
   }
-  const rootDir = resolvedStat.isDirectory() ? resolved : path14.dirname(resolved);
+  const rootDir = resolvedStat.isDirectory() ? resolved : path15.dirname(resolved);
   const files = {};
   await collectPackageFiles(rootDir, rootDir, files);
   return {
-    rootPath: path14.basename(rootDir),
+    rootPath: path15.basename(rootDir),
     files
   };
 }
 async function writeExportToFolder(outDir, exported) {
-  const root = path14.resolve(outDir);
-  await mkdir2(root, { recursive: true });
+  const root = path15.resolve(outDir);
+  await mkdir3(root, { recursive: true });
   for (const [relativePath, content] of Object.entries(exported.files)) {
     const normalized = relativePath.replace(/\\/g, "/");
-    const filePath = path14.join(root, normalized);
-    await mkdir2(path14.dirname(filePath), { recursive: true });
+    const filePath = path15.join(root, normalized);
+    await mkdir3(path15.dirname(filePath), { recursive: true });
     const writeValue = portableFileEntryToWriteValue(content);
     if (typeof writeValue === "string") {
       await writeFile2(filePath, writeValue, "utf8");
@@ -16174,8 +16199,8 @@ async function writeExportToFolder(outDir, exported) {
   }
 }
 async function confirmOverwriteExportDirectory(outDir) {
-  const root = path14.resolve(outDir);
-  const stats = await stat2(root).catch(() => null);
+  const root = path15.resolve(outDir);
+  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.`);
@@ -16324,7 +16349,7 @@ function registerCompanyCommands(program) {
         printOutput(
           {
             ok: true,
-            out: path14.resolve(opts.out),
+            out: path15.resolve(opts.out),
             rootPath: exported.rootPath,
             filesWritten: Object.keys(exported.files).length,
             rudderExtensionPath: exported.rudderExtensionPath,
@@ -16685,8 +16710,8 @@ function registerDashboardCommands(program) {
 
 // src/commands/client/issue.ts
 init_dist();
-import { readFile as readFile4, stat as stat3 } from "node:fs/promises";
-import path15 from "node:path";
+import { readFile as readFile4, stat as stat4 } from "node:fs/promises";
+import path16 from "node:path";
 function registerIssueCommands(program) {
   const issue = program.command("issue").description("Issue operations");
   addCommonClientOptions(
@@ -17050,7 +17075,7 @@ async function readTextInputFile2(inputPath, optionName) {
   if (inputPath === "-") {
     return readStdinText2();
   }
-  const resolvedPath = path15.resolve(process.cwd(), inputPath);
+  const resolvedPath = path16.resolve(process.cwd(), inputPath);
   return readFile4(resolvedPath, "utf8").catch((err) => {
     throw new Error(`Unable to read ${optionName} ${inputPath}: ${err instanceof Error ? err.message : String(err)}`);
   });
@@ -17107,14 +17132,14 @@ async function appendUploadedIssueImages(ctx, issueId, body, imagePaths) {
 ${imageBlock}` : imageBlock;
 }
 async function uploadIssueCommentImage(ctx, issue, imagePath) {
-  const resolvedPath = path15.resolve(process.cwd(), imagePath);
-  const stats = await stat3(resolvedPath).catch((err) => {
+  const resolvedPath = path16.resolve(process.cwd(), imagePath);
+  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()) {
     throw new Error(`Image path must be a file: ${imagePath}`);
   }
-  const filename = path15.basename(resolvedPath);
+  const filename = path16.basename(resolvedPath);
   const contentType = inferCommentImageContentType(filename);
   const buffer = await readFile4(resolvedPath);
   if (buffer.length <= 0) {
@@ -17133,7 +17158,7 @@ async function uploadIssueCommentImage(ctx, issue, imagePath) {
   return attachment;
 }
 function inferCommentImageContentType(filename) {
-  const ext = path15.extname(filename).toLowerCase();
+  const ext = path16.extname(filename).toLowerCase();
   switch (ext) {
     case ".png":
       return "image/png";
@@ -17237,7 +17262,7 @@ function formatIssueSearchMatch(match) {
 
 // src/commands/client/library.ts
 import { readFile as readFile5 } from "node:fs/promises";
-import path16 from "node:path";
+import path17 from "node:path";
 function toLibraryFileLinkResult(detail) {
   return {
     filePath: detail.filePath,
@@ -17382,7 +17407,7 @@ async function resolveBodyFileInput(inputPath) {
   if (inputPath === "-") {
     return readStdinText3();
   }
-  const resolvedPath = path16.resolve(process.cwd(), inputPath);
+  const resolvedPath = path17.resolve(process.cwd(), inputPath);
   return readFile5(resolvedPath, "utf8").catch((err) => {
     throw new Error(`Unable to read --body-file ${inputPath}: ${err instanceof Error ? err.message : String(err)}`);
   });
@@ -17396,16 +17421,16 @@ async function readStdinText3() {
 }
 
 // src/commands/client/plugin.ts
-import path17 from "node:path";
+import path18 from "node:path";
 import pc7 from "picocolors";
 function resolvePackageArg(packageArg, isLocal) {
   if (!isLocal) return packageArg;
-  if (path17.isAbsolute(packageArg)) return packageArg;
+  if (path18.isAbsolute(packageArg)) return packageArg;
   if (packageArg.startsWith("~")) {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    return path17.resolve(home, packageArg.slice(1).replace(/^[\\/]/, ""));
+    return path18.resolve(home, packageArg.slice(1).replace(/^[\\/]/, ""));
   }
-  return path17.resolve(process.cwd(), packageArg);
+  return path18.resolve(process.cwd(), packageArg);
 }
 function formatPlugin(p16) {
   const statusColor = p16.status === "ready" ? pc7.green(p16.status) : p16.status === "error" ? pc7.red(p16.status) : p16.status === "disabled" ? pc7.dim(p16.status) : pc7.yellow(p16.status);
@@ -18348,8 +18373,8 @@ function registerUserCommands(program) {
         appendParam(params, "limit", opts.limit);
         appendParam(params, "cursor", opts.cursor);
         const query = params.toString();
-        const path24 = `/api/orgs/${ctx.orgId}/users/${encodeURIComponent(userId)}/activity-ledger${query ? `?${query}` : ""}`;
-        const result = await ctx.api.get(path24);
+        const path25 = `/api/orgs/${ctx.orgId}/users/${encodeURIComponent(userId)}/activity-ledger${query ? `?${query}` : ""}`;
+        const result = await ctx.api.get(path25);
         if (ctx.json) {
           printOutput(result, { json: true });
           return;
@@ -19168,9 +19193,9 @@ import * as p15 from "@clack/prompts";
 import { spawn as spawn3, spawnSync as spawnSync4 } from "node:child_process";
 import { createHash as createHash2, randomUUID } from "node:crypto";
 import { createWriteStream, constants as fsConstants, mkdirSync, readFileSync as readFileSync2 } from "node:fs";
-import { access, chmod, copyFile as copyFile2, cp as cp2, mkdir as mkdir3, mkdtemp as mkdtemp2, readdir as readdir3, readFile as readFile6, rm as rm2, stat as stat4, utimes, writeFile as writeFile3 } from "node:fs/promises";
+import { access, chmod, copyFile as copyFile2, cp as cp3, mkdir as mkdir4, mkdtemp as mkdtemp2, readdir as readdir3, readFile as readFile6, rm as rm2, stat as stat5, utimes, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
-import path22 from "node:path";
+import path23 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";
@@ -19528,38 +19553,38 @@ function resolveDesktopAssetTarget(platform = process.platform, arch = process.a
   throw new Error(`Rudder Desktop does not publish portable assets for ${platform}.`);
 }
 function resolveDefaultDesktopInstallRoot(target, env = process.env, homeDir = homedir()) {
-  if (target.platform === "macos") return path22.join(homeDir, "Applications");
+  if (target.platform === "macos") return path23.join(homeDir, "Applications");
   if (target.platform === "windows") {
-    const localAppData = env.LOCALAPPDATA?.trim() || path22.join(homeDir, "AppData", "Local");
-    return path22.join(localAppData, "Programs", DESKTOP_APP_NAME);
+    const localAppData = env.LOCALAPPDATA?.trim() || path23.join(homeDir, "AppData", "Local");
+    return path23.join(localAppData, "Programs", DESKTOP_APP_NAME);
   }
-  return path22.join(homeDir, ".local", "share", "rudder");
+  return path23.join(homeDir, ".local", "share", "rudder");
 }
 function resolveDesktopInstallPaths(target, installRoot) {
-  const root = path22.resolve(installRoot);
+  const root = path23.resolve(installRoot);
   if (target.platform === "macos") {
-    const appPath2 = path22.join(root, `${DESKTOP_APP_NAME}.app`);
+    const appPath2 = path23.join(root, `${DESKTOP_APP_NAME}.app`);
     return {
       installRoot: root,
       appPath: appPath2,
-      executablePath: path22.join(appPath2, "Contents", "MacOS", DESKTOP_APP_NAME),
-      metadataPath: path22.join(root, DESKTOP_METADATA_FILE)
+      executablePath: path23.join(appPath2, "Contents", "MacOS", DESKTOP_APP_NAME),
+      metadataPath: path23.join(root, DESKTOP_METADATA_FILE)
     };
   }
   if (target.platform === "windows") {
     return {
       installRoot: root,
       appPath: root,
-      executablePath: path22.join(root, `${DESKTOP_APP_NAME}.exe`),
-      metadataPath: path22.join(root, DESKTOP_METADATA_FILE)
+      executablePath: path23.join(root, `${DESKTOP_APP_NAME}.exe`),
+      metadataPath: path23.join(root, DESKTOP_METADATA_FILE)
     };
   }
-  const appPath = path22.join(root, `${DESKTOP_APP_NAME}.AppImage`);
+  const appPath = path23.join(root, `${DESKTOP_APP_NAME}.AppImage`);
   return {
     installRoot: root,
     appPath,
     executablePath: appPath,
-    metadataPath: path22.join(root, DESKTOP_METADATA_FILE)
+    metadataPath: path23.join(root, DESKTOP_METADATA_FILE)
   };
 }
 function normalizeAssetName(name) {
@@ -19732,7 +19757,7 @@ function contentLengthFromHeaders(headers) {
 }
 async function downloadAsset(asset, outputDir, progressFactory = createByteProgress) {
   mkdirSync(outputDir, { recursive: true });
-  const outputPath = path22.join(outputDir, path22.basename(asset.name));
+  const outputPath = path23.join(outputDir, path23.basename(asset.name));
   const ASSET_DOWNLOAD_TIMEOUT_MS = 6e5;
   let response = null;
   const failures = [];
@@ -19790,16 +19815,16 @@ function parseChecksumFile(contents) {
   return checksums;
 }
 function resolveAssetChecksum(checksums, assetName) {
-  const expected = checksums.get(path22.basename(assetName));
+  const expected = checksums.get(path23.basename(assetName));
   if (!expected) {
-    throw new Error(`Desktop release checksums do not include ${path22.basename(assetName)}.`);
+    throw new Error(`Desktop release checksums do not include ${path23.basename(assetName)}.`);
   }
   return expected;
 }
 function assertChecksumMatch(filePath, expected) {
   const actual = checksumForFile(filePath);
   if (actual !== expected.toLowerCase()) {
-    throw new Error(`Checksum mismatch for ${path22.basename(filePath)}.`);
+    throw new Error(`Checksum mismatch for ${path23.basename(filePath)}.`);
   }
   return actual;
 }
@@ -19818,10 +19843,10 @@ function normalizeDesktopAssetChecksum(checksum) {
   return normalized;
 }
 function resolveDesktopAssetCacheDir(assetChecksum, homeDir = resolveRudderHomeDir()) {
-  return path22.join(homeDir, DESKTOP_ASSET_CACHE_DIR, normalizeDesktopAssetChecksum(assetChecksum));
+  return path23.join(homeDir, DESKTOP_ASSET_CACHE_DIR, normalizeDesktopAssetChecksum(assetChecksum));
 }
 function resolveDesktopCachedAssetPath(assetName, assetChecksum, homeDir = resolveRudderHomeDir()) {
-  return path22.join(resolveDesktopAssetCacheDir(assetChecksum, homeDir), path22.basename(assetName));
+  return path23.join(resolveDesktopAssetCacheDir(assetChecksum, homeDir), path23.basename(assetName));
 }
 async function pruneDesktopAssetCache(options = {}) {
   const homeDir = options.homeDir ?? resolveRudderHomeDir();
@@ -19867,7 +19892,7 @@ async function maybePruneDesktopAssetCache(options) {
   return result.deleted.length > 0 || result.warnings.length > 0 ? result : null;
 }
 async function scanDesktopAssetCacheEntries(homeDir) {
-  const cacheRoot = path22.join(homeDir, DESKTOP_ASSET_CACHE_DIR);
+  const cacheRoot = path23.join(homeDir, DESKTOP_ASSET_CACHE_DIR);
   const dirents = await readdir3(cacheRoot, { withFileTypes: true }).catch(() => null);
   if (!dirents) return [];
   const entries = [];
@@ -19879,7 +19904,7 @@ async function scanDesktopAssetCacheEntries(homeDir) {
     } catch {
       continue;
     }
-    const cacheDir = path22.join(cacheRoot, dirent.name);
+    const cacheDir = path23.join(cacheRoot, dirent.name);
     const stats = await desktopCacheDirectoryStats(cacheDir);
     entries.push({
       cacheDir,
@@ -19891,7 +19916,7 @@ async function scanDesktopAssetCacheEntries(homeDir) {
   return entries;
 }
 async function desktopCacheDirectoryStats(targetPath) {
-  const fallbackStat = await stat4(targetPath).catch(() => null);
+  const fallbackStat = await stat5(targetPath).catch(() => null);
   const dirents = await readdir3(targetPath, { withFileTypes: true }).catch(() => null);
   if (!dirents) {
     return {
@@ -19903,8 +19928,8 @@ async function desktopCacheDirectoryStats(targetPath) {
   let lastUsedAtMs = Number(fallbackStat?.mtimeMs ?? 0);
   for (const dirent of dirents) {
     if (dirent.isSymbolicLink()) continue;
-    const entryPath = path22.join(targetPath, dirent.name);
-    const entryStat = await stat4(entryPath).catch(() => null);
+    const entryPath = path23.join(targetPath, dirent.name);
+    const entryStat = await stat5(entryPath).catch(() => null);
     if (!entryStat) continue;
     lastUsedAtMs = Math.max(lastUsedAtMs, Number(entryStat.mtimeMs ?? 0));
     if (dirent.isDirectory()) {
@@ -19980,13 +20005,13 @@ async function downloadDesktopAssetWithCache(asset, expectedChecksum, options =
       await rm2(cachePath, { force: true });
     }
   }
-  const outputDir = options.outputDir ?? await mkdtemp2(path22.join(tmpdir(), "rudder-desktop-installer."));
+  const outputDir = options.outputDir ?? await mkdtemp2(path23.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 mkdir3(path22.dirname(cachePath), { recursive: true });
-    if (path22.resolve(downloadedPath) !== path22.resolve(cachePath)) {
+    await mkdir4(path23.dirname(cachePath), { recursive: true });
+    if (path23.resolve(downloadedPath) !== path23.resolve(cachePath)) {
       await copyFile2(downloadedPath, cachePath);
     }
     return { path: cachePath, checksum, cacheStatus: "miss" };
@@ -20003,8 +20028,8 @@ async function pathExists2(targetPath) {
   }
 }
 function resolveDesktopInstallLockPath(paths) {
-  const installRootHash = createHash2("sha256").update(path22.resolve(paths.installRoot)).digest("hex").slice(0, 16);
-  return path22.join(path22.dirname(paths.appPath), `.rudder-desktop-install-${installRootHash}.lock`);
+  const installRootHash = createHash2("sha256").update(path23.resolve(paths.installRoot)).digest("hex").slice(0, 16);
+  return path23.join(path23.dirname(paths.appPath), `.rudder-desktop-install-${installRootHash}.lock`);
 }
 async function readDesktopInstallLock(lockPath) {
   try {
@@ -20024,17 +20049,17 @@ async function readDesktopInstallLock(lockPath) {
 }
 async function withDesktopInstallLock(paths, fn, options = {}) {
   const lockPath = resolveDesktopInstallLockPath(paths);
-  const lockDir = path22.dirname(lockPath);
+  const lockDir = path23.dirname(lockPath);
   const timeoutMs = options.timeoutMs ?? DESKTOP_INSTALL_LOCK_TIMEOUT_MS;
   const pollMs = options.pollMs ?? DESKTOP_INSTALL_LOCK_POLL_MS;
   const startedAt = Date.now();
   const payload = {
     lockId: randomUUID(),
     pid: process.pid,
-    installRoot: path22.resolve(paths.installRoot),
+    installRoot: path23.resolve(paths.installRoot),
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await mkdir3(lockDir, { recursive: true });
+  await mkdir4(lockDir, { recursive: true });
   while (true) {
     try {
       await writeFile3(lockPath, `${JSON.stringify(payload, null, 2)}
@@ -20097,7 +20122,7 @@ function isSuccessfulRobocopyExitCode(status) {
 }
 async function extractZip(zipPath, outputDir, target) {
   await rm2(outputDir, { recursive: true, force: true });
-  await mkdir3(outputDir, { recursive: true });
+  await mkdir4(outputDir, { recursive: true });
   if (target.platform === "macos") {
     runChecked("ditto", ["-x", "-k", zipPath, outputDir]);
     return;
@@ -20113,7 +20138,7 @@ async function findPath(root, predicate, maxDepth = 5) {
   async function visit(dir, depth) {
     const entries = await readdir3(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path22.join(dir, entry.name);
+      const fullPath = path23.join(dir, entry.name);
       if (predicate(fullPath, entry.isDirectory())) return fullPath;
       if (entry.isDirectory() && depth < maxDepth) {
         const nested = await visit(fullPath, depth + 1);
@@ -20125,18 +20150,18 @@ async function findPath(root, predicate, maxDepth = 5) {
   return await visit(root, 0);
 }
 async function findMacApp(extractDir) {
-  const direct = path22.join(extractDir, `${DESKTOP_APP_NAME}.app`);
+  const direct = path23.join(extractDir, `${DESKTOP_APP_NAME}.app`);
   if (await pathExists2(direct)) return direct;
-  const found = await findPath(extractDir, (filePath, isDirectory) => isDirectory && path22.basename(filePath) === `${DESKTOP_APP_NAME}.app`);
+  const found = await findPath(extractDir, (filePath, isDirectory) => isDirectory && path23.basename(filePath) === `${DESKTOP_APP_NAME}.app`);
   if (!found) throw new Error(`Portable macOS archive did not contain ${DESKTOP_APP_NAME}.app.`);
   return found;
 }
 async function findWindowsAppDir(extractDir) {
-  const direct = path22.join(extractDir, `${DESKTOP_APP_NAME}.exe`);
+  const direct = path23.join(extractDir, `${DESKTOP_APP_NAME}.exe`);
   if (await pathExists2(direct)) return extractDir;
-  const executable = await findPath(extractDir, (filePath, isDirectory) => !isDirectory && path22.basename(filePath).toLowerCase() === `${DESKTOP_APP_NAME.toLowerCase()}.exe`);
+  const executable = await findPath(extractDir, (filePath, isDirectory) => !isDirectory && path23.basename(filePath).toLowerCase() === `${DESKTOP_APP_NAME.toLowerCase()}.exe`);
   if (!executable) throw new Error(`Portable Windows archive did not contain ${DESKTOP_APP_NAME}.exe.`);
-  return path22.dirname(executable);
+  return path23.dirname(executable);
 }
 async function readInstallMetadata(metadataPath) {
   try {
@@ -20204,7 +20229,7 @@ async function waitForUpdateQuitResponse(responsePath, timeoutMs = 8e3) {
 }
 async function requestDesktopQuit(executablePath, target, options = {}) {
   if (!await pathExists2(executablePath)) return { ok: true, status: "not_running" };
-  const responsePath = path22.join(tmpdir(), `rudder-update-quit-${process.pid}-${Date.now()}.json`);
+  const responsePath = path23.join(tmpdir(), `rudder-update-quit-${process.pid}-${Date.now()}.json`);
   const result = spawnSync4(executablePath, [
     `${DESKTOP_UPDATE_QUIT_ARG}=${responsePath}`,
     ...options.forceUpdate ? [DESKTOP_UPDATE_FORCE_ARG] : []
@@ -20362,13 +20387,13 @@ async function prepareForDesktopReplace(paths, target, options = {}) {
   throw new Error(`Failed to replace existing Rudder Desktop at ${replacePath}. Close Rudder and rerun start.`);
 }
 async function installPortableDesktop(installerPath, paths, target) {
-  await mkdir3(paths.installRoot, { recursive: true });
+  await mkdir4(paths.installRoot, { recursive: true });
   if (target.platform === "linux") {
     await copyFile2(installerPath, paths.appPath);
     await chmod(paths.appPath, 493);
     return;
   }
-  const extractDir = await mkdtemp2(path22.join(tmpdir(), "rudder-desktop-extract."));
+  const extractDir = await mkdtemp2(path23.join(tmpdir(), "rudder-desktop-extract."));
   try {
     await extractZip(installerPath, extractDir, target);
     if (target.platform === "macos") {
@@ -20377,7 +20402,7 @@ async function installPortableDesktop(installerPath, paths, target) {
       return;
     }
     const appSource = await findWindowsAppDir(extractDir);
-    await mkdir3(path22.dirname(paths.installRoot), { recursive: true });
+    await mkdir4(path23.dirname(paths.installRoot), { recursive: true });
     await copyPortableAppBundle(appSource, paths.installRoot);
   } finally {
     await rm2(extractDir, { recursive: true, force: true });
@@ -20385,7 +20410,7 @@ async function installPortableDesktop(installerPath, paths, target) {
 }
 async function copyPortableAppBundle(sourcePath, destinationPath) {
   if (process.platform === "win32") {
-    await mkdir3(destinationPath, { recursive: true });
+    await mkdir4(destinationPath, { recursive: true });
     const command = buildWindowsRobocopyMirrorCommand(sourcePath, destinationPath);
     const result = spawnSync4(command.command, command.args, {
       encoding: "utf8",
@@ -20394,7 +20419,7 @@ async function copyPortableAppBundle(sourcePath, destinationPath) {
     if (isSuccessfulRobocopyExitCode(result.status)) return;
     throw new Error(formatCommandFailure(command.command, command.args, result.stdout, result.stderr));
   }
-  await cp2(sourcePath, destinationPath, { recursive: true, verbatimSymlinks: true });
+  await cp3(sourcePath, destinationPath, { recursive: true, verbatimSymlinks: true });
 }
 async function removeMacQuarantine(paths, target) {
   if (target.platform !== "macos") return;
@@ -20418,12 +20443,12 @@ function buildLinuxDesktopEntry(executablePath) {
   ].join("\n");
 }
 async function writeLinuxLaunchers(paths) {
-  const desktopDir = path22.join(homedir(), ".local", "share", "applications");
-  await mkdir3(desktopDir, { recursive: true });
-  await writeFile3(path22.join(desktopDir, "rudder.desktop"), buildLinuxDesktopEntry(paths.executablePath), "utf8");
-  const binDir = path22.join(homedir(), ".local", "bin");
-  await mkdir3(binDir, { recursive: true });
-  const wrapperPath = path22.join(binDir, "rudder-desktop");
+  const desktopDir = path23.join(homedir(), ".local", "share", "applications");
+  await mkdir4(desktopDir, { recursive: true });
+  await writeFile3(path23.join(desktopDir, "rudder.desktop"), buildLinuxDesktopEntry(paths.executablePath), "utf8");
+  const binDir = path23.join(homedir(), ".local", "bin");
+  await mkdir4(binDir, { recursive: true });
+  const wrapperPath = path23.join(binDir, "rudder-desktop");
   const escaped = paths.executablePath.replaceAll("'", `'"'"'`);
   await writeFile3(wrapperPath, `#!/bin/sh
 exec '${escaped}' "$@"
@@ -20431,13 +20456,13 @@ exec '${escaped}' "$@"
   await chmod(wrapperPath, 493);
 }
 function buildWindowsShortcutScript(executablePath) {
-  const appData = process.env.APPDATA?.trim() || path22.join(homedir(), "AppData", "Roaming");
-  const shortcutPath = path22.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Rudder.lnk");
+  const appData = process.env.APPDATA?.trim() || path23.join(homedir(), "AppData", "Roaming");
+  const shortcutPath = path23.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Rudder.lnk");
   return [
     "$shell = New-Object -ComObject WScript.Shell",
     `$shortcut = $shell.CreateShortcut(${powershellQuote(shortcutPath)})`,
     `$shortcut.TargetPath = ${powershellQuote(executablePath)}`,
-    `$shortcut.WorkingDirectory = ${powershellQuote(path22.dirname(executablePath))}`,
+    `$shortcut.WorkingDirectory = ${powershellQuote(path23.dirname(executablePath))}`,
     "$shortcut.Save()"
   ].join("; ");
 }
@@ -20469,7 +20494,7 @@ function launchDesktop(paths, target) {
   spawn3(paths.executablePath, [], { detached: true, stdio: "ignore" }).unref();
 }
 async function writeInstallMetadata(paths, releaseTag, assetName, assetChecksum, assetKind = "full") {
-  mkdirSync(path22.dirname(paths.metadataPath), { recursive: true });
+  mkdirSync(path23.dirname(paths.metadataPath), { recursive: true });
   const metadata = {
     version: 1,
     releaseTag,
@@ -20589,9 +20614,9 @@ async function startCommand(opts) {
   if (installDesktop) {
     const target = resolveDesktopAssetTarget();
     const tag = resolveDesktopReleaseTag(version);
-    const installRoot = opts.desktopInstallDir ? path22.resolve(opts.desktopInstallDir) : resolveDefaultDesktopInstallRoot(target);
+    const installRoot = opts.desktopInstallDir ? path23.resolve(opts.desktopInstallDir) : resolveDefaultDesktopInstallRoot(target);
     const installPaths = resolveDesktopInstallPaths(target, installRoot);
-    const outputDir = opts.outputDir ? path22.resolve(opts.outputDir) : await mkdtemp2(path22.join(tmpdir(), "rudder-desktop-installer."));
+    const outputDir = opts.outputDir ? path23.resolve(opts.outputDir) : await mkdtemp2(path23.join(tmpdir(), "rudder-desktop-installer."));
     p15.log.step("Installing desktop app");
     p15.log.message(`Release: ${pc15.cyan(`${repo}@${tag}`)}`);
     p15.log.message(`Target: ${pc15.cyan(`${target.platform}/${target.arch}`)}`);
@@ -20690,7 +20715,7 @@ async function startCommand(opts) {
         }
         const checksum = await runStartPhase(
           "Verifying Desktop checksum...",
-          `Verified ${pc15.cyan(path22.basename(cachedAsset.path))}.`,
+          `Verified ${pc15.cyan(path23.basename(cachedAsset.path))}.`,
           () => assertChecksumMatch(cachedAsset.path, expectedChecksum),
           desktopProgressJson ? "verifying_checksum" : null
         );
@@ -20774,11 +20799,11 @@ async function startCommand(opts) {
 
 // src/config/data-dir.ts
 init_home();
-import path23 from "node:path";
+import path24 from "node:path";
 function applyDataDirOverride(options, support = {}) {
   const rawDataDir = options.dataDir?.trim();
   if (!rawDataDir) return null;
-  const resolvedDataDir = path23.resolve(expandHomePrefix(rawDataDir));
+  const resolvedDataDir = path24.resolve(expandHomePrefix(rawDataDir));
   process.env.RUDDER_HOME = resolvedDataDir;
   if (support.hasConfigOption) {
     const hasConfigOverride = Boolean(options.config?.trim()) || Boolean(process.env.RUDDER_CONFIG?.trim());