@superblocksteam/sdk 2.0.115-next.0 → 2.0.115-next.2

package/src/cli-replacement/package-json-snapshot.test.mts

@@ -0,0 +1,250 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { describe, expect, it } from "vitest";
+
+import {
+  didPackageJsonSnapshotChange,
+  packageJsonSnapshot,
+  readPackageJsonSnapshotWithSource,
+  restoreManagedPackageDependencies,
+} from "./package-json-snapshot.mjs";
+
+describe("packageJsonSnapshot", () => {
+  it("is stable for object key order changes", () => {
+    const before = packageJsonSnapshot({
+      dependencies: {
+        "@superblocksteam/library": "2.0.0",
+        react: "19.0.0",
+      },
+      scripts: {
+        dev: "vite",
+        build: "vite build",
+      },
+    });
+
+    const after = packageJsonSnapshot({
+      scripts: {
+        build: "vite build",
+        dev: "vite",
+      },
+      dependencies: {
+        react: "19.0.0",
+        "@superblocksteam/library": "2.0.0",
+      },
+    });
+
+    expect(didPackageJsonSnapshotChange(before, after)).toBe(false);
+    expect(before.diagnostic.sha256).toBe(after.diagnostic.sha256);
+  });
+
+  it("detects dependency version changes", () => {
+    const before = packageJsonSnapshot({
+      dependencies: {
+        "@superblocksteam/library": "1.0.0",
+      },
+    });
+    const after = packageJsonSnapshot({
+      dependencies: {
+        "@superblocksteam/library": "2.0.0",
+      },
+    });
+
+    expect(didPackageJsonSnapshotChange(before, after)).toBe(true);
+  });
+
+  it("ignores non-dependency package metadata", () => {
+    const before = packageJsonSnapshot({
+      name: "warm-template",
+      version: "1.0.0",
+      scripts: {
+        dev: "vite",
+      },
+      dependencies: {
+        react: "19.0.0",
+      },
+    });
+    const after = packageJsonSnapshot({
+      name: "restored-app",
+      version: "2.0.0",
+      scripts: {
+        dev: "vite --host 0.0.0.0",
+      },
+      dependencies: {
+        react: "19.0.0",
+      },
+    });
+
+    expect(didPackageJsonSnapshotChange(before, after)).toBe(false);
+  });
+
+  it("detects install-relevant package metadata changes", () => {
+    const basePackageJson = {
+      dependencies: {
+        react: "19.0.0",
+      },
+      overrides: {
+        lodash: "4.17.20",
+      },
+      pnpm: {
+        overrides: {
+          axios: "1.12.0",
+        },
+      },
+    };
+
+    const before = packageJsonSnapshot(basePackageJson);
+    const after = packageJsonSnapshot({
+      ...basePackageJson,
+      overrides: {
+        lodash: "4.17.21",
+      },
+    });
+
+    expect(didPackageJsonSnapshotChange(before, after)).toBe(true);
+  });
+
+  it("detects package-manager-specific install metadata changes", () => {
+    const before = packageJsonSnapshot({
+      dependencies: {
+        react: "19.0.0",
+      },
+      pnpm: {
+        overrides: {
+          axios: "1.12.0",
+        },
+      },
+    });
+
+    const after = packageJsonSnapshot({
+      dependencies: {
+        react: "19.0.0",
+      },
+      pnpm: {
+        overrides: {
+          axios: "1.13.2",
+        },
+      },
+    });
+
+    expect(didPackageJsonSnapshotChange(before, after)).toBe(true);
+  });
+
+  it("detects devEngines package manager changes", () => {
+    const before = packageJsonSnapshot({
+      dependencies: {
+        react: "19.0.0",
+      },
+      devEngines: {
+        packageManager: {
+          name: "npm",
+          version: "10.0.0",
+        },
+      },
+    });
+
+    const after = packageJsonSnapshot({
+      dependencies: {
+        react: "19.0.0",
+      },
+      devEngines: {
+        packageManager: {
+          name: "pnpm",
+          version: "10.0.0",
+        },
+      },
+    });
+
+    expect(didPackageJsonSnapshotChange(before, after)).toBe(true);
+  });
+
+  it("omits undefined object values when serializing snapshots", () => {
+    const before = packageJsonSnapshot({
+      dependencies: {
+        react: "19.0.0",
+        removed: undefined,
+      },
+      pnpm: {
+        onlyBuiltDependencies: ["esbuild", undefined],
+        overrides: undefined,
+      },
+    });
+    const after = packageJsonSnapshot({
+      dependencies: {
+        react: "19.0.0",
+      },
+      pnpm: {
+        onlyBuiltDependencies: ["esbuild", null],
+      },
+    });
+
+    expect(before.value).not.toContain("undefined");
+    expect(didPackageJsonSnapshotChange(before, after)).toBe(false);
+  });
+
+  it("matches read-pkg bundle dependency alias normalization", async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "pkg-json-"));
+
+    try {
+      await fs.writeFile(
+        path.join(tmpDir, "package.json"),
+        JSON.stringify({
+          name: "test-app",
+          version: "1.0.0",
+          dependencies: {
+            react: "19.0.0",
+          },
+          bundledDependencies: ["react"],
+        }),
+      );
+
+      const before = await readPackageJsonSnapshotWithSource(tmpDir);
+      const { readPackage } = await import("read-pkg");
+      const after = packageJsonSnapshot(await readPackage({ cwd: tmpDir }));
+
+      expect(didPackageJsonSnapshotChange(before.snapshot, after)).toBe(false);
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("restoreManagedPackageDependencies", () => {
+  it("preserves the restored package.json indentation when rewriting managed packages", async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "pkg-json-"));
+
+    try {
+      await fs.writeFile(
+        path.join(tmpDir, "package.json"),
+        JSON.stringify(
+          {
+            name: "restored-app",
+            dependencies: {
+              "@superblocksteam/library": "1.0.0",
+              react: "19.0.0",
+            },
+          },
+          null,
+          4,
+        ) + "\n",
+      );
+
+      await restoreManagedPackageDependencies(tmpDir, {
+        dependencies: {
+          "@superblocksteam/library": "2.0.0",
+        },
+      });
+
+      const restored = await fs.readFile(
+        path.join(tmpDir, "package.json"),
+        "utf-8",
+      );
+      expect(restored).toContain('\n    "dependencies"');
+      expect(restored).toContain('\n        "@superblocksteam/library"');
+      expect(restored.endsWith("\n")).toBe(true);
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  });
+});

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

@@ -0,0 +1,96 @@
+import type * as NodeChildProcess from "node:child_process";
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+
+import { describe, expect, it, vi } from "vitest";
+
+const { spawnMock } = vi.hoisted(() => ({
+  spawnMock: vi.fn(),
+}));
+
+vi.mock("node:child_process", async () => {
+  const actual =
+    await vi.importActual<typeof NodeChildProcess>("node:child_process");
+
+  return {
+    ...actual,
+    default: {
+      ...actual,
+      spawn: spawnMock,
+    },
+    spawn: spawnMock,
+  };
+});
+
+function createMockProcess() {
+  return Object.assign(new EventEmitter(), {
+    stdin: new PassThrough(),
+    stdout: new PassThrough(),
+    stderr: new PassThrough(),
+  });
+}
+
+describe("createWorkspacePersistArchive", () => {
+  it("excludes node_modules from the tar archive", async () => {
+    const tarProc = createMockProcess();
+    const zstdProc = createMockProcess();
+    spawnMock.mockImplementation((command: string) => {
+      if (command === "tar") {
+        queueMicrotask(() => tarProc.emit("close", 0));
+        return tarProc;
+      }
+
+      queueMicrotask(() => {
+        zstdProc.stdout.emit("data", Buffer.from("archive"));
+        zstdProc.emit("close", 0);
+      });
+      return zstdProc;
+    });
+
+    const { createWorkspacePersistArchive } = await import("./dev-server.mjs");
+
+    await expect(createWorkspacePersistArchive("/workspace")).resolves.toEqual(
+      Buffer.from("archive"),
+    );
+
+    const tarCall = spawnMock.mock.calls.find(([command]) => command === "tar");
+    expect(tarCall).toBeDefined();
+    expect(tarCall?.[1]).toEqual([
+      "cf",
+      "-",
+      "--exclude",
+      ".git",
+      "--exclude",
+      "node_modules",
+      "--exclude",
+      ".superblocks",
+      "-C",
+      "/workspace",
+      ".",
+    ]);
+  });
+
+  it("rejects if tar fails after zstd closes successfully", async () => {
+    const tarProc = createMockProcess();
+    const zstdProc = createMockProcess();
+    spawnMock.mockImplementation((command: string) => {
+      if (command === "tar") {
+        return tarProc;
+      }
+
+      queueMicrotask(() => {
+        zstdProc.emit("close", 0);
+        zstdProc.stderr.emit("data", Buffer.from("zstd diagnostic"));
+        tarProc.stderr.emit("data", Buffer.from("tar failed"));
+        tarProc.emit("close", 2);
+      });
+      return zstdProc;
+    });
+
+    const { createWorkspacePersistArchive } = await import("./dev-server.mjs");
+
+    await expect(
+      createWorkspacePersistArchive("/workspace"),
+    ).rejects.toThrowError(/^tar archival failed \(code 2\): tar failed$/);
+  });
+});

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

@@ -48,6 +48,10 @@ import {
   customComponentsPlugin,
   isCustomComponentsEnabled,
 } from "./custom-build.mjs";
+import {
+  formatViteDevServerStartedLog,
+  logViteBuildError,
+} from "./vite-dev-server-diagnostics.mjs";
 import { buildManifestStubPlugin } from "./vite-plugin-build-manifest-stub.mjs";
 import { ddRumPlugin } from "./vite-plugin-dd-rum.mjs";
 
@@ -119,6 +123,96 @@ function vitePlugins(
   ];
 }
 
+export async function createWorkspacePersistArchive(root: string) {
+  // Warm pods already have template dependencies installed, so persist only
+  // user workspace files and let startup reconcile package drift if needed.
+  return new Promise<Buffer>((resolveArchive, rejectArchive) => {
+    const tarProc = child_process.spawn(
+      "tar",
+      [
+        "cf",
+        "-",
+        "--exclude",
+        ".git",
+        "--exclude",
+        "node_modules",
+        "--exclude",
+        ".superblocks",
+        "-C",
+        root,
+        ".",
+      ],
+      { stdio: ["ignore", "pipe", "pipe"] },
+    );
+    const zstdProc = child_process.spawn("zstd", ["-1", "--no-progress"], {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    let settled = false;
+    let tarExitCode: number | null | undefined;
+    let zstdExitCode: number | null | undefined;
+    const rejectOnce = (error: Error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      rejectArchive(error);
+    };
+
+    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) => {
+      rejectOnce(new Error(`zstd stdin stream error: ${err.message}`));
+    });
+
+    const chunks: Buffer[] = [];
+    zstdProc.stdout.on("data", (chunk: Buffer) => chunks.push(chunk));
+
+    let tarStderr = "";
+    let zstdStderr = "";
+    tarProc.stderr.on("data", (chunk: Buffer) => {
+      tarStderr += chunk.toString();
+    });
+    zstdProc.stderr.on("data", (chunk: Buffer) => {
+      zstdStderr += chunk.toString();
+    });
+
+    const finishIfClosed = () => {
+      if (settled || tarExitCode === undefined || zstdExitCode === undefined) {
+        return;
+      }
+      settled = true;
+      if (zstdExitCode !== 0) {
+        rejectArchive(
+          new Error(
+            `zstd compression failed (code ${zstdExitCode}): ${zstdStderr}`,
+          ),
+        );
+      } else if (tarExitCode !== 0) {
+        rejectArchive(
+          new Error(`tar archival failed (code ${tarExitCode}): ${tarStderr}`),
+        );
+      } else {
+        resolveArchive(Buffer.concat(chunks));
+      }
+    };
+
+    tarProc.on("close", (code) => {
+      tarExitCode = code;
+      finishIfClosed();
+    });
+
+    zstdProc.on("close", (code) => {
+      zstdExitCode = code;
+      finishIfClosed();
+    });
+    tarProc.on("error", rejectOnce);
+    zstdProc.on("error", rejectOnce);
+  });
+}
+
 export const RESTART_EXIT_CODE = 98;
 
 function getJwksUriWithBaseUrl(superblocksBaseUrl?: string): string {
@@ -587,79 +681,7 @@ export async function createDevServer({
 
       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);
-        },
-      );
+      const archive = await createWorkspacePersistArchive(process.cwd());
 
       logger.info(
         `/_sb_persist: archive created (${(archive.length / 1024 / 1024).toFixed(1)}MB) in ${Date.now() - persistStart}ms, uploading...`,
@@ -833,7 +855,11 @@ async function startVite({
         logger.warn(msg);
       };
       viteLogger.error = (msg: string) => {
-        logger.error(msg);
+        logViteBuildError(logger, {
+          rawMessage: msg,
+          sdkVersion: pkg.version,
+          viteRootBasename: path.basename(root),
+        });
       };
 
       viteLogger.clearScreen = () => {};
@@ -954,7 +980,12 @@ async function startVite({
 
       const routeIndex = (app._router as IRouter).stack.length;
       app.use(viteServer.middlewares);
-      logger.info("Dev server created and middleware attached successfully");
+      logger.info(
+        `${formatViteDevServerStartedLog({
+          sdkVersion: pkg.version,
+          viteRootBasename: path.basename(root),
+        })} Dev server created and middleware attached successfully`,
+      );
 
       return {
         viteServer,