@superblocksteam/cli 2.0.110-next.14 → 2.0.110-next.15

package/dist/index.js

@@ -1,7 +1,7 @@
 if (typeof process === 'object' && process !== null &&
     process.env !== null && typeof process.env === 'object') {
   process.env.DD_GIT_REPOSITORY_URL = 'https://token@github.com/superblocksteam/superblocks.git';
-  process.env.DD_GIT_COMMIT_SHA = 'd6e752a2cecf8e93bafaf04dda2d5214949ae79a';
+  process.env.DD_GIT_COMMIT_SHA = '17d24669ad0b2ea8b205ca9196a4c77939b28866';
 }
 import { createRequire as $dd_createRequire } from 'module';
 import { fileURLToPath as $dd_fileURLToPath } from 'url';
@@ -15,7 +15,7 @@ import {
   configPathForClient,
   labelForClient,
   mergeMcpConfig
-} from "./chunk-VUXGBCHS.js";
+} from "./chunk-HFKWO5WW.js";
 import {
   AUTO_UPGRADE_EXIT_CODE,
   AuthHotReloadServer,
@@ -62,6 +62,7 @@ import {
   isSocketAlive,
   magenta,
   modeFlagValuesMap,
+  preWarmViteCache,
   readApiFromDisk,
   readApplicationFromDisk,
   readMultiPageApplicationFromDisk,
@@ -78,28 +79,28 @@ import {
   writeApplicationToDisk,
   writeResourceToDisk,
   yellow
-} from "./chunk-6L5GMSF2.js";
-import "./chunk-QQTIZ3JW.js";
+} from "./chunk-PUJRK3HU.js";
+import "./chunk-O3ZP25TF.js";
 import {
   require_enquirer
-} from "./chunk-SOVZ4MKE.js";
+} from "./chunk-LZVIP2I7.js";
 import {
   init_lodash,
   isEmpty_default,
   require_lib
-} from "./chunk-7XGJ2DPJ.js";
+} from "./chunk-2A3K3NFD.js";
 import {
   require_rfdc
-} from "./chunk-X2O46BBJ.js";
-import "./chunk-H427LM2L.js";
-import "./chunk-Y5UCK4QB.js";
-import "./chunk-4N2GPPW5.js";
-import "./chunk-FAJ3NJRT.js";
+} from "./chunk-D23FTYGA.js";
+import "./chunk-C3LE2B2C.js";
+import "./chunk-AK4KVVMQ.js";
+import "./chunk-ZM5JKT44.js";
+import "./chunk-MJADJD5I.js";
 import {
   __commonJS,
   __toESM,
   init_cjs_shims
-} from "./chunk-E33HPBUC.js";
+} from "./chunk-4ICSOTLX.js";
 
 // ../../../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.js
 var require_eventemitter3 = __commonJS({
@@ -1011,7 +1012,7 @@ async function createPrompt(options, settings) {
     enquirer3 = settings.enquirer;
   } else {
     try {
-      enquirer3 = await import("./enquirer-QSA4Q3KI.js").then((imported) => imported.default ? new imported.default() : new imported());
+      enquirer3 = await import("./enquirer-UFVUWHG7.js").then((imported) => imported.default ? new imported.default() : new imported());
     } catch (e) {
       if (this instanceof TaskWrapper) {
         this.task.prompt = new PromptError("Enquirer is a peer dependency that must be installed separately.");
@@ -1219,9 +1220,9 @@ var _DefaultRenderer = class {
     return typeof bottomBar === "number" && bottomBar !== 0 || typeof bottomBar === "boolean" && bottomBar !== false || !task.hasTitle();
   }
   async render() {
-    const { createLogUpdate } = await import("./log-update-53HBE7QZ.js");
-    const { default: truncate } = await import("./cli-truncate-R7BZHTWM.js");
-    const { default: wrap } = await import("./wrap-ansi-7RMGVNIF.js");
+    const { createLogUpdate } = await import("./log-update-7HNOGI6A.js");
+    const { default: truncate } = await import("./cli-truncate-OPCPEVAK.js");
+    const { default: wrap } = await import("./wrap-ansi-OULD3OUB.js");
     this.updater = createLogUpdate(this.logger.process.stdout);
     this.truncate = truncate;
     this.wrap = wrap;
@@ -4786,7 +4787,9 @@ var Deploy = class _Deploy extends AuthenticatedCommand {
 // src/commands/dev.mts
 init_cjs_shims();
 import * as child_process from "node:child_process";
-import { resolve } from "node:path";
+import * as fs6 from "node:fs";
+import * as http from "node:http";
+import { basename, dirname, join as join3, resolve } from "node:path";
 import { Flags as Flags6, ux as ux4 } from "@oclif/core";
 var import_util13 = __toESM(require_dist2(), 1);
 var Dev = class _Dev extends AuthenticatedCommand {
@@ -4795,6 +4798,12 @@ var Dev = class _Dev extends AuthenticatedCommand {
   flags;
   applicationConfig;
   superblocksBaseUrl;
+  warmServer;
+  // When true, the CLI was started in warm pool standby mode and subsequently
+  // activated by SABS. Used to route auto-upgrade to SKIP_CLI_ONLY — the warm
+  // pod already ships with the latest CLI, but the user's package.json still
+  // needs to be synced to the target @superblocksteam/library version.
+  warmStandbyActivated = false;
   authHotReloadServer;
   getAuthTokenTimeoutMs() {
     return 5 * 60 * 1e3;
@@ -4809,6 +4818,9 @@ var Dev = class _Dev extends AuthenticatedCommand {
   async init() {
     const { flags } = await this.parse(_Dev);
     this.flags = flags;
+    if (this.flags.warm) {
+      return;
+    }
     let token;
     let superblocksBaseUrl;
     const branch = await getCurrentBranchInfo();
@@ -4979,7 +4991,7 @@ var Dev = class _Dev extends AuthenticatedCommand {
     if (!this.flags) {
       throw new Error("Flags are not initialized");
     }
-    const autoUpgradeMode = this.flags["skip-auto-upgrade"] ? DevServerAutoUpgradeMode.SKIP : this.flags["force-auto-upgrade"] ? DevServerAutoUpgradeMode.FORCE : void 0;
+    const autoUpgradeMode = this.warmStandbyActivated ? DevServerAutoUpgradeMode.SKIP_CLI_ONLY : this.flags["skip-auto-upgrade"] ? DevServerAutoUpgradeMode.SKIP : this.flags["force-auto-upgrade"] ? DevServerAutoUpgradeMode.FORCE : void 0;
     await this.startDevServer({
       applicationConfig: this.applicationConfig,
       tokenConfig: {
@@ -4994,7 +5006,9 @@ var Dev = class _Dev extends AuthenticatedCommand {
       superblocksPath: resolve(process.argv[1]),
       autoUpgradeMode,
       sdk,
-      prefetchedApplication
+      prefetchedApplication,
+      skipSync: false
+      // DBFS runs alongside S3 during migration (D-25)
     });
   }
   async onTokenReceived(token) {
@@ -5025,6 +5039,12 @@ var Dev = class _Dev extends AuthenticatedCommand {
       description: "The port that the dev server will run on",
       hidden: true
     }),
+    warm: Flags6.boolean({
+      name: "warm",
+      description: "Start in warm standby mode: pre-loads the server process without auth, then activates on /_sb_activate POST",
+      default: false,
+      hidden: true
+    }),
     "upload-first": Flags6.boolean({
       name: "upload-first",
       description: "Upload to Superblocks before starting",
@@ -5073,6 +5093,10 @@ var Dev = class _Dev extends AuthenticatedCommand {
       if (!this.flags) {
         throw new Error("Flags are not initialized");
       }
+      if (this.flags.warm) {
+        await this.runWarmStandby();
+        return;
+      }
       if (!this.flags["upload-first"] && !this.flags["download-first"]) {
         throw new Error(
           "This command requires either the --upload-first or --download-first flag"
@@ -5158,9 +5182,257 @@ var Dev = class _Dev extends AuthenticatedCommand {
       tokenManager: this.tokenManager,
       getCurrentToken: () => this.getCurrentToken(),
       authHotReloadServer: this.authHotReloadServer,
-      autoUpgradeMode: options.autoUpgradeMode
+      autoUpgradeMode: options.autoUpgradeMode,
+      existingServer: this.warmServer
     });
   }
+  /**
+   * Warm standby mode: starts a minimal HTTP server that responds to health
+   * checks while the Node.js runtime is fully loaded in memory. When SABS
+   * activates the pod via POST /_sb_activate with session credentials, this
+   * method writes the config files, closes the standby server, and hands off
+   * to the normal `executeWithToken` flow.
+   *
+   * This eliminates the ~1.9s CLI cold-start from the claim-time critical path.
+   */
+  async runWarmStandby() {
+    const port = this.flags?.port ?? 5173;
+    const logger = this.logger();
+    logger.info(`Starting warm standby server on port ${port}`);
+    const activationConfig = await new Promise((resolveActivation, rejectActivation) => {
+      const server = http.createServer((req, res) => {
+        res.setHeader("Cache-Control", "no-store, max-age=0");
+        res.setHeader("x-csb-no-sw-proxy", "1");
+        if (req.url === "/_sb_health" && req.method === "GET") {
+          res.writeHead(503, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ status: "warming" }));
+          return;
+        }
+        if (req.url === "/_sb_activate" && req.method === "POST") {
+          const MAX_BODY = 64 * 1024;
+          let body = "";
+          let destroyed = false;
+          req.on("data", (chunk) => {
+            if (destroyed) return;
+            body += chunk.toString();
+            if (body.length > MAX_BODY) {
+              destroyed = true;
+              res.writeHead(413, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: "Request body too large" }));
+              req.destroy();
+            }
+          });
+          req.on("end", () => {
+            if (destroyed) return;
+            try {
+              const config = JSON.parse(body);
+              const missing = ["token", "baseUrl", "applicationId", "branch"].filter((k) => typeof config[k] !== "string" || !config[k]);
+              if (missing.length) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(
+                  JSON.stringify({
+                    error: `Missing required fields: ${missing.join(", ")}`
+                  })
+                );
+                return;
+              }
+              res.writeHead(200, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ status: "activating" }));
+              logger.info(
+                "Activation received, transitioning to full dev server"
+              );
+              this.warmServer = server;
+              resolveActivation(config);
+            } catch {
+              res.writeHead(400, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: "invalid JSON body" }));
+            }
+          });
+          return;
+        }
+        res.writeHead(503);
+        res.end();
+      });
+      server.on("error", (err) => {
+        logger.error(`Warm standby server failed to start: ${err.message}`);
+        rejectActivation(err);
+      });
+      server.listen(port, () => {
+        logger.info(`Warm standby ready on port ${port}`);
+        preWarmViteCache(process.cwd()).catch((err) => {
+          logger.warn(`preWarmViteCache background task rejected: ${err}`);
+        });
+      });
+    });
+    process.env.SUPERBLOCKS_TOKEN = activationConfig.token;
+    process.env.SUPERBLOCKS_BASE_URL = activationConfig.baseUrl;
+    process.env.APPLICATION_ID = activationConfig.applicationId;
+    process.env.BRANCH = activationConfig.branch;
+    if (activationConfig.hostname) {
+      process.env.SABS_LIVE_EDIT_HOSTNAME = activationConfig.hostname;
+    }
+    if (activationConfig.templateName) {
+      process.env.SUPERBLOCKS_APP_TEMPLATE_NAME = activationConfig.templateName;
+      const currentDir = basename(process.cwd());
+      if (currentDir !== activationConfig.templateName) {
+        const targetDir = join3(
+          process.cwd(),
+          "..",
+          activationConfig.templateName
+        );
+        if (fs6.existsSync(targetDir)) {
+          logger.info(
+            `Switching template directory: ${currentDir} -> ${activationConfig.templateName}`
+          );
+          process.chdir(targetDir);
+        } else {
+          logger.warn(
+            `Template directory not found: ${targetDir}, staying in ${currentDir}`
+          );
+        }
+      }
+    }
+    const authFilePath = (0, import_util13.resolveAuthFilePath)();
+    fs6.mkdirSync(dirname(authFilePath), { recursive: true });
+    fs6.writeFileSync(
+      authFilePath,
+      JSON.stringify({
+        superblocksBaseUrl: activationConfig.baseUrl,
+        token: activationConfig.token
+      })
+    );
+    const appConfigPath = join3(
+      process.cwd(),
+      ".superblocks",
+      "superblocks.json"
+    );
+    fs6.mkdirSync(dirname(appConfigPath), { recursive: true });
+    fs6.writeFileSync(
+      appConfigPath,
+      JSON.stringify({
+        configType: "APPLICATION_V2",
+        id: activationConfig.applicationId
+      })
+    );
+    const devEnvPath = join3(
+      process.cwd(),
+      "..",
+      "..",
+      ".superblocks",
+      "dev-environment.json"
+    );
+    fs6.mkdirSync(dirname(devEnvPath), { recursive: true });
+    fs6.writeFileSync(
+      devEnvPath,
+      JSON.stringify({
+        configType: "DEV_ENVIRONMENT",
+        branch: activationConfig.branch
+      })
+    );
+    if (activationConfig.downloadURL) {
+      try {
+        logger.info("Downloading workspace archive...");
+        const downloadStart = Date.now();
+        const downloadResp = await fetch(activationConfig.downloadURL, {
+          signal: AbortSignal.timeout(3e4)
+        });
+        if (!downloadResp.ok || !downloadResp.body) {
+          throw new Error(
+            `Workspace download failed: ${downloadResp.status} ${downloadResp.statusText}`
+          );
+        }
+        logger.info(
+          `Workspace download completed in ${Date.now() - downloadStart}ms, extracting...`
+        );
+        const extractStart = Date.now();
+        await new Promise((resolveExtract, rejectExtract) => {
+          const zstdProc = child_process.spawn("zstd", ["-d"], {
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+          const tarProc = child_process.spawn(
+            "tar",
+            ["xf", "-", "-C", process.cwd()],
+            {
+              stdio: ["pipe", "inherit", "pipe"]
+            }
+          );
+          zstdProc.stdout.pipe(tarProc.stdin);
+          zstdProc.stdin.on("error", (err) => {
+            rejectExtract(new Error(`zstd stdin stream error: ${err.message}`));
+          });
+          tarProc.stdin.on("error", (err) => {
+            rejectExtract(new Error(`tar stdin stream error: ${err.message}`));
+          });
+          const reader = downloadResp.body.getReader();
+          const pump = async () => {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) {
+                zstdProc.stdin.end();
+                break;
+              }
+              if (!zstdProc.stdin.write(value)) {
+                await new Promise((r) => zstdProc.stdin.once("drain", r));
+              }
+            }
+          };
+          pump().catch((e) => {
+            zstdProc.kill();
+            tarProc.kill();
+            rejectExtract(e);
+          });
+          let stderr = "";
+          zstdProc.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+          });
+          tarProc.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+          });
+          let zstdExitCode = null;
+          zstdProc.on("close", (code) => {
+            zstdExitCode = code;
+          });
+          tarProc.on("close", (code) => {
+            if (zstdExitCode !== null && zstdExitCode !== 0) {
+              rejectExtract(
+                new Error(
+                  `zstd decompression failed (code ${zstdExitCode}): ${stderr}`
+                )
+              );
+            } else if (code === 0) {
+              resolveExtract();
+            } else {
+              rejectExtract(
+                new Error(`tar extract failed (code ${code}): ${stderr}`)
+              );
+            }
+          });
+          tarProc.on("error", rejectExtract);
+          zstdProc.on("error", rejectExtract);
+        });
+        logger.info(
+          `Workspace extracted in ${Date.now() - extractStart}ms (total ${Date.now() - downloadStart}ms)`
+        );
+      } catch (error) {
+        logger.warn(
+          `Workspace download/extract failed, DBFS will fill the gap: ${error}`
+        );
+      }
+    }
+    this.currentToken = activationConfig.token;
+    this.superblocksBaseUrl = activationConfig.baseUrl;
+    this.applicationConfig = {
+      id: activationConfig.applicationId,
+      branchName: activationConfig.branch
+    };
+    this.warmStandbyActivated = true;
+    this.flags = {
+      ...this.flags,
+      "download-first": true
+    };
+    await this.initializeTelemetry(activationConfig.token);
+    await this.executeWithToken(activationConfig.token);
+  }
   async spawnAndWaitForChild(previousRunResult, flags) {
     let _resolve;
     const promise = new Promise((resolve2) => {
@@ -5978,12 +6250,12 @@ var McpServe = class _McpServe extends Command9 {
           "HTTP transport requires auth token. Pass --http-token <token> or set SUPERBLOCKS_MCP_HTTP_TOKEN."
         );
       }
-      const { startHttpServer } = await import("./http-TOEXWWMX.js");
+      const { startHttpServer } = await import("./http-IOIOPQJJ.js");
       await startHttpServer({ port: flags.port, authToken: httpToken });
       await new Promise(() => {
       });
     } else {
-      const { startServer } = await import("./dist-LAIEBQ3V.js");
+      const { startServer } = await import("./dist-PUVCR3ZI.js");
       await startServer();
       await new Promise((resolve2) => {
         process.stdin.once("end", () => resolve2());
@@ -7466,7 +7738,7 @@ function getResourceIdFromLocation(ctx, resourceLocation) {
 // src/commands/sync.mts
 init_cjs_shims();
 import { execFile } from "node:child_process";
-import * as fs11 from "node:fs/promises";
+import * as fs12 from "node:fs/promises";
 import * as os from "node:os";
 import path17 from "node:path";
 import { promisify as promisify2 } from "node:util";
@@ -7560,7 +7832,7 @@ var Sync = class _Sync extends Command11 {
     appRelativePath,
     requestedSha
   }) {
-    const worktreeBase = await fs11.mkdtemp(
+    const worktreeBase = await fs12.mkdtemp(
       path17.join(os.tmpdir(), "superblocks-sync-main-")
     );
     const worktreePath = path17.join(worktreeBase, "worktree");
@@ -7620,7 +7892,7 @@ var Sync = class _Sync extends Command11 {
         );
       } catch {
       }
-      await fs11.rm(worktreeBase, { recursive: true, force: true });
+      await fs12.rm(worktreeBase, { recursive: true, force: true });
     }
   }
   async resolveRepoRoot(localDirectoryPath) {
@@ -7657,7 +7929,7 @@ var Sync = class _Sync extends Command11 {
       return snapshotAppPath;
     }
     const uploadPath = path17.join(worktreeBase, "upload");
-    await fs11.cp(snapshotAppPath, uploadPath, {
+    await fs12.cp(snapshotAppPath, uploadPath, {
       recursive: true,
       force: true,
       filter: (sourcePath) => path17.basename(sourcePath) !== ".git"