@superblocksteam/sdk 2.0.83 → 2.0.84-next.0

package/src/cli-replacement/dev.mts

@@ -23,10 +23,8 @@ import { detect } from "package-manager-detector/detect";
 import { AUTO_UPGRADE_EXIT_CODE, createDevServer } from "../index.js";
 import { getTracer } from "../telemetry/index.js";
 import { getErrorMeta, getLogger, type Logger } from "../telemetry/logging.js";
-import {
-  checkVersionsAndWritePackageJson,
-  getCurrentCliVersion,
-} from "./automatic-upgrades.js";
+import { checkVersionsAndWritePackageJson } from "./automatic-upgrades.js";
+import { getCurrentCliVersion } from "./version-detection.js";
 import type {
   AuthHotReloadServer,
   TokenManager,
@@ -284,322 +282,379 @@ export async function dev(options: {
   const logger = getLogger(options.logger);
   const skipAutoUpgrade = autoUpgradeMode === DevServerAutoUpgradeMode.SKIP;
 
-  // Add check for node_modules
-  if (!fs.existsSync(path.join(cwd, "node_modules"))) {
-    throw new Error(
-      'node_modules folder is missing. Please run "npm install" first.',
-    );
-  }
-
-  const cliVersion = await getCurrentCliVersion();
-  logger.info(
-    `Running command: ${options.superblocksPath} dev${options.uploadFirst ? " --upload-first" : ""}${options.downloadFirst ? " --download-first" : ""} with baseUrl: ${tokenConfig.superblocksBaseUrl}, cliVersion: ${cliVersion?.version}${cliVersion?.alias ? ` (${cliVersion.alias})` : ""}`,
-  );
-
-  const port = devServerPort ?? 5173;
-
-  const fsOperationQueue = new OperationQueue();
-  if (applicationConfig && !skipSync) {
-    const rpcClient = new AutoConnectingRpcClient(
-      tokenConfig.superblocksBaseUrl,
-      tokenConfig.token,
-      tracer,
-      tokenManager,
-      logger,
-    );
+  await tracer.startActiveSpan("devServerStartup", async (startupSpan) => {
+    try {
+      // Add check for node_modules
+      if (!fs.existsSync(path.join(cwd, "node_modules"))) {
+        throw new Error(
+          'node_modules folder is missing. Please run "npm install" first.',
+        );
+      }
 
-    // Get feature flags for inactivity timeout
-    const featureFlags = await sdk.getFeatureFlagsForCurrentUser();
-    const lockType =
-      process.env.SUPERBLOCKS_IS_CSB === "true" ? LockType.CSB : LockType.LOCAL;
-    const inactivityTimeoutMs =
-      lockType === LockType.CSB
-        ? featureFlags.devServerCloudInactivityTimeoutMinutes() * 60 * 1000
-        : featureFlags.devServerLocalInactivityTimeoutMinutes() * 60 * 1000;
-
-    lockService = new LockService({
-      superblocksBaseUrl: tokenConfig.superblocksBaseUrl,
-      applicationId: applicationConfig.id,
-      branchName: applicationConfig.branchName,
-      lockType: lockType,
-      tracer,
-      logger,
-      rpcClient,
-      inactivityThresholdMs: inactivityTimeoutMs,
-    });
+      const cliVersion = await tracer.startActiveSpan(
+        "getCurrentCliVersion",
+        async (span) => {
+          try {
+            return await getCurrentCliVersion();
+          } finally {
+            span.end();
+          }
+        },
+      );
+      logger.info(
+        `Running command: ${options.superblocksPath} dev${options.uploadFirst ? " --upload-first" : ""}${options.downloadFirst ? " --download-first" : ""} with baseUrl: ${tokenConfig.superblocksBaseUrl}, cliVersion: ${cliVersion?.version}${cliVersion?.alias ? ` (${cliVersion.alias})` : ""}`,
+      );
 
-    syncService = new SyncService({
-      appRootDirPath: cwd,
-      applicationId: applicationConfig.id,
-      branchName: applicationConfig.branchName,
-      fsOperationQueue,
-      lockService: lockService,
-      tracer,
-      superblocksBaseUrl: tokenConfig.superblocksBaseUrl,
-      rpcClient,
-      logger,
-    });
+      const port = devServerPort ?? 5173;
 
-    logger.info("Checking if local files are synced with the server");
+      const fsOperationQueue = new OperationQueue();
+      if (applicationConfig && !skipSync) {
+        const rpcClient = new AutoConnectingRpcClient(
+          tokenConfig.superblocksBaseUrl,
+          tokenConfig.token,
+          tracer,
+          tokenManager,
+          logger,
+        );
 
-    try {
-      await maskUnixSignals(async () => {
-        if (lockService) {
-          const lockSvc = lockService;
-          await tracer.startActiveSpan("acquiringInitialLock", async (span) => {
+        // Get feature flags for inactivity timeout
+        const featureFlags = await tracer.startActiveSpan(
+          "getFeatureFlags",
+          async (span) => {
             try {
-              // If --force-takeover flag is set, immediately force takeover instead of acquiring
-              if (options.forceTakeover) {
-                logger.info("Force takeover requested, taking over lock...");
-                await lockSvc.forceTakeover();
-                logger.info("Lock acquired successfully via force takeover.");
-              } else {
-                await lockSvc.acquireLock();
-              }
-            } catch (error) {
-              // If we got a conflict error (409), inspect the lock for more information
-              if (error instanceof ConflictError) {
-                await handleLockConflict(error, lockSvc, span, logger);
-                return;
-              }
-
-              logger.error(
-                "Failed to acquire lock on application",
-                getErrorMeta(error),
-              );
-              span.setStatus({
-                code: SpanStatusCode.ERROR,
-                message: JSON.stringify(error),
-              });
-              passErrorToVSCode(
-                (error as { context?: { message: string } }).context?.message,
-                logger,
-              );
-              throw new Error(
-                `Failed to acquire lock on application: ${error}`,
-              );
+              return await sdk.getFeatureFlagsForCurrentUser();
             } finally {
               span.end();
             }
-          });
-        }
-
-        const [localContents, serverHash, currentUser] =
-          await tracer.startActiveSpan("fetchInitInfo", async (span) => {
-            const results = await Promise.all([
-              sdk.hashLocalDirectory(cwd),
-              getDraftOrLiveEditHash(sdk, applicationConfig, logger),
-              sdk.fetchCurrentUser(),
-            ]);
-            span.end();
-            return results;
-          });
-
-        aiService = new AiService({
+          },
+        );
+        const lockType =
+          process.env.SUPERBLOCKS_IS_CSB === "true"
+            ? LockType.CSB
+            : LockType.LOCAL;
+        const inactivityTimeoutMs =
+          lockType === LockType.CSB
+            ? featureFlags.devServerCloudInactivityTimeoutMinutes() * 60 * 1000
+            : featureFlags.devServerLocalInactivityTimeoutMinutes() * 60 * 1000;
+
+        lockService = new LockService({
           superblocksBaseUrl: tokenConfig.superblocksBaseUrl,
-          appRootDirPath: options.cwd,
           applicationId: applicationConfig.id,
-          organizationId: currentUser.organizations[0].id,
-          fsOperationQueue,
-          draftInterface: syncService as DraftInterface,
+          branchName: applicationConfig.branchName,
+          lockType: lockType,
+          tracer,
+          logger,
           rpcClient,
+          inactivityThresholdMs: inactivityTimeoutMs,
+        });
+
+        syncService = new SyncService({
+          appRootDirPath: cwd,
+          applicationId: applicationConfig.id,
+          branchName: applicationConfig.branchName,
+          fsOperationQueue,
+          lockService: lockService,
           tracer,
+          superblocksBaseUrl: tokenConfig.superblocksBaseUrl,
+          rpcClient,
           logger,
-          tokenManager,
-          features: AiServiceFeatureFlags.create(
-            currentUser.flagBootstrap as Record<string, unknown> | undefined,
-          ),
-          pluginExecutionVersions:
-            currentUser.organizations[0].pluginExecutionVersions,
         });
 
-        await aiService.initialize();
+        logger.info("Checking if local files are synced with the server");
+
+        try {
+          await maskUnixSignals(async () => {
+            if (lockService) {
+              const lockSvc = lockService;
+              await tracer.startActiveSpan(
+                "acquiringInitialLock",
+                async (span) => {
+                  try {
+                    // If --force-takeover flag is set, immediately force takeover instead of acquiring
+                    if (options.forceTakeover) {
+                      logger.info(
+                        "Force takeover requested, taking over lock...",
+                      );
+                      await lockSvc.forceTakeover();
+                      logger.info(
+                        "Lock acquired successfully via force takeover.",
+                      );
+                    } else {
+                      await lockSvc.acquireLock();
+                    }
+                  } catch (error) {
+                    // If we got a conflict error (409), inspect the lock for more information
+                    if (error instanceof ConflictError) {
+                      await handleLockConflict(error, lockSvc, span, logger);
+                      return;
+                    }
+
+                    logger.error(
+                      "Failed to acquire lock on application",
+                      getErrorMeta(error),
+                    );
+                    span.setStatus({
+                      code: SpanStatusCode.ERROR,
+                      message: JSON.stringify(error),
+                    });
+                    passErrorToVSCode(
+                      (error as { context?: { message: string } }).context
+                        ?.message,
+                      logger,
+                    );
+                    throw new Error(
+                      `Failed to acquire lock on application: ${error}`,
+                    );
+                  } finally {
+                    span.end();
+                  }
+                },
+              );
+            }
 
-        const isSynced = localContents.hash === serverHash;
+            const [localContents, serverHash, currentUser] =
+              await tracer.startActiveSpan("fetchInitInfo", async (span) => {
+                try {
+                  const results = await Promise.all([
+                    sdk.hashLocalDirectory(cwd),
+                    getDraftOrLiveEditHash(sdk, applicationConfig, logger),
+                    sdk.fetchCurrentUser(),
+                  ]);
+                  return results;
+                } finally {
+                  span.end();
+                }
+              });
 
-        if (isSynced) {
-          logger.info(
-            `Local files are in sync with the server on branch '${applicationConfig.branchName}', local hash: ${localContents.hash}, server hash: ${serverHash}`,
-          );
-        } else {
-          logger.info(
-            `Local files are out of sync with the server on branch '${applicationConfig.branchName}', local hash: ${localContents.hash}, server hash: ${serverHash}`,
-          );
-        }
+            aiService = new AiService({
+              superblocksBaseUrl: tokenConfig.superblocksBaseUrl,
+              appRootDirPath: options.cwd,
+              applicationId: applicationConfig.id,
+              organizationId: currentUser.organizations[0].id,
+              fsOperationQueue,
+              draftInterface: syncService as DraftInterface,
+              rpcClient,
+              tracer,
+              logger,
+              tokenManager,
+              features: AiServiceFeatureFlags.create(
+                currentUser.flagBootstrap as
+                  | Record<string, unknown>
+                  | undefined,
+              ),
+              pluginExecutionVersions:
+                currentUser.organizations[0].pluginExecutionVersions,
+            });
+
+            await tracer.startActiveSpan(
+              "aiServiceInitialize",
+              async (span) => {
+                try {
+                  await aiService!.initialize();
+                } finally {
+                  span.end();
+                }
+              },
+            );
 
-        if (!(downloadFirst || uploadFirst)) {
-          throw new Error(
-            "You must choose --download-first or --upload-first to use the dev command",
-          );
-        }
-        if (downloadFirst && uploadFirst) {
-          throw new Error("Choose either --download-first or --upload-first");
-        }
+            const isSynced = localContents.hash === serverHash;
 
-        let hasPackageChanged = false;
+            if (isSynced) {
+              logger.info(
+                `Local files are in sync with the server on branch '${applicationConfig.branchName}', local hash: ${localContents.hash}, server hash: ${serverHash}`,
+              );
+            } else {
+              logger.info(
+                `Local files are out of sync with the server on branch '${applicationConfig.branchName}', local hash: ${localContents.hash}, server hash: ${serverHash}`,
+              );
+            }
 
-        const packageJsonBefore = await readPkgJson(cwd);
+            if (!(downloadFirst || uploadFirst)) {
+              throw new Error(
+                "You must choose --download-first or --upload-first to use the dev command",
+              );
+            }
+            if (downloadFirst && uploadFirst) {
+              throw new Error(
+                "Choose either --download-first or --upload-first",
+              );
+            }
 
-        if (downloadFirst && !isSynced) {
-          await tracer.startActiveSpan("downloadFirst", async (span) => {
-            logger.info(
-              `Starting download of branch '${applicationConfig.branchName}'`,
-            );
+            let hasPackageChanged = false;
 
-            await syncService!.downloadDirectory();
-            span.end();
-          });
-        }
+            const packageJsonBefore = await readPkgJson(cwd);
 
-        let hasCliUpdated = false;
-        let upgradePromises: Promise<void>[] = [];
-        const forceUpgrade =
-          options.autoUpgradeMode === DevServerAutoUpgradeMode.FORCE;
-        // Determine whether we must try to auto-upgrade the CLI
-        if (!skipAutoUpgrade || forceUpgrade) {
-          await tracer.startActiveSpan(
-            "versionCheckAndUpgrade",
-            async (span) => {
-              if (lockService) {
-                const applicationConfigWithTokenConfigAndUserInfo: ApplicationConfigWithTokenConfigAndUserInfo =
-                  {
-                    ...applicationConfig,
-                    superblocksBaseUrl: tokenConfig.superblocksBaseUrl,
-                    token: tokenConfig.token,
-                    userId: currentUser.user.id,
-                    userEmail: currentUser.user.email,
-                    organizationId: currentUser.user.currentOrganizationId,
-                    featureFlags: sdk.getFeatureFlagsForUser(currentUser),
-                  };
-
-                const result = await checkVersionsAndWritePackageJson(
-                  lockService,
-                  applicationConfigWithTokenConfigAndUserInfo,
-                  forceUpgrade,
+            if (downloadFirst && !isSynced) {
+              await tracer.startActiveSpan("downloadFirst", async (span) => {
+                logger.info(
+                  `Starting download of branch '${applicationConfig.branchName}'`,
                 );
-                hasCliUpdated = result.cliUpdated;
-                upgradePromises = result.upgradePromises;
-              } else {
-                logger.warn(
-                  "Lock service is not available, skipping version check and upgrade",
-                );
-              }
-              span.end();
-            },
-          );
-        }
 
-        const packageJsonAfter = await readPkgJson(cwd);
+                await syncService!.downloadDirectory();
+                span.end();
+              });
+            }
 
-        if (packageJsonBefore && packageJsonAfter) {
-          hasPackageChanged =
-            JSON.stringify(packageJsonBefore, null, 2) !==
-            JSON.stringify(packageJsonAfter, null, 2);
-        } else if (packageJsonAfter) {
-          hasPackageChanged = true;
-          logger.info("package.json was created, installing packages…");
-        }
+            let hasCliUpdated = false;
+            let upgradePromises: Promise<void>[] = [];
+            const forceUpgrade =
+              options.autoUpgradeMode === DevServerAutoUpgradeMode.FORCE;
+            // Determine whether we must try to auto-upgrade the CLI
+            if (!skipAutoUpgrade || forceUpgrade) {
+              await tracer.startActiveSpan(
+                "versionCheckAndUpgrade",
+                async (span) => {
+                  if (lockService) {
+                    const applicationConfigWithTokenConfigAndUserInfo: ApplicationConfigWithTokenConfigAndUserInfo =
+                      {
+                        ...applicationConfig,
+                        superblocksBaseUrl: tokenConfig.superblocksBaseUrl,
+                        token: tokenConfig.token,
+                        userId: currentUser.user.id,
+                        userEmail: currentUser.user.email,
+                        organizationId: currentUser.user.currentOrganizationId,
+                        featureFlags: sdk.getFeatureFlagsForUser(currentUser),
+                      };
+
+                    const result = await checkVersionsAndWritePackageJson(
+                      lockService,
+                      applicationConfigWithTokenConfigAndUserInfo,
+                      forceUpgrade,
+                    );
+                    hasCliUpdated = result.cliUpdated;
+                    upgradePromises = result.upgradePromises;
+                  } else {
+                    logger.warn(
+                      "Lock service is not available, skipping version check and upgrade",
+                    );
+                  }
+                  span.end();
+                },
+              );
+            }
 
-        if (hasPackageChanged || upgradePromises.length > 0) {
-          logger.info("Installing packages…");
-          await tracer.startActiveSpan("installPackages", async (span) => {
-            // Upgrade global CLI and local packages in parallel - improves performance
-            await Promise.all([
-              ...upgradePromises,
-              installPackages(cwd, logger),
-            ]);
-            span.end();
-          });
-        } else {
-          logger.info(
-            "package.json has not changed, skipping package installation",
-          );
-        }
+            const packageJsonAfter = await readPkgJson(cwd);
 
-        if (hasPackageChanged || uploadFirst) {
-          logger.info(
-            `Uploading local files to branch '${applicationConfig.branchName}' on server before starting`,
-          );
-          await tracer.startActiveSpan(
-            "uploadFirstOrPackageChanged",
-            async (span) => {
-              await syncService!.uploadDirectory("cli:sdk");
-              await syncService!.uploadDirectoryNowIfNeeded("cli:sdk");
-              span.end();
-            },
-          );
-        }
+            if (packageJsonBefore && packageJsonAfter) {
+              hasPackageChanged =
+                JSON.stringify(packageJsonBefore, null, 2) !==
+                JSON.stringify(packageJsonAfter, null, 2);
+            } else if (packageJsonAfter) {
+              hasPackageChanged = true;
+              logger.info("package.json was created, installing packages…");
+            }
+
+            if (hasPackageChanged || upgradePromises.length > 0) {
+              logger.info("Installing packages…");
+              await tracer.startActiveSpan("installPackages", async (span) => {
+                try {
+                  // Upgrade global CLI and local packages in parallel - improves performance
+                  await Promise.all([
+                    ...upgradePromises,
+                    installPackages(cwd, logger),
+                  ]);
+                } finally {
+                  span.end();
+                }
+              });
+            } else {
+              logger.info(
+                "package.json has not changed, skipping package installation",
+              );
+            }
+
+            if (hasPackageChanged || uploadFirst) {
+              logger.info(
+                `Uploading local files to branch '${applicationConfig.branchName}' on server before starting`,
+              );
+              await tracer.startActiveSpan(
+                "uploadFirstOrPackageChanged",
+                async (span) => {
+                  await syncService!.uploadDirectory("cli:sdk");
+                  await syncService!.uploadDirectoryNowIfNeeded("cli:sdk");
+                  span.end();
+                },
+              );
+            }
 
-        if (hasCliUpdated) {
+            if (hasCliUpdated) {
+              try {
+                logger.info("Releasing lock before restarting the dev server");
+                await aiService?.removeIntegrationCache();
+                await lockService?.shutdown({ serverInitiated: false });
+              } catch (e) {
+                logger.error(
+                  "Error releasing lock before restarting the dev server",
+                  getErrorMeta(e),
+                );
+              }
+              logger.info("CLI was updated, restarting the dev server…");
+              process.exit(AUTO_UPGRADE_EXIT_CODE);
+            }
+          });
+        } catch (error: any) {
+          logger.error(error.message);
           try {
-            logger.info("Releasing lock before restarting the dev server");
             await aiService?.removeIntegrationCache();
-            await lockService?.shutdown({ serverInitiated: false });
-          } catch (e) {
-            logger.error(
-              "Error releasing lock before restarting the dev server",
-              getErrorMeta(e),
-            );
+            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);
           }
-          logger.info("CLI was updated, restarting the dev server…");
-          process.exit(AUTO_UPGRADE_EXIT_CODE);
         }
-      });
-    } catch (error: any) {
-      logger.error(error.message);
-      try {
-        await aiService?.removeIntegrationCache();
-        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");
       }
-    }
-  } else {
-    logger.info("Skipping directory sync");
-  }
 
-  const httpServer = await tracer.startActiveSpan(
-    "createDevServer",
-    async (span) => {
-      const result = await createDevServer({
-        root: options.cwd,
-        mode: "development",
-        port: port,
-        fsOperationQueue,
-        syncService: syncService,
-        lockService: lockService,
-        aiService: aiService,
-        logger: options.logger,
-        sdk,
-      });
-      span.end();
-      return result;
-    },
-  );
+      const httpServer = await tracer.startActiveSpan(
+        "createDevServer",
+        async (span) => {
+          const result = await createDevServer({
+            root: options.cwd,
+            mode: "development",
+            port: port,
+            fsOperationQueue,
+            syncService: syncService,
+            lockService: lockService,
+            aiService: aiService,
+            logger: options.logger,
+            sdk,
+          });
+          span.end();
+          return result;
+        },
+      );
 
-  options.signal?.addEventListener("abort", () => {
-    logger.info("Server closed");
-    httpServer.close();
-    // Stop auth hot-reload server on abort
-    if (authHotReloadServer) {
-      authHotReloadServer.stop().catch((error: any) => {
-        logger.warn(`Error stopping auth hot-reload server: ${error}`);
+      options.signal?.addEventListener("abort", () => {
+        logger.info("Server closed");
+        httpServer.close();
+        // Stop auth hot-reload server on abort
+        if (authHotReloadServer) {
+          authHotReloadServer.stop().catch((error: any) => {
+            logger.warn(`Error stopping auth hot-reload server: ${error}`);
+          });
+        }
+        // Clean up AI service cache (must happen before app switches directories)
+        aiService?.removeIntegrationCache().catch((error: any) => {
+          logger.warn(`Error removing integration cache: ${error}`);
+        });
+        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}`));
+      logger.debug(green(`Visit your application at:`));
+      logger.debug(green(`http://localhost:${port}`));
+
+      startupSpan.end();
+    } catch (error) {
+      startupSpan.setStatus({ code: SpanStatusCode.ERROR });
+      startupSpan.end();
+      throw error;
     }
-    // Clean up AI service cache (must happen before app switches directories)
-    aiService?.removeIntegrationCache().catch((error: any) => {
-      logger.warn(`Error removing integration cache: ${error}`);
-    });
-    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}`));
-  logger.debug(green(`Visit your application at:`));
-  logger.debug(green(`http://localhost:${port}`));
 }
 async function getDraftOrLiveEditHash(
   sdk: SuperblocksSdk,