@superblocksteam/sdk 2.0.110-next.8 → 2.0.110

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

@@ -1,5 +1,3 @@
-import * as child_process from "node:child_process";
-import { existsSync } from "node:fs";
 import type http from "node:http";
 import net from "node:net";
 import os from "node:os";
@@ -114,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;
@@ -140,7 +131,6 @@ export async function createDevServer({
   port,
   sdk,
   superblocksBaseUrl: explicitBaseUrl,
-  existingServer,
 }: CreateDevServerOptions) {
   const logger = getLogger(loggerOverride);
   if (httpServer) {
@@ -177,12 +167,6 @@ export async function createDevServer({
     viteResolve = resolve;
     viteReject = reject;
   });
-  // Attach a no-op catch so that if viteReject() fires before any request
-  // handler awaits vitePromise (e.g. Vite fails during eager init, before
-  // /_sb_connect), the process doesn't crash with UnhandledPromiseRejection.
-  // The actual error is still logged via the .then(_, onRejected) handler
-  // attached at the viteStartPromise call site.
-  vitePromise.catch(() => {});
 
   async function gracefulShutdown({
     logger,
@@ -400,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) => {
@@ -444,7 +457,6 @@ export async function createDevServer({
             viteResolve = resolve;
             viteReject = reject;
           });
-          vitePromise.catch(() => {});
           isViteServerInitialized = false;
         }
         res.send("ok");
@@ -488,143 +500,8 @@ export async function createDevServer({
         timeSinceLastActivityMs: lockService.timeSinceLastActivity,
       });
     } else {
-      // Lock service may be undefined during warm pool activation (sync is
-      // deferred until the first /_sb_connect). Return a safe default instead
-      // of rejecting vitePromise which would crash the server.
-      // Use MAX_SAFE_INTEGER so idle-detection callers don't mistake this for recent activity.
-      res.json({
-        isUserActive: false,
-        connectedUsers: [],
-        timeSinceLastActivityMs: Number.MAX_SAFE_INTEGER,
-      });
-    }
-  });
-
-  // /_sb_persist: SABS POSTs a presigned S3 upload URL at teardown.
-  // This endpoint creates a tar+zstd archive of the workspace and uploads
-  // it directly to S3 via the presigned PUT URL. Registered on the Express
-  // app so it's available on ALL dev server instances (warm and cold-start, D-24).
-  let persistInProgress = false;
-  app.post("/_sb_persist", authHandler, async (req, res) => {
-    if (persistInProgress) {
-      res.status(409).json({ error: "persist already in progress" });
-      return;
-    }
-    persistInProgress = true;
-    const persistStart = Date.now();
-    try {
-      const { uploadURL } = req.body as { uploadURL: string };
-      if (!uploadURL) {
-        res.status(400).json({ error: "uploadURL required" });
-        return;
-      }
-
-      logger.info("/_sb_persist: archiving and uploading workspace to S3...");
-
-      // Create tar+zstd archive excluding .git/ and node_modules/.cache/
-      // then stream directly to S3 via presigned PUT URL.
-      const archive = await new Promise<Buffer>(
-        (resolveArchive, rejectArchive) => {
-          const tarProc = child_process.spawn(
-            "tar",
-            [
-              "cf",
-              "-",
-              "--exclude",
-              ".git",
-              "--exclude",
-              "node_modules/.cache",
-              "--exclude",
-              ".superblocks",
-              "-C",
-              process.cwd(),
-              ".",
-            ],
-            { stdio: ["ignore", "pipe", "pipe"] },
-          );
-          const zstdProc = child_process.spawn(
-            "zstd",
-            ["-1", "--no-progress"],
-            {
-              stdio: ["pipe", "pipe", "pipe"],
-            },
-          );
-
-          tarProc.stdout.pipe(zstdProc.stdin);
-
-          // Attach error handlers on the piped stdin. ChildProcess-level 'error'
-          // events don't catch stream errors like EPIPE from writing to a closed
-          // pipe if the downstream process crashes.
-          zstdProc.stdin.on("error", (err) => {
-            rejectArchive(new Error(`zstd stdin stream error: ${err.message}`));
-          });
-
-          const chunks: Buffer[] = [];
-          zstdProc.stdout.on("data", (chunk: Buffer) => chunks.push(chunk));
-
-          let stderr = "";
-          tarProc.stderr.on("data", (chunk: Buffer) => {
-            stderr += chunk.toString();
-          });
-          zstdProc.stderr.on("data", (chunk: Buffer) => {
-            stderr += chunk.toString();
-          });
-
-          let tarExitCode: number | null = null;
-          tarProc.on("close", (code) => {
-            tarExitCode = code;
-          });
-
-          zstdProc.on("close", (code) => {
-            if (code !== 0) {
-              rejectArchive(
-                new Error(`zstd compression failed (code ${code}): ${stderr}`),
-              );
-            } else if (tarExitCode !== null && tarExitCode !== 0) {
-              rejectArchive(
-                new Error(
-                  `tar archival failed (code ${tarExitCode}): ${stderr}`,
-                ),
-              );
-            } else {
-              resolveArchive(Buffer.concat(chunks));
-            }
-          });
-          tarProc.on("error", rejectArchive);
-          zstdProc.on("error", rejectArchive);
-        },
-      );
-
-      logger.info(
-        `/_sb_persist: archive created (${(archive.length / 1024 / 1024).toFixed(1)}MB) in ${Date.now() - persistStart}ms, uploading...`,
-      );
-
-      const uploadStart = Date.now();
-      const uploadResp = await fetch(uploadURL, {
-        method: "PUT",
-        body: archive,
-        headers: {
-          "Content-Type": "application/zstd",
-          "Content-Length": String(archive.length),
-        },
-        signal: AbortSignal.timeout(30_000),
-      });
-
-      if (!uploadResp.ok) {
-        throw new Error(
-          `S3 upload failed: ${uploadResp.status} ${uploadResp.statusText}`,
-        );
-      }
-
-      logger.info(
-        `/_sb_persist: uploaded in ${Date.now() - uploadStart}ms (total ${Date.now() - persistStart}ms)`,
-      );
-      res.status(200).json({ status: "uploaded" });
-    } catch (error) {
-      logger.error(`/_sb_persist failed: ${error}`);
-      res.status(500).json({ error: String(error) });
-    } finally {
-      persistInProgress = false;
+      logger.error("Lock service not found, rejecting request");
+      viteReject(new Error("Lock service not found, rejecting request"));
     }
   });
 
@@ -656,72 +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((err: unknown) => {
-        logger.warn(`Failed to fetch feature flags, using defaults: ${err}`);
-        return undefined;
-      });
-
-    const viteStartPromise = 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,
-      },
-    });
-    // Note: vitePromise itself gets a no-op .catch() at its construction site
-    // (see lines ~179 / ~443) to prevent UnhandledPromiseRejection if Vite
-    // fails before any request awaits vitePromise. The actual error is logged
-    // below via the rejection branch of .then().
-    viteStartPromise.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;
 }
 
@@ -930,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";