@superblocksteam/sdk 2.0.115-next.1 → 2.0.115

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

@@ -123,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 {
@@ -591,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...`,

package/src/index.ts

@@ -86,6 +86,21 @@ export {
 
 export { dev, DevServerAutoUpgradeMode } from "./cli-replacement/dev.mjs";
 
+export {
+  didPackageJsonSnapshotChange,
+  packageJsonSnapshot,
+  packageJsonSnapshotDiagnostic,
+  readPackageJsonSnapshot,
+  readPackageJsonSnapshotWithSource,
+  PACKAGE_DEPENDENCY_FIELDS,
+  restoreManagedPackageDependencies,
+  MANAGED_PACKAGE_DEPENDENCIES,
+  SUPERBLOCKS_SDK_API_PACKAGE,
+  SUPERBLOCKS_LIBRARY_PACKAGE,
+  type PackageJsonSnapshot,
+  type PackageJsonSnapshotReadResult,
+} from "./cli-replacement/package-json-snapshot.mjs";
+
 export { getLogger } from "./telemetry/logging.js";
 
 export {