@rudderhq/cli 0.3.6-canary.31 → 0.3.6-canary.32

package/dist/index.js

@@ -3601,23 +3601,6 @@ async function hasRequiredRuntimePlatformDependencies(cacheDir) {
   if (!platformPackage) return true;
   return await canResolveRuntimePackage(cacheDir, platformPackage);
 }
-async function assertRequiredRuntimePlatformDependencies(cacheDir, command, output) {
-  if (!await canResolveRuntimePackage(cacheDir, EMBEDDED_POSTGRES_PACKAGE_NAME)) return;
-  const platformPackage = resolveEmbeddedPostgresPlatformPackage();
-  if (!platformPackage || await canResolveRuntimePackage(cacheDir, platformPackage)) return;
-  throw new RuntimeInstallError(
-    `Rudder runtime installation is missing required platform package ${platformPackage}. Re-run manually: ${command}`,
-    {
-      cacheDir,
-      command,
-      output: [
-        output,
-        `Missing required optional dependency: ${platformPackage}`,
-        "Your npm registry, mirror, proxy, or cache may have skipped the embedded PostgreSQL platform package."
-      ].filter((line) => line.trim().length > 0).join("\n")
-    }
-  );
-}
 async function isRuntimeCacheHit(options) {
   const packageName = options.packageName ?? RUNTIME_NPM_PACKAGE_NAME;
   const packageVersion = resolveRuntimePackageVersion(options.version);
@@ -3650,13 +3633,36 @@ async function ensureRuntimeInstalled(options) {
     });
     return { status: "hit", cacheDir, packageSpec, command, output: "", ...prune2 ? { prune: prune2 } : {} };
   }
+  const spawnSyncImpl = options.spawnSyncImpl ?? spawnSync;
+  const existingRuntimeOutput = await tryRepairExistingRuntimePackage({
+    spawnSyncImpl,
+    cacheDir,
+    packageName,
+    packageVersion
+  });
+  if (existingRuntimeOutput !== null) {
+    const metadata2 = {
+      version: 1,
+      packageName,
+      packageVersion,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastUsedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeRuntimeInstallMetadata(cacheDir, metadata2);
+    const prune2 = await maybePruneRuntimeCache({
+      homeDir: options.homeDir,
+      requestedVersion: packageVersion,
+      enabled: options.pruneRuntimeCache !== false,
+      retention: options.retention
+    });
+    return { status: "installed", cacheDir, packageSpec, command, output: existingRuntimeOutput, ...prune2 ? { prune: prune2 } : {} };
+  }
   await rm(cacheDir, { recursive: true, force: true });
   await mkdir(cacheDir, { recursive: true });
-  await writeFile(path4.join(cacheDir, "package.json"), `${JSON.stringify({ private: true, type: "module" }, null, 2)}
+  await writeFile(path4.join(cacheDir, "package.json"), `${JSON.stringify(RUNTIME_CACHE_PACKAGE_JSON, null, 2)}
 `, "utf8");
-  const spawnSyncImpl = options.spawnSyncImpl ?? spawnSync;
   const result = runNpmRuntimeInstall(spawnSyncImpl, cacheDir, packageSpec);
-  const output = collectSpawnOutput(result);
+  let output = collectSpawnOutput(result);
   if (result.status !== 0 && packageVersion !== "latest" && isVersionNotFoundError(output)) {
     const fallbackVersion = "latest";
     const fallbackCacheDir = resolveRuntimeCacheDir(fallbackVersion, options.homeDir);
@@ -3673,12 +3679,15 @@ async function ensureRuntimeInstalled(options) {
     }
     await rm(fallbackCacheDir, { recursive: true, force: true });
     await mkdir(fallbackCacheDir, { recursive: true });
-    await writeFile(path4.join(fallbackCacheDir, "package.json"), `${JSON.stringify({ private: true, type: "module" }, null, 2)}
+    await writeFile(path4.join(fallbackCacheDir, "package.json"), `${JSON.stringify(RUNTIME_CACHE_PACKAGE_JSON, null, 2)}
 `, "utf8");
     const fallbackResult = runNpmRuntimeInstall(spawnSyncImpl, fallbackCacheDir, fallbackSpec);
-    const fallbackOutput = collectSpawnOutput(fallbackResult);
+    let fallbackOutput = collectSpawnOutput(fallbackResult);
     if (fallbackResult.status === 0) {
-      await assertRequiredRuntimePlatformDependencies(fallbackCacheDir, formatRuntimeInstallCommand(fallbackCacheDir, fallbackSpec), fallbackOutput);
+      fallbackOutput = collectOutputParts(
+        fallbackOutput,
+        await ensureRequiredEmbeddedPostgresPlatformPackage(spawnSyncImpl, fallbackCacheDir)
+      );
       const fallbackMetadata = {
         version: 1,
         packageName,
@@ -3702,7 +3711,10 @@ async function ensureRuntimeInstalled(options) {
       { cacheDir, command, output }
     );
   }
-  await assertRequiredRuntimePlatformDependencies(cacheDir, command, output);
+  output = collectOutputParts(
+    output,
+    await ensureRequiredEmbeddedPostgresPlatformPackage(spawnSyncImpl, cacheDir)
+  );
   const metadata = {
     version: 1,
     packageName,
@@ -3740,9 +3752,139 @@ function runNpmRuntimeInstall(spawnSyncImpl, cacheDir, packageSpec) {
 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 ${path4.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();
 }
+function collectOutputParts(...parts) {
+  return parts.filter((part) => part.trim().length > 0).join("\n").trim();
+}
+function runtimePackageJsonPath(cacheDir, packageName) {
+  return path4.join(cacheDir, "node_modules", ...packageName.split("/"), "package.json");
+}
+async function readRuntimePackageJson(cacheDir, packageName) {
+  try {
+    return JSON.parse(await readFile(runtimePackageJsonPath(cacheDir, packageName), "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function tryRepairExistingRuntimePackage(options) {
+  const runtimePackage = await readRuntimePackageJson(options.cacheDir, options.packageName);
+  if (!runtimePackage) return null;
+  if (options.packageVersion !== "latest" && runtimePackage.version !== options.packageVersion) return null;
+  const output = await ensureRequiredEmbeddedPostgresPlatformPackage(options.spawnSyncImpl, options.cacheDir);
+  return await hasRequiredRuntimePlatformDependencies(options.cacheDir) ? output : null;
+}
+async function resolveEmbeddedPostgresPlatformPackageSpec(cacheDir) {
+  if (!await canResolveRuntimePackage(cacheDir, EMBEDDED_POSTGRES_PACKAGE_NAME)) return null;
+  const packageName = resolveEmbeddedPostgresPlatformPackage();
+  if (!packageName) return null;
+  const embeddedPostgresPackage = await readRuntimePackageJson(cacheDir, EMBEDDED_POSTGRES_PACKAGE_NAME);
+  const versionRange = embeddedPostgresPackage?.optionalDependencies?.[packageName];
+  const packageVersion = normalizeOptionalDependencyVersion(versionRange);
+  return packageVersion ? `${packageName}@${packageVersion}` : packageName;
+}
+async function ensureRequiredEmbeddedPostgresPlatformPackage(spawnSyncImpl, cacheDir) {
+  const packageSpec = await resolveEmbeddedPostgresPlatformPackageSpec(cacheDir);
+  if (!packageSpec) return "";
+  const packageName = packageNameFromSpec(packageSpec);
+  if (packageName && await canResolveRuntimePackage(cacheDir, packageName)) return "";
+  await removeRuntimeInstallLocks(cacheDir);
+  const result = await installRuntimePackageInStaging(spawnSyncImpl, cacheDir, packageSpec, packageName);
+  const output = collectSpawnOutput(result);
+  if (result.status === 0 && packageName && await canResolveRuntimePackage(cacheDir, packageName)) {
+    return output;
+  }
+  const command = formatRuntimePlatformRepairCommand(cacheDir, packageSpec);
+  throw new RuntimeInstallError(
+    `Rudder runtime installation is missing required platform package ${packageName || packageSpec}. Re-run manually: ${command}`,
+    { cacheDir, command, output }
+  );
+}
+async function installRuntimePackageInStaging(spawnSyncImpl, cacheDir, packageSpec, packageName) {
+  const stagingDir = path4.join(cacheDir, `.platform-repair-${process.pid}-${Date.now()}`);
+  await mkdir(stagingDir, { recursive: true });
+  try {
+    const packResult = runNpmPack(spawnSyncImpl, packageSpec, stagingDir);
+    if (packResult.status !== 0) return packResult;
+    const packFilename = parseNpmPackFilename(packResult.stdout);
+    if (!packFilename) {
+      return createSyntheticSpawnResult(1, "", `Unable to parse npm pack output for ${packageSpec}.`);
+    }
+    const archivePath = path4.join(stagingDir, packFilename);
+    const targetDir = path4.dirname(runtimePackageJsonPath(cacheDir, packageName));
+    await mkdir(path4.dirname(targetDir), { recursive: true });
+    await rm(targetDir, { recursive: true, force: true });
+    await mkdir(targetDir, { recursive: true });
+    const extractResult = runTarExtract(spawnSyncImpl, archivePath, targetDir);
+    return combineSpawnResults(packResult, extractResult);
+  } finally {
+    await rm(stagingDir, { recursive: true, force: true });
+  }
+}
+function runNpmPack(spawnSyncImpl, packageSpec, destinationDir) {
+  return spawnSyncImpl(
+    process.platform === "win32" ? "npm.cmd" : "npm",
+    ["pack", packageSpec, "--pack-destination", destinationDir, ...RUNTIME_NPM_PACK_FLAGS],
+    {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, ...NPM_PLATFORM_REPAIR_ENV },
+      ...process.platform === "win32" ? { shell: true, windowsHide: true } : {}
+    }
+  );
+}
+function runTarExtract(spawnSyncImpl, archivePath, targetDir) {
+  return spawnSyncImpl(
+    "tar",
+    ["-xzf", archivePath, "-C", targetDir, "--strip-components", "1"],
+    {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      ...process.platform === "win32" ? { windowsHide: true } : {}
+    }
+  );
+}
+function parseNpmPackFilename(stdout) {
+  if (typeof stdout !== "string") return null;
+  const filename = stdout.trim().split(/\r?\n/).filter(Boolean).at(-1);
+  return filename?.endsWith(".tgz") ? filename : null;
+}
+function createSyntheticSpawnResult(status, stdout, stderr) {
+  return { status, stdout, stderr };
+}
+function combineSpawnResults(...results) {
+  const last = results.at(-1);
+  return {
+    status: last?.status ?? 0,
+    stdout: results.map((result) => result.stdout).filter(Boolean).join("\n"),
+    stderr: results.map((result) => result.stderr).filter(Boolean).join("\n"),
+    error: results.find((result) => result.error)?.error
+  };
+}
+async function removeRuntimeInstallLocks(cacheDir) {
+  await Promise.all([
+    rm(path4.join(cacheDir, "package-lock.json"), { force: true }),
+    rm(path4.join(cacheDir, "node_modules", ".package-lock.json"), { force: true })
+  ]);
+}
+function packageNameFromSpec(packageSpec) {
+  if (!packageSpec.startsWith("@")) {
+    const versionSeparator2 = packageSpec.indexOf("@");
+    return versionSeparator2 === -1 ? packageSpec : packageSpec.slice(0, versionSeparator2);
+  }
+  const versionSeparator = packageSpec.indexOf("@", 1);
+  return versionSeparator === -1 ? packageSpec : packageSpec.slice(0, versionSeparator);
+}
+function normalizeOptionalDependencyVersion(versionRange) {
+  const trimmed = versionRange?.trim();
+  if (!trimmed) return null;
+  const exactVersion = /^[~^]\s*([0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?)$/.exec(trimmed);
+  return exactVersion?.[1] ?? trimmed;
+}
 function isVersionNotFoundError(output) {
   const normalized = output.toLowerCase();
   return normalized.includes("enoent") || normalized.includes("etarget") || normalized.includes("no matching version found");
@@ -3968,19 +4110,32 @@ function parseRuntimeVersion(version) {
     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, RUNTIME_NPM_INSTALL_FLAGS, EMBEDDED_POSTGRES_PACKAGE_NAME, RuntimeInstallError;
+var RUNTIME_NPM_PACKAGE_NAME, NPM_PUBLIC_REGISTRY_URL, RUNTIME_METADATA_FILE, DEFAULT_RUNTIME_CACHE_MAX_ENTRIES, DEFAULT_RUNTIME_CACHE_MAX_AGE_MS, DEFAULT_RUNTIME_CACHE_MAX_BYTES, DEFAULT_RUNTIME_CACHE_KEEP_PREVIOUS, RUNTIME_NPM_INSTALL_FLAGS, RUNTIME_NPM_PACK_FLAGS, EMBEDDED_POSTGRES_PACKAGE_NAME, RUNTIME_CACHE_PACKAGE_JSON, NPM_PLATFORM_REPAIR_ENV, RuntimeInstallError;
 var init_install = __esm({
   "src/runtime/install.ts"() {
     "use strict";
     init_home();
     RUNTIME_NPM_PACKAGE_NAME = "@rudderhq/server";
+    NPM_PUBLIC_REGISTRY_URL = "https://registry.npmjs.org";
     RUNTIME_METADATA_FILE = "runtime.json";
     DEFAULT_RUNTIME_CACHE_MAX_ENTRIES = 2;
     DEFAULT_RUNTIME_CACHE_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
     DEFAULT_RUNTIME_CACHE_MAX_BYTES = 2 * 1024 * 1024 * 1024;
     DEFAULT_RUNTIME_CACHE_KEEP_PREVIOUS = 0;
     RUNTIME_NPM_INSTALL_FLAGS = ["--omit=dev", "--include=optional", "--no-audit", "--no-fund"];
+    RUNTIME_NPM_PACK_FLAGS = ["--registry", NPM_PUBLIC_REGISTRY_URL, "--silent"];
     EMBEDDED_POSTGRES_PACKAGE_NAME = "embedded-postgres";
+    RUNTIME_CACHE_PACKAGE_JSON = {
+      name: "rudder-runtime-cache",
+      version: "0.0.0",
+      private: true,
+      type: "module"
+    };
+    NPM_PLATFORM_REPAIR_ENV = {
+      npm_config_registry: NPM_PUBLIC_REGISTRY_URL,
+      npm_config_update_notifier: "false",
+      NO_UPDATE_NOTIFIER: "1"
+    };
     RuntimeInstallError = class extends Error {
       cacheDir;
       command;