@superblocksteam/sdk 2.0.106-next.6 → 2.0.106

package/src/dev-utils/dev-server.mts

@@ -1,4 +1,3 @@
-import { existsSync } from "node:fs";
 import type http from "node:http";
 import net from "node:net";
 import os from "node:os";
@@ -113,13 +112,6 @@ interface CreateDevServerOptions {
   sdk?: SuperblocksSdk;
   /** Explicitly provided base URL from the CLI; preferred over auth-file reads. */
   superblocksBaseUrl?: string;
-  /**
-   * Pre-existing HTTP server from warm standby mode. When provided, the dev
-   * server attaches its Express app as a request handler on this server instead
-   * of creating a new one and calling listen(). This avoids the port gap that
-   * causes 502s from the gateway during the warm → full server transition.
-   */
-  existingServer?: http.Server;
 }
 
 let httpServer: http.Server;
@@ -139,7 +131,6 @@ export async function createDevServer({
   port,
   sdk,
   superblocksBaseUrl: explicitBaseUrl,
-  existingServer,
 }: CreateDevServerOptions) {
   const logger = getLogger(loggerOverride);
   if (httpServer) {
@@ -393,21 +384,50 @@ export async function createDevServer({
       }
     }
 
-    logger.info("Received connect request, waiting for vite server...");
-    // Vite is started eagerly after HTTP server listen (see below).
-    // Wait for it to be ready before responding.
-    try {
-      await vitePromise;
+    logger.info("Initializing dev server...");
+    if (isViteServerInitialized) {
+      logger.info("Dev server already initialized");
       res.send(JSON.stringify(healthResponse));
-    } catch (e) {
-      logger.error(
-        "Vite server failed to initialize",
-        getErrorMeta(e as Error),
-      );
-      res
-        .status(500)
-        .send(JSON.stringify({ error: "Dev server failed to initialize" }));
+      return;
     }
+    logger.info("Starting dev server");
+    isViteServerInitialized = true;
+
+    const featureFlags = await sdk?.getFeatureFlagsForCurrentUser();
+
+    // TODO(code-mode): should this include any validation checks, such as getting a token?
+
+    startVite({
+      port,
+      app,
+      root,
+      mode,
+      fsOperationQueue,
+      syncService,
+      lockService,
+      aiService,
+      gitService,
+      activateGitService,
+      snapshotManager,
+      checkAuthorization,
+      logger: loggerOverride,
+      httpServer,
+      superblocksBaseUrl: explicitBaseUrl || localToken?.superblocksBaseUrl,
+      features: {
+        enableSessionRecording: featureFlags?.enableSessionRecording() ?? false,
+      },
+    }).then(
+      (result) => {
+        logger.info("Dev server initialized");
+        viteResolve();
+        viteCreationResults = result;
+        res.send(JSON.stringify(healthResponse));
+      },
+      (e) => {
+        logger.error("Error initializing dev server", getErrorMeta(e));
+        viteReject(e);
+      },
+    );
   });
 
   app.post("/_sb_disconnect", authHandler, async (req, res) => {
@@ -480,13 +500,8 @@ export async function createDevServer({
         timeSinceLastActivityMs: lockService.timeSinceLastActivity,
       });
     } else {
-      // Lock service may be undefined when skipSync=true (warm pool activation).
-      // Return a safe default instead of rejecting vitePromise which would crash the server.
-      res.send({
-        isUserActive: false,
-        connectedUsers: [],
-        timeSinceLastActivityMs: 0,
-      });
+      logger.error("Lock service not found, rejecting request");
+      viteReject(new Error("Lock service not found, rejecting request"));
     }
   });
 
@@ -518,64 +533,9 @@ export async function createDevServer({
     );
   });
 
-  if (existingServer) {
-    // Warm standby mode: reuse the pre-existing HTTP server to avoid a port gap.
-    // Replace the warm server's request handler with the full Express app.
-    existingServer.removeAllListeners("request");
-    existingServer.on("request", app);
-    httpServer = existingServer;
-    logger.info(
-      `Attached full dev server to existing HTTP server on port ${port}`,
-    );
-  } else {
-    logger.info(`Starting HTTP server on port ${port}`);
-    httpServer = await app.listen(port);
-    logger.info(`HTTP server started successfully on port ${port}`);
-  }
-
-  // Start vite eagerly so it's ready (or nearly ready) by the time the editor
-  // connects via /_sb_connect. Previously vite was started lazily on first
-  // /_sb_connect, adding ~5s to perceived connection time.
-  if (!isViteServerInitialized) {
-    isViteServerInitialized = true;
-    logger.info("Eagerly starting vite server...");
-
-    const featureFlags = await sdk
-      ?.getFeatureFlagsForCurrentUser()
-      .catch(() => undefined);
-
-    startVite({
-      port,
-      app,
-      root,
-      mode,
-      fsOperationQueue,
-      syncService,
-      lockService,
-      aiService,
-      gitService,
-      activateGitService,
-      snapshotManager,
-      checkAuthorization,
-      logger: loggerOverride,
-      httpServer,
-      superblocksBaseUrl: explicitBaseUrl || localToken?.superblocksBaseUrl,
-      features: {
-        enableSessionRecording: featureFlags?.enableSessionRecording() ?? false,
-      },
-    }).then(
-      (result) => {
-        logger.info("Vite server initialized eagerly");
-        viteResolve();
-        viteCreationResults = result;
-      },
-      (e) => {
-        logger.error("Error initializing vite server", getErrorMeta(e));
-        viteReject(e);
-      },
-    );
-  }
-
+  logger.info(`Starting HTTP server on port ${port}`);
+  httpServer = await app.listen(port);
+  logger.info(`HTTP server started successfully on port ${port}`);
   return httpServer;
 }
 
@@ -784,54 +744,6 @@ async function startVite({
   });
 }
 
-/**
- * Pre-warm the Vite dependency cache by creating and immediately closing a
- * minimal Vite server. This populates `node_modules/.vite/deps` with
- * pre-bundled dependencies so that `createDevServer` starts ~1-2s faster.
- *
- * Call this during warm standby phase while waiting for activation.
- * Non-fatal — if it fails the activation-time Vite start still works,
- * just without the cache benefit.
- */
-export async function preWarmViteCache(root: string): Promise<void> {
-  const start = Date.now();
-  console.log("[warm] Pre-warming Vite dependency cache...");
-  try {
-    // Create a Vite server with optimizeDeps.noDiscovery so it only processes
-    // the deps listed in optimizeDeps.include (from vite.config) without
-    // scanning source files. This is faster and avoids hanging on HMR setup.
-    const server = await createServer({
-      root,
-      mode: "development",
-      server: { middlewareMode: true, hmr: false },
-      plugins: [tsconfigPaths()],
-      logLevel: "warn",
-      optimizeDeps: { noDiscovery: true },
-    });
-    // Poll for the dep cache directory instead of sleeping a fixed 500ms.
-    // Vite renames a temp dir to node_modules/.vite/deps once optimization
-    // completes; polling avoids both under-waiting (cache not committed) and
-    // over-waiting (wasted time on fast disks).
-    const depsDir = path.join(root, "node_modules", ".vite", "deps");
-    const maxWaitMs = 5_000;
-    const pollMs = 50;
-    const deadline = Date.now() + maxWaitMs;
-    while (!existsSync(depsDir) && Date.now() < deadline) {
-      await new Promise((r) => setTimeout(r, pollMs));
-    }
-    await server.close();
-    const cached = existsSync(depsDir);
-    console.log(
-      `[warm] Vite cache ${cached ? "warmed" : "not committed (timed out)"} in ${Date.now() - start}ms`,
-    );
-  } catch (error) {
-    console.warn(
-      `[warm] Vite cache pre-warm failed (non-fatal, ${Date.now() - start}ms):`,
-      error,
-    );
-  }
-}
-
 const DEFAULT_HMR_PORT = 24678;
 
 function getFreePort() {

package/src/index.ts

@@ -64,7 +64,7 @@ export {
 export { AUTO_UPGRADE_EXIT_CODE } from "./cli-replacement/automatic-upgrades.js";
 export { RESTART_EXIT_CODE } from "./dev-utils/dev-server.mjs";
 
-export { createDevServer, preWarmViteCache } from "./dev-utils/dev-server.mjs";
+export { createDevServer } from "./dev-utils/dev-server.mjs";
 
 export { TokenManager } from "./dev-utils/token-manager.js";