@superblocksteam/sdk 2.0.3-next.162 → 2.0.3-next.163

package/src/cli-replacement/automatic-upgrades.ts

@@ -1,7 +1,6 @@
 import * as child_process from "node:child_process";
 import { promisify } from "node:util";
 import { isNativeError } from "node:util/types";
-import { isEqual, pickBy } from "lodash-es";
 import { resolveCommand, type DetectResult } from "package-manager-detector";
 import { detect } from "package-manager-detector/detect";
 import gt from "semver/functions/gt.js";
@@ -18,6 +17,11 @@ interface Versions {
   [pkg: string]: string;
 }
 
+interface PackageVersionInfo {
+  version: string;
+  alias?: string;
+}
+
 interface CheckVersionsErrorResponse {
   responseMeta: ResponseMeta;
 }
@@ -27,7 +31,7 @@ interface CheckVersionsSuccessResponse {
   responseMeta: ResponseMeta;
 }
 
-async function getRemoteCliLibraryVersions(
+async function getRemoteVersions(
   config: ApplicationConfig,
 ): Promise<Versions | undefined> {
   const { token, superblocksBaseUrl, id } = config;
@@ -40,9 +44,7 @@ async function getRemoteCliLibraryVersions(
       ),
       {
         method: "GET",
-        headers: {
-          Authorization: `Bearer ${token}`,
-        },
+        headers: { Authorization: `Bearer ${token}` },
       },
     );
 
@@ -64,57 +66,18 @@ async function getRemoteCliLibraryVersions(
   }
 }
 
-async function installPackageVersions(pm: DetectResult, versions: Versions) {
-  const installCommand = resolveCommand(
-    pm.agent,
-    "install",
-    Object.entries(versions).map(
-      ([pkg, version]) => `@superblocksteam/${pkg}@${version}`,
-    ),
-  );
-
-  if (!installCommand) {
-    console.error(
-      "We could not determine how to upgrade your Superblocks packages.",
-    );
-    return;
-  }
-
-  const { command, args } = installCommand;
-
-  // upgrade packages
-  return await exec(`${command} ${args.join(" ")}`);
-}
-
-async function findSuperblocksExecutable(): Promise<string | undefined> {
+async function getCurrentCliVersion(): Promise<string | undefined> {
   try {
-    // Use cross-platform approach to find superblocks executable
     const command = process.platform === "win32" ? "where" : "which";
     const { stdout } = await exec(`${command} superblocks`);
-    return stdout.trim();
-  } catch {
-    return undefined;
-  }
-}
+    const superblocksPath = stdout.trim();
 
-async function getLocalCliLibraryVersions(
-  pm: DetectResult,
-): Promise<Partial<Versions>> {
-  return {
-    cli: await getLocalCliVersion(),
-    library: await getLocalPackageVersion(pm, "library"),
-  };
-}
+    if (!superblocksPath) return undefined;
 
-async function getLocalCliVersion(): Promise<string | undefined> {
-  try {
-    const superblocksPath = await findSuperblocksExecutable();
-    if (!superblocksPath) {
-      return undefined;
-    }
-
-    const { stdout } = await exec(`${superblocksPath} version --json`);
-    const json = JSON.parse(stdout) as Record<string, string>;
+    const { stdout: versionOutput } = await exec(
+      `${superblocksPath} version --json`,
+    );
+    const json = JSON.parse(versionOutput) as Record<string, string>;
     // Extract version from string like "@superblocksteam/cli/2.0.0-next.1" or "@superblocksteam/cli-ephemeral/2.0.0-SNAPSHOT.1749077365"
     return json.cliVersion?.replace(/@superblocksteam\/cli(-ephemeral)?\//, "");
   } catch (error) {
@@ -125,99 +88,153 @@ async function getLocalCliVersion(): Promise<string | undefined> {
   }
 }
 
-async function getLocalPackageVersion(
+async function getCurrentLibraryVersion(
   pm: DetectResult,
-  pkg: string,
-  global?: boolean,
-) {
+): Promise<PackageVersionInfo | undefined> {
   try {
-    // Configure commands and parsing logic based on package manager type
     switch (pm.agent) {
-      case "npm": {
-        const { stdout } = await exec(
-          `npm list ${global ? "--global" : ""} @superblocksteam/${pkg} --json`,
-          {
-            cwd: process.cwd(),
-          },
-        );
-        const parsed = JSON.parse(stdout);
-        return (
-          parsed.dependencies?.[`@superblocksteam/${pkg}`]?.version ??
-          parsed.devDependencies?.[`@superblocksteam/${pkg}`]?.version
-        );
-      }
-      case "pnpm": {
-        const { stdout } = await exec(
-          `pnpm list ${global ? "--global" : ""} @superblocksteam/${pkg} --json`,
-          { cwd: process.cwd() },
-        );
-        const parsed = JSON.parse(stdout);
-        // Check the structure based on actual output
-        return (
-          parsed[0]?.dependencies?.[`@superblocksteam/${pkg}`]?.version ??
-          parsed[0]?.devDependencies?.[`@superblocksteam/${pkg}`]?.version
-        );
-      }
+      case "npm":
+        return await getNpmLibraryVersion();
+      case "pnpm":
+        return await getPnpmLibraryVersion();
       default:
         console.error(
-          `${pm.agent} is currently not supported. Your application will not be upgraded automatically.`,
+          `${pm.agent} is currently not supported for automatic upgrades.`,
         );
-        return;
+        return undefined;
     }
-  } catch (e) {
+  } catch (error) {
     console.error(
-      "We couldn't resolve your current Superblocks package versions. Your application will not be upgraded automatically.",
+      "Could not resolve current library version. Skipping automatic upgrade.",
     );
-    console.error(e);
-    return;
+    console.error(error);
+    return undefined;
   }
 }
 
-/**
- * Check if the CLI is updatable via the oclif update command
- * This indicates it was installed through a prebuilt installer (and updates the CLI)
- */
-async function tryCliUpdateCommand(version: string): Promise<boolean> {
+async function getNpmLibraryVersion(): Promise<PackageVersionInfo | undefined> {
+  const { stdout } = await exec("npm list @superblocksteam/library --json", {
+    cwd: process.cwd(),
+  });
+  const parsed = JSON.parse(stdout);
+  const packageData =
+    parsed.dependencies?.["@superblocksteam/library"] ??
+    parsed.devDependencies?.["@superblocksteam/library"];
+
+  if (!packageData?.version) return undefined;
+
+  // Check if this is an alias by examining the resolved URL
+  const resolved = packageData.resolved;
+  if (resolved && resolved.includes("@superblocksteam/")) {
+    const aliasMatch = resolved.match(/@superblocksteam\/([^\/]+)/);
+    if (aliasMatch && aliasMatch[1] !== "library") {
+      return {
+        version: packageData.version,
+        alias: `@superblocksteam/${aliasMatch[1]}`,
+      };
+    }
+  }
+
+  return { version: packageData.version };
+}
+
+async function getPnpmLibraryVersion(): Promise<
+  { version: string; alias?: string } | undefined
+> {
+  // First try the original package name
+  let packageData: any;
+
   try {
-    const superblocksPath = await findSuperblocksExecutable();
-    if (!superblocksPath) {
-      return false;
+    const result = await exec("pnpm list @superblocksteam/library --json", {
+      cwd: process.cwd(),
+    });
+    const parsed = JSON.parse(result.stdout);
+    packageData =
+      parsed[0]?.dependencies?.["@superblocksteam/library"] ??
+      parsed[0]?.devDependencies?.["@superblocksteam/library"];
+  } catch {
+    // Package not found with original name, might be aliased
+  }
+
+  // If not found, try the ephemeral alias
+  if (!packageData?.version) {
+    try {
+      const aliasResult = await exec(
+        "pnpm list @superblocksteam/library-ephemeral --json",
+        { cwd: process.cwd() },
+      );
+      const aliasParsed = JSON.parse(aliasResult.stdout);
+      packageData =
+        aliasParsed[0]?.dependencies?.["@superblocksteam/library"] ??
+        aliasParsed[0]?.devDependencies?.["@superblocksteam/library"];
+    } catch {
+      return undefined;
     }
+  }
 
-    // Check if the CLI is installed in a way that allows direct updates
-    // We'll try running the update command with --version to see if it shows an updatable message
-    const { stdout } = await exec(
-      `${superblocksPath} update --version=${version}`,
-    );
+  if (!packageData?.version) return undefined;
 
-    // If it mentions "not updatable" in either stdout or stderr, it's not a prebuilt installer
-    return !stdout.includes("not updatable");
+  // Check if this is an alias by looking at the 'from' field
+  const from = packageData.from;
+  if (from && from !== "@superblocksteam/library") {
+    return {
+      version: packageData.version,
+      alias: from,
+    };
+  }
+
+  return { version: packageData.version };
+}
+
+async function upgradeCliWithOclif(targetVersion: string): Promise<boolean> {
+  try {
+    const command = process.platform === "win32" ? "where" : "which";
+    const { stdout } = await exec(`${command} superblocks`);
+    const superblocksPath = stdout.trim();
+
+    if (!superblocksPath) return false;
+
+    const { stdout: updateOutput } = await exec(
+      `${superblocksPath} update --version=${targetVersion}`,
+    );
+    return !updateOutput.includes("not updatable");
   } catch (error) {
     if (isNativeError(error)) {
-      logger.error(`Error checking updatability: ${error.message}`);
+      logger.error(`Error checking CLI updatability: ${error.message}`);
     }
     return false;
   }
 }
 
-/**
- * Restart the CLI
- */
+async function upgradePackageWithPackageManager(
+  pm: DetectResult,
+  packageName: string,
+  targetVersion: string,
+  alias?: string,
+): Promise<void> {
+  const packageSpec = alias
+    ? `@superblocksteam/${packageName}@npm:${alias}@${targetVersion}`
+    : `@superblocksteam/${packageName}@${targetVersion}`;
+
+  const installCommand = resolveCommand(pm.agent, "install", [packageSpec]);
+
+  if (!installCommand) {
+    console.error("Could not determine how to upgrade Superblocks packages.");
+    return;
+  }
+
+  const { command, args } = installCommand;
+  await exec(`${command} ${args.join(" ")}`);
+}
+
 async function restartCli() {
-  // Get the args that were used to start the current process
   const args = process.argv.slice(1);
-
-  // Create a new process with the same arguments
   const child = child_process.spawn(process.execPath, [...args], {
     detached: true,
     stdio: "inherit",
     env: process.env,
   });
-
-  // Disconnect the child from the parent
   child.unref();
-
-  // Exit the current process after the next tick to ensure any logs were written to stdout
   process.nextTick(() => process.exit(0));
 }
 
@@ -225,6 +242,7 @@ export async function checkVersionsAndUpgrade(
   lockService: LockService,
   config?: ApplicationConfig,
 ) {
+  // Detect package manager
   const pm = await detect({
     strategies: [
       "packageManager-field",
@@ -235,70 +253,69 @@ export async function checkVersionsAndUpgrade(
     cwd: process.cwd(),
   });
 
-  if (!pm) return;
-  if (!config?.id) return;
+  if (!pm || !config?.id) return;
 
-  const localVersions = await getLocalCliLibraryVersions(pm);
+  // Get current versions
+  const currentCliVersion = await getCurrentCliVersion();
+  const currentLibraryInfo = await getCurrentLibraryVersion(pm);
 
+  // Skip if we're in local development
   if (
-    // don't attempt upgrades in local development
-    Object.values(localVersions).some(
-      (x) => !x || !valid(x) || x.startsWith("file:") || x.startsWith("link:"),
-    )
+    !currentCliVersion ||
+    !valid(currentCliVersion) ||
+    currentCliVersion.startsWith("file:") ||
+    currentCliVersion.startsWith("link:") ||
+    !currentLibraryInfo ||
+    !valid(currentLibraryInfo.version) ||
+    currentLibraryInfo.version.startsWith("file:") ||
+    currentLibraryInfo.version.startsWith("link:")
   ) {
     return;
   }
 
-  const serverVersions = await getRemoteCliLibraryVersions(config);
+  // Get target versions from server
+  const targetVersions = await getRemoteVersions(config);
+  if (!targetVersions) return;
 
-  // don't attempt upgrades if
-  if (
-    // server versions could not be fetched, or
-    !serverVersions ||
-    // we have a different # of libraries in server/local
-    Object.keys(localVersions).length !== Object.keys(serverVersions).length
-  ) {
-    return;
-  }
-
-  const isUpToDate = isEqual(localVersions, serverVersions);
-
-  if (isUpToDate) return;
+  // Check if CLI needs upgrade
+  const cliNeedsUpgrade =
+    targetVersions.cli && gt(targetVersions.cli, currentCliVersion);
 
-  // Determine which packages need to be updated
-  const packagesToUpdate = pickBy(localVersions, (_, key) => {
-    try {
-      return gt(serverVersions[key], (localVersions as Versions)[key]);
-    } catch {
-      return false;
-    }
-  }) as Versions;
+  // Check if library needs upgrade
+  const libraryNeedsUpgrade =
+    targetVersions.library &&
+    gt(targetVersions.library, currentLibraryInfo.version);
 
-  if (Object.keys(packagesToUpdate).length === 0) {
-    return;
+  if (!cliNeedsUpgrade && !libraryNeedsUpgrade) {
+    return; // Everything is up to date
   }
 
   let cliUpdated = false;
   let libraryUpdated = false;
 
-  // Handle CLI update separately if it needs updating
-  if (packagesToUpdate.cli) {
-    // Try to update using Oclif's builtin update command
-    const isUpdated = await tryCliUpdateCommand(serverVersions.cli);
+  // Upgrade CLI if needed
+  if (cliNeedsUpgrade) {
+    const oclifUpgradeSucceeded = await upgradeCliWithOclif(targetVersions.cli);
 
-    if (!isUpdated) {
-      // try to update using package manager (npm/pnpm/yarn)
-      await installPackageVersions(pm, { cli: serverVersions.cli });
+    if (!oclifUpgradeSucceeded) {
+      // Fall back to package manager upgrade
+      await upgradePackageWithPackageManager(pm, "cli", targetVersions.cli);
       cliUpdated = true;
     }
   }
 
-  // Always use package manager for library updates
-  if (packagesToUpdate.library) {
-    await installPackageVersions(pm, { library: serverVersions.library });
+  // Upgrade library if needed
+  if (libraryNeedsUpgrade) {
+    await upgradePackageWithPackageManager(
+      pm,
+      "library",
+      targetVersions.library,
+      currentLibraryInfo.alias,
+    );
     libraryUpdated = true;
   }
 
+  // Log what was updated
   if (cliUpdated && libraryUpdated) {
     logger.info(
       "@superblocksteam/cli and @superblocksteam/library have been updated.",
@@ -309,8 +326,10 @@ export async function checkVersionsAndUpgrade(
     logger.info("@superblocksteam/library has been updated.");
   }
 
-  logger.info("Restarting the CLI…");
-
-  await lockService.releaseLock();
-  await restartCli();
+  // Restart CLI if anything was updated
+  if (cliUpdated || libraryUpdated) {
+    logger.info("Restarting the CLI…");
+    await lockService.releaseLock();
+    await restartCli();
+  }
 }