@superblocksteam/sdk 2.0.6-next.6 → 2.0.6-next.61

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

@@ -1,11 +1,13 @@
 import * as child_process from "node:child_process";
 import { promisify } from "node:util";
 import { isNativeError } from "node:util/types";
+import { traceFunction } from "@superblocksteam/shared";
 import { resolveCommand, type DetectResult } from "package-manager-detector";
 import { detect } from "package-manager-detector/detect";
 import gt from "semver/functions/gt.js";
 import valid from "semver/functions/valid.js";
-import { getLogger } from "../dev-utils/dev-logger.mjs";
+import { getErrorMeta, getLogger } from "../dev-utils/dev-logger.mjs";
+import tracer from "../dev-utils/dev-tracer.js";
 import type { ResponseMeta } from "../socket/handlers.js";
 import type { ApplicationConfig } from "../types/common.js";
 import type { LockService } from "@superblocksteam/vite-plugin-file-sync/lock-service";
@@ -55,7 +57,7 @@ async function getRemoteVersions(
       return data.data;
     } else {
       const error = (await response.json()) as CheckVersionsErrorResponse;
-      console.log(
+      logger.error(
         `Could not get latest CLI version: ${error.responseMeta.message}`,
       );
     }
@@ -68,7 +70,9 @@ async function getRemoteVersions(
   }
 }
 
-export async function getCurrentCliVersion(): Promise<string | undefined> {
+export async function getCurrentCliVersion(): Promise<
+  PackageVersionInfo | undefined
+> {
   try {
     const command = process.platform === "win32" ? "where" : "which";
     const { stdout } = await exec(`${command} superblocks`);
@@ -85,7 +89,16 @@ export async function getCurrentCliVersion(): Promise<string | undefined> {
       /@superblocksteam\/cli(-ephemeral)?\//,
       "",
     );
-    return version;
+
+    const aliasMatch = json.cliVersion?.match(/@superblocksteam\/([^\/]+)/);
+    if (aliasMatch && aliasMatch[1] !== "cli") {
+      return {
+        version: version,
+        alias: `@superblocksteam/${aliasMatch[1]}`,
+      };
+    }
+
+    return { version };
   } catch (error) {
     if (isNativeError(error)) {
       logger.error(`Error getting CLI version: ${error.message}`);
@@ -104,16 +117,16 @@ export async function getCurrentLibraryVersion(
       case "pnpm":
         return await getPnpmLibraryVersion();
       default:
-        console.error(
+        logger.error(
           `${pm.agent} is currently not supported for automatic upgrades.`,
         );
         return undefined;
     }
   } catch (error) {
-    console.error(
+    logger.error(
       "Could not resolve current library version. Skipping automatic upgrade.",
+      getErrorMeta(error),
     );
-    console.error(error);
     return undefined;
   }
 }
@@ -200,10 +213,10 @@ async function upgradeCliWithOclif(targetVersion: string): Promise<boolean> {
 
     if (!superblocksPath) return false;
 
-    const { stdout: updateOutput } = await exec(
+    const { stdout: updateOutput, stderr: updateErrorOutput } = await exec(
       `${superblocksPath} update --version=${targetVersion}`,
     );
-    return !updateOutput.includes("not updatable");
+    return !(updateOutput + updateErrorOutput).includes("not updatable");
   } catch (error) {
     if (isNativeError(error)) {
       logger.error(`Error checking CLI updatability: ${error.message}`);
@@ -216,21 +229,61 @@ async function upgradePackageWithPackageManager(
   pm: DetectResult,
   packageName: string,
   targetVersion: string,
-  alias?: string,
+  {
+    alias,
+    global,
+  }: {
+    alias?: string;
+    global?: boolean;
+  },
 ): Promise<void> {
   const packageSpec = alias
     ? `@superblocksteam/${packageName}@npm:${alias}@${targetVersion}`
     : `@superblocksteam/${packageName}@${targetVersion}`;
 
-  const installCommand = resolveCommand(pm.agent, "install", [packageSpec]);
+  const installCommand = resolveCommand(
+    pm.agent,
+    global ? "global" : "install",
+    [packageSpec],
+  );
 
   if (!installCommand) {
-    console.error("Could not determine how to upgrade Superblocks packages.");
+    logger.error("Could not determine how to upgrade Superblocks packages.");
     return;
   }
 
   const { command, args } = installCommand;
-  await exec(`${command} ${args.join(" ")}`);
+  logger.info(
+    `Running ${command} ${args.join(" ")} to upgrade ${packageName}...`,
+  );
+  let resolver: (value: void | PromiseLike<void>) => void;
+  let rejecter: (reason?: any) => void;
+  const promise = new Promise<void>((resolve, reject) => {
+    resolver = resolve;
+    rejecter = reject;
+  });
+  const cp = child_process.exec(
+    `${command} ${args.join(" ")}`,
+    {
+      cwd: process.cwd(),
+    },
+    (error) => {
+      if (error) {
+        logger.error(`Failed to upgrade ${packageName} to ${targetVersion}`);
+        rejecter(error);
+      } else {
+        logger.info(`Successfully upgraded ${packageName} to ${targetVersion}`);
+        resolver();
+      }
+    },
+  );
+  cp.stdout?.on("data", (data) => {
+    logger.info(data);
+  });
+  cp.stderr?.on("data", (data) => {
+    logger.warn(data);
+  });
+  return promise;
 }
 
 export async function getCurrentLibraryVersionWithoutPM(): Promise<
@@ -255,109 +308,196 @@ export async function getCurrentLibraryVersionWithoutPM(): Promise<
 export async function checkVersionsAndUpgrade(
   lockService: LockService,
   config?: ApplicationConfig,
-) {
-  // Detect package manager
-  const pm = await detect({
-    strategies: [
-      "packageManager-field",
-      "lockfile",
-      "install-metadata",
-      "devEngines-field",
-    ],
-    cwd: process.cwd(),
-  });
-
-  if (!pm || !config?.id) return;
-
-  // Get current versions
-  const currentCliVersion = await getCurrentCliVersion();
-  const currentLibraryInfo = await getCurrentLibraryVersion(pm);
-
-  // Skip if we're in local development
-  if (
-    !currentCliVersion ||
-    !valid(currentCliVersion) ||
-    currentCliVersion.startsWith("file:") ||
-    currentCliVersion.startsWith("link:") ||
-    !currentLibraryInfo ||
-    !valid(currentLibraryInfo.version) ||
-    currentLibraryInfo.version.startsWith("file:") ||
-    currentLibraryInfo.version.startsWith("link:")
-  ) {
-    return;
-  }
+): Promise<{
+  cliUpdated: boolean;
+  libraryUpdated: boolean;
+}> {
+  const cliUpdated = false;
+  const libraryUpdated = false;
+  let hasFailedToUpgrade = false;
+
+  logger.info("Checking versions");
+
+  await traceFunction({
+    name: "checkVersionsAndUpgrade",
+    tracer,
+    fn: async () => {
+      // Detect package manager
+      const pm = await traceFunction({
+        name: "detectPackageManager",
+        tracer,
+        fn: async () => {
+          return await detect({
+            strategies: [
+              "packageManager-field",
+              "lockfile",
+              "install-metadata",
+              "devEngines-field",
+            ],
+            cwd: process.cwd(),
+          });
+        },
+      });
+
+      if (!pm || !config?.id) return;
+
+      // Get current versions
+      const currentCliInfo = await traceFunction({
+        name: "getCurrentCliVersion",
+        tracer,
+        fn: async () => {
+          return await getCurrentCliVersion();
+        },
+      });
+      const currentLibraryInfo = await traceFunction({
+        name: "getCurrentLibraryVersion",
+        tracer,
+        fn: async () => {
+          return await getCurrentLibraryVersion(pm);
+        },
+      });
+
+      // Skip if we're in local development
+      if (
+        !currentCliInfo ||
+        !valid(currentCliInfo.version) ||
+        currentCliInfo.version.startsWith("file:") ||
+        currentCliInfo.version.startsWith("link:") ||
+        !currentLibraryInfo ||
+        !valid(currentLibraryInfo.version) ||
+        currentLibraryInfo.version.startsWith("file:") ||
+        currentLibraryInfo.version.startsWith("link:")
+      ) {
+        return;
+      }
+
+      // Get target versions from server
+      const targetVersions = await traceFunction({
+        name: "getRemoteVersions",
+        tracer,
+        fn: async () => {
+          return await getRemoteVersions(config);
+        },
+      });
+      if (!targetVersions) return;
+
+      let cliNeedsUpgrade: boolean | string;
+      let libraryNeedsUpgrade: boolean | string;
+      try {
+        // If version is latest, then semver can throw an error
+        // Check if CLI needs upgrade
+        cliNeedsUpgrade =
+          targetVersions.cli && gt(targetVersions.cli, currentCliInfo.version);
+
+        // Check if library needs upgrade
+        libraryNeedsUpgrade =
+          targetVersions.library &&
+          gt(targetVersions.library, currentLibraryInfo.version);
+      } catch (error) {
+        logger.error(
+          "Error checking versions to upgrade, releasing lock and exiting",
+          getErrorMeta(error),
+        );
+        await traceFunction({
+          name: "shutdownLockService",
+          tracer,
+          fn: async () => {
+            await lockService.shutdown({
+              serverInitiated: false,
+            });
+          },
+        });
+        hasFailedToUpgrade = true;
+        return;
+      }
+
+      if (!cliNeedsUpgrade && !libraryNeedsUpgrade) {
+        return; // Everything is up to date
+      }
+
+      let cliUpdated = false;
+      let libraryUpdated = false;
+
+      // Upgrade CLI if needed
+      if (cliNeedsUpgrade) {
+        logger.info(
+          `Beginning CLI upgrade from ${currentCliInfo.version} to ${targetVersions.cli}`,
+        );
 
-  // Get target versions from server
-  const targetVersions = await getRemoteVersions(config);
-  if (!targetVersions) return;
+        const oclifUpgradeSucceeded = await traceFunction({
+          name: "upgradeCliWithOclif",
+          tracer,
+          fn: async () => {
+            return await upgradeCliWithOclif(targetVersions.cli);
+          },
+        });
+        if (!oclifUpgradeSucceeded) {
+          logger.info(`Falling back to package manager upgrade for CLI`);
+          // Fall back to package manager upgrade
+          await traceFunction({
+            name: "upgradePackageWithPackageManager - cli",
+            tracer,
+            fn: async () => {
+              await upgradePackageWithPackageManager(
+                pm,
+                "cli",
+                targetVersions.cli,
+                {
+                  alias: currentCliInfo.alias,
+                  global: true,
+                },
+              );
+            },
+          });
+          cliUpdated = true;
+        }
+      }
+
+      // Upgrade library if needed
+      if (libraryNeedsUpgrade) {
+        logger.info(
+          `Beginning library upgrade from ${currentLibraryInfo.version} to ${targetVersions.library}`,
+        );
+        await traceFunction({
+          name: "upgradePackageWithPackageManager - library",
+          tracer,
+          fn: async () => {
+            await upgradePackageWithPackageManager(
+              pm,
+              "library",
+              targetVersions.library,
+              {
+                alias: currentLibraryInfo.alias,
+                global: false,
+              },
+            );
+          },
+        });
+        libraryUpdated = true;
+      }
+
+      // Log what was updated
+      if (cliUpdated && libraryUpdated) {
+        logger.info(
+          "@superblocksteam/cli and @superblocksteam/library have been updated.",
+        );
+      } else if (cliUpdated) {
+        logger.info("@superblocksteam/cli has been updated.");
+      } else if (libraryUpdated) {
+        logger.info("@superblocksteam/library has been updated.");
+      } else {
+        logger.info("No upgrades needed");
+      }
+    },
+  });
 
-  let cliNeedsUpgrade: boolean | string;
-  let libraryNeedsUpgrade: boolean | string;
-  try {
-    // If version is latest, then semver can throw an error
-    // Check if CLI needs upgrade
-    cliNeedsUpgrade =
-      targetVersions.cli && gt(targetVersions.cli, currentCliVersion);
-
-    // Check if library needs upgrade
-    libraryNeedsUpgrade =
-      targetVersions.library &&
-      gt(targetVersions.library, currentLibraryInfo.version);
-  } catch (error) {
-    console.warn(
-      "Error checking versions to upgrade, releasing lock and exiting",
-      error,
-    );
-    await lockService.shutdown({
-      serverInitiated: false,
-    });
+  // Restart CLI if anything was updated
+  if (hasFailedToUpgrade) {
     process.exit(1);
   }
 
-  if (!cliNeedsUpgrade && !libraryNeedsUpgrade) {
-    return; // Everything is up to date
-  }
-
-  let cliUpdated = false;
-  let libraryUpdated = false;
-
-  // Upgrade CLI if needed
-  if (cliNeedsUpgrade) {
-    const oclifUpgradeSucceeded = await upgradeCliWithOclif(targetVersions.cli);
-
-    if (!oclifUpgradeSucceeded) {
-      // Fall back to package manager upgrade
-      await upgradePackageWithPackageManager(pm, "cli", targetVersions.cli);
-      cliUpdated = true;
-    }
-  }
-
-  // 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.",
-    );
-  } else if (cliUpdated) {
-    logger.info("@superblocksteam/cli has been updated.");
-  } else if (libraryUpdated) {
-    logger.info("@superblocksteam/library has been updated.");
-  }
-
-  // Restart CLI if anything was updated
-  if (cliUpdated || libraryUpdated) {
-    logger.info("Restarting the CLI…");
-    await lockService.releaseLock();
-    process.exit(AUTO_UPGRADE_EXIT_CODE);
-  }
+  return {
+    cliUpdated,
+    libraryUpdated,
+  };
 }

package/src/cli-replacement/dev.mts

@@ -1,7 +1,6 @@
 import "../dev-utils/dev-tracer.js";
 
 import * as child_process from "node:child_process";
-import * as fsp from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 import { maskUnixSignals } from "@superblocksteam/util";
@@ -18,7 +17,7 @@ import fs from "fs-extra";
 import { resolveCommand } from "package-manager-detector";
 import { detect } from "package-manager-detector/detect";
 
-import { getLogger } from "../dev-utils/dev-logger.mjs";
+import { getErrorMeta, getLogger } from "../dev-utils/dev-logger.mjs";
 import { createDevServer } from "../dev-utils/dev-server.mjs";
 import tracer from "../dev-utils/dev-tracer.js";
 import { SuperblocksSdk } from "../sdk.js";
@@ -27,6 +26,7 @@ import {
   getCurrentCliVersion,
   getCurrentLibraryVersionWithoutPM,
 } from "./automatic-upgrades.js";
+import { AUTO_UPGRADE_EXIT_CODE } from "./automatic-upgrades.js";
 import type { DevLogger } from "../dev-utils/dev-logger.mjs";
 import type { ApplicationConfig } from "../types/common.js";
 import type { DraftInterface } from "@superblocksteam/vite-plugin-file-sync/draft-interface";
@@ -93,7 +93,6 @@ async function installPackages(cwd: string, logger: DevLogger) {
 export async function dev(options: {
   /* cwd is required */
   cwd: string;
-  pidfilePath?: string;
   devServerPort?: number;
 
   /* user control of sync operations */
@@ -107,7 +106,7 @@ export async function dev(options: {
   /* For debugging purposes to get location of the cli */
   superblocksPath?: string;
   /* For redirecting output, like when running outside of the CLI */
-  logger?: (message: string) => void;
+  logger?: (...messages: (string | Error)[]) => void;
 
   /* For a child process when restarting the dev server for automatic upgrades */
   skipAutoUpgrade?: boolean;
@@ -119,7 +118,6 @@ export async function dev(options: {
 
   const {
     cwd,
-    pidfilePath,
     devServerPort,
     downloadFirst,
     uploadFirst,
@@ -128,12 +126,6 @@ export async function dev(options: {
     skipAutoUpgrade,
   } = options;
 
-  const cliVersion = await getCurrentCliVersion();
-  const libraryVersion = await getCurrentLibraryVersionWithoutPM();
-  logger.info(
-    `Running command: ${options.superblocksPath} dev${options.uploadFirst ? " --upload-first" : ""}${options.downloadFirst ? " --download-first" : ""} with baseUrl: ${applicationConfig?.superblocksBaseUrl}, cliVersion: ${cliVersion}, libraryVersion: ${libraryVersion?.alias} ${libraryVersion?.version}`,
-  );
-
   // Add check for node_modules
   if (!fs.existsSync(path.join(cwd, "node_modules"))) {
     throw new Error(
@@ -141,9 +133,13 @@ export async function dev(options: {
     );
   }
 
-  if (pidfilePath) {
-    await fsp.writeFile(pidfilePath, `${process.pid}\n`);
-  }
+  logger.info("Starting dev server");
+
+  const cliVersion = await getCurrentCliVersion();
+  const libraryVersion = await getCurrentLibraryVersionWithoutPM();
+  logger.info(
+    `Running command: ${options.superblocksPath} dev${options.uploadFirst ? " --upload-first" : ""}${options.downloadFirst ? " --download-first" : ""} with baseUrl: ${applicationConfig?.superblocksBaseUrl}, cliVersion: ${cliVersion}, libraryVersion: ${libraryVersion?.alias} ${libraryVersion?.version}`,
+  );
 
   const port = devServerPort ?? 5173;
 
@@ -188,17 +184,11 @@ export async function dev(options: {
         if (lockService) {
           try {
             await lockService!.acquireLock();
-
-            // TODO(code-mode): package naming is preventing upgrade in ephemeral environments
-            if (
-              !process.env.PACKAGE_SUFFIX ||
-              process.env.PACKAGE_SUFFIX === "" ||
-              !skipAutoUpgrade
-            ) {
-              await checkVersionsAndUpgrade(lockService, applicationConfig);
-            }
           } catch (error) {
-            logger.error("Failed to acquire lock on application", error);
+            logger.error(
+              "Failed to acquire lock on application",
+              getErrorMeta(error),
+            );
             passErrorToVSCode(
               (error as { context?: { message: string } }).context?.message,
               logger,
@@ -222,7 +212,6 @@ export async function dev(options: {
           appRootDirPath: options.cwd,
           applicationId: applicationConfig.id,
           organizationId: currentUser.organizations[0].id,
-          anthropicApiKey: process.env.ANTHROPIC_API_KEY || "",
           fsOperationQueue,
           draftInterface: syncService! as DraftInterface,
           tracer,
@@ -232,11 +221,10 @@ export async function dev(options: {
 
         if (isSynced) {
           logger.info("Local files are in sync with the server");
-          return;
+        } else {
+          logger.info("Local files are out of sync with the server");
         }
 
-        logger.info("Local files are out of sync with the server");
-
         if (!(downloadFirst || uploadFirst)) {
           throw new Error(
             "You must choose --download-first or --upload-first to use the dev command",
@@ -246,37 +234,70 @@ export async function dev(options: {
           throw new Error("Choose either --download-first or --upload-first");
         }
 
+        let hasPackageChanged = false;
+
         if (downloadFirst) {
-          logger.info(
-            "Starting directory sync from server before starting the local server",
-          );
+          logger.info("Starting download");
 
-          // Read package.json before download
           const packageJsonBefore = await readPkgJson(cwd);
-
           await syncService!.downloadDirectory();
-
-          // Read package.json after download and compare
           const packageJsonAfter = await readPkgJson(cwd);
 
-          // Check if package.json changed
           if (packageJsonBefore && packageJsonAfter) {
             const diff = diffJson(packageJsonBefore, packageJsonAfter);
-            const hasChanges = diff.some((part) => part.added || part.removed);
+            hasPackageChanged = diff.some((part) => part.added || part.removed);
+          } else if (packageJsonAfter) {
+            hasPackageChanged = true;
+            logger.info("package.json was created, installing packages…");
+          }
+        }
 
-            if (hasChanges) {
-              logger.info("package.json has changed, installing packages…");
-              await installPackages(cwd, logger);
+        let hasCliUpdated = false;
+        if (
+          !process.env.PACKAGE_SUFFIX ||
+          process.env.PACKAGE_SUFFIX === "" ||
+          !skipAutoUpgrade
+        ) {
+          if (lockService) {
+            const result = await checkVersionsAndUpgrade(
+              lockService,
+              applicationConfig,
+            );
+            if (result?.libraryUpdated) {
+              hasPackageChanged = true;
             }
+            hasCliUpdated = result?.cliUpdated ?? false;
+          } else {
+            logger.warn(
+              "Lock service is not available, skipping version check and upgrade",
+            );
           }
-        } else if (uploadFirst) {
+        }
+
+        if (hasPackageChanged) {
+          logger.info("Installing packages…");
+          await installPackages(cwd, logger);
+        }
+
+        if (hasPackageChanged || uploadFirst) {
           logger.info("Uploading local files to server before starting");
           await syncService!.uploadDirectory();
+          await syncService!.uploadDirectoryNowIfNeeded();
+        }
+
+        if (hasCliUpdated) {
+          logger.info("CLI was updated, restarting the dev server…");
+          process.exit(AUTO_UPGRADE_EXIT_CODE);
         }
       });
     } catch (error: any) {
       logger.error(error.message);
-      process.exit(1);
+      try {
+        await lockService?.shutdownAndExit();
+      } finally {
+        // this is redundant, but it's here to make sure the lock service is shutdown and the process exits
+        process.exit(1);
+      }
     }
   } else {
     logger.info("Skipping directory sync");
@@ -296,6 +317,10 @@ export async function dev(options: {
   options.signal?.addEventListener("abort", () => {
     logger.info("Server closed");
     httpServer.close();
+    lockService?.shutdownAndExit().catch(() => {
+      // this is redundant, but it's here to make sure the lock service is shutdown and the process exits
+      process.exit(1);
+    });
   });
 
   logger.debug(green(`Local server started at port ${port}`));