@superblocksteam/sdk 2.0.109 → 2.0.110-next.1

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

@@ -1,3 +1,5 @@
+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";
@@ -112,6 +114,13 @@ 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;
@@ -131,6 +140,7 @@ export async function createDevServer({
   port,
   sdk,
   superblocksBaseUrl: explicitBaseUrl,
+  existingServer,
 }: CreateDevServerOptions) {
   const logger = getLogger(loggerOverride);
   if (httpServer) {
@@ -167,6 +177,12 @@ 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,
@@ -384,50 +400,21 @@ export async function createDevServer({
       }
     }
 
-    logger.info("Initializing dev server...");
-    if (isViteServerInitialized) {
-      logger.info("Dev server already initialized");
+    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;
       res.send(JSON.stringify(healthResponse));
-      return;
+    } 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" }));
     }
-    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) => {
@@ -457,6 +444,7 @@ export async function createDevServer({
             viteResolve = resolve;
             viteReject = reject;
           });
+          vitePromise.catch(() => {});
           isViteServerInitialized = false;
         }
         res.send("ok");
@@ -500,8 +488,143 @@ export async function createDevServer({
         timeSinceLastActivityMs: lockService.timeSinceLastActivity,
       });
     } else {
-      logger.error("Lock service not found, rejecting request");
-      viteReject(new Error("Lock service not found, rejecting request"));
+      // 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;
     }
   });
 
@@ -533,9 +656,72 @@ export async function createDevServer({
     );
   });
 
-  logger.info(`Starting HTTP server on port ${port}`);
-  httpServer = await app.listen(port);
-  logger.info(`HTTP server started successfully on port ${port}`);
+  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);
+      },
+    );
+  }
+
   return httpServer;
 }
 
@@ -744,6 +930,54 @@ 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 } from "./dev-utils/dev-server.mjs";
+export { createDevServer, preWarmViteCache } from "./dev-utils/dev-server.mjs";
 
 export { TokenManager } from "./dev-utils/token-manager.js";