@superblocksteam/sdk 2.0.83-next.1 → 2.0.83

package/src/cli-replacement/dev.mts

@@ -23,8 +23,10 @@ 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 } from "./automatic-upgrades.js";
-import { getCurrentCliVersion } from "./version-detection.js";
+import {
+  checkVersionsAndWritePackageJson,
+  getCurrentCliVersion,
+} from "./automatic-upgrades.js";
 import type {
   AuthHotReloadServer,
   TokenManager,
@@ -282,379 +284,322 @@ export async function dev(options: {
   const logger = getLogger(options.logger);
   const skipAutoUpgrade = autoUpgradeMode === DevServerAutoUpgradeMode.SKIP;
 
-  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.',
-        );
-      }
+  // 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 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})` : ""}`,
-      );
+  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 port = devServerPort ?? 5173;
 
-      const fsOperationQueue = new OperationQueue();
-      if (applicationConfig && !skipSync) {
-        const rpcClient = new AutoConnectingRpcClient(
-          tokenConfig.superblocksBaseUrl,
-          tokenConfig.token,
-          tracer,
-          tokenManager,
-          logger,
-        );
+  const fsOperationQueue = new OperationQueue();
+  if (applicationConfig && !skipSync) {
+    const rpcClient = new AutoConnectingRpcClient(
+      tokenConfig.superblocksBaseUrl,
+      tokenConfig.token,
+      tracer,
+      tokenManager,
+      logger,
+    );
+
+    // 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,
+    });
 
-        // Get feature flags for inactivity timeout
-        const featureFlags = await tracer.startActiveSpan(
-          "getFeatureFlags",
-          async (span) => {
+    syncService = new SyncService({
+      appRootDirPath: cwd,
+      applicationId: applicationConfig.id,
+      branchName: applicationConfig.branchName,
+      fsOperationQueue,
+      lockService: lockService,
+      tracer,
+      superblocksBaseUrl: tokenConfig.superblocksBaseUrl,
+      rpcClient,
+      logger,
+    });
+
+    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 {
-              return await sdk.getFeatureFlagsForCurrentUser();
+              // 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 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,
-        });
+          });
+        }
 
-        syncService = new SyncService({
-          appRootDirPath: cwd,
+        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({
+          superblocksBaseUrl: tokenConfig.superblocksBaseUrl,
+          appRootDirPath: options.cwd,
           applicationId: applicationConfig.id,
-          branchName: applicationConfig.branchName,
+          organizationId: currentUser.organizations[0].id,
           fsOperationQueue,
-          lockService: lockService,
-          tracer,
-          superblocksBaseUrl: tokenConfig.superblocksBaseUrl,
+          draftInterface: syncService as DraftInterface,
           rpcClient,
+          tracer,
           logger,
+          tokenManager,
+          features: AiServiceFeatureFlags.create(
+            currentUser.flagBootstrap as Record<string, unknown> | undefined,
+          ),
+          pluginExecutionVersions:
+            currentUser.organizations[0].pluginExecutionVersions,
         });
 
-        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();
-                  }
-                },
-              );
-            }
+        await aiService.initialize();
 
-            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();
-                }
-              });
+        const isSynced = localContents.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 (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 isSynced = localContents.hash === serverHash;
+        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 (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}`,
-              );
-            }
+        let hasPackageChanged = false;
 
-            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 packageJsonBefore = await readPkgJson(cwd);
 
-            let hasPackageChanged = false;
+        if (downloadFirst && !isSynced) {
+          await tracer.startActiveSpan("downloadFirst", async (span) => {
+            logger.info(
+              `Starting download of branch '${applicationConfig.branchName}'`,
+            );
 
-            const packageJsonBefore = await readPkgJson(cwd);
+            await syncService!.downloadDirectory();
+            span.end();
+          });
+        }
 
-            if (downloadFirst && !isSynced) {
-              await tracer.startActiveSpan("downloadFirst", async (span) => {
-                logger.info(
-                  `Starting download of branch '${applicationConfig.branchName}'`,
+        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();
+            },
+          );
+        }
 
-                await syncService!.downloadDirectory();
-                span.end();
-              });
-            }
-
-            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();
-                },
-              );
-            }
-
-            const packageJsonAfter = await readPkgJson(cwd);
+        const packageJsonAfter = await readPkgJson(cwd);
 
-            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 (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 || 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",
+          );
+        }
 
-            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 (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) {
-              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);
+        if (hasCliUpdated) {
           try {
+            logger.info("Releasing lock before restarting the dev server");
             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);
+            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);
         }
-      } else {
-        logger.info("Skipping directory sync");
+      });
+    } 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");
+  }
 
-      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}`);
-          });
-        }
-        // 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);
-        });
+  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;
+    },
+  );
 
-      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;
+  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}`));
 }
 async function getDraftOrLiveEditHash(
   sdk: SuperblocksSdk,