@superblocksteam/sdk 2.0.117 → 2.0.118-next.0

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

@@ -1,8 +1,11 @@
 import type * as NodeChildProcess from "node:child_process";
 import { EventEmitter } from "node:events";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { PassThrough } from "node:stream";
 
-import { describe, expect, it, vi } from "vitest";
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
 
 const { spawnMock } = vi.hoisted(() => ({
   spawnMock: vi.fn(),
@@ -22,6 +25,14 @@ vi.mock("node:child_process", async () => {
   };
 });
 
+// Use a static import so the slow `dev-server.mjs` module graph (vite, react
+// plugin, workspace deps) loads during file evaluation rather than inside each
+// test, where the cold-import cost easily exceeds the default 5s test timeout.
+import {
+  createWorkspacePersistArchive,
+  getSuperblocksTarExcludes,
+} from "./dev-server.mjs";
+
 function createMockProcess() {
   return Object.assign(new EventEmitter(), {
     stdin: new PassThrough(),
@@ -30,8 +41,53 @@ function createMockProcess() {
   });
 }
 
+describe("getSuperblocksTarExcludes", () => {
+  let tempRoot: string;
+
+  beforeAll(() => {
+    tempRoot = mkdtempSync(join(tmpdir(), "persist-test-"));
+  });
+
+  afterAll(() => {
+    rmSync(tempRoot, { recursive: true, force: true });
+  });
+
+  it("excludes .superblocks entirely when the directory does not exist", () => {
+    const result = getSuperblocksTarExcludes(tempRoot);
+    expect(result).toEqual(["--exclude", ".superblocks"]);
+  });
+
+  it("excludes subdirs not in the safelist and keeps context/drafts", () => {
+    const sb = join(tempRoot, ".superblocks");
+    mkdirSync(sb);
+    mkdirSync(join(sb, "context"));
+    mkdirSync(join(sb, "drafts"));
+    mkdirSync(join(sb, "recordings"));
+    mkdirSync(join(sb, "scratch"));
+    mkdirSync(join(sb, "system-skills"));
+
+    const result = getSuperblocksTarExcludes(tempRoot);
+
+    // Safelisted dirs must NOT appear
+    expect(result).not.toContain(".superblocks/context");
+    expect(result).not.toContain(".superblocks/drafts");
+
+    // Non-safelisted dirs must be excluded
+    expect(result).toContain(".superblocks/recordings");
+    expect(result).toContain(".superblocks/scratch");
+    expect(result).toContain(".superblocks/system-skills");
+
+    // Each excluded dir has a preceding --exclude flag
+    for (const name of ["recordings", "scratch", "system-skills"]) {
+      const idx = result.indexOf(`.superblocks/${name}`);
+      expect(idx).toBeGreaterThan(0);
+      expect(result[idx - 1]).toBe("--exclude");
+    }
+  });
+});
+
 describe("createWorkspacePersistArchive", () => {
-  it("excludes node_modules from the tar archive", async () => {
+  it("archive respects excludes", async () => {
     const tarProc = createMockProcess();
     const zstdProc = createMockProcess();
     spawnMock.mockImplementation((command: string) => {
@@ -47,27 +103,17 @@ describe("createWorkspacePersistArchive", () => {
       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",
-      ".",
-    ]);
+    const args: string[] = tarCall?.[1];
+
+    // Standard excludes are always present
+    expect(args).toContain(".git");
+    expect(args).toContain("node_modules");
   });
 
   it("rejects if tar fails after zstd closes successfully", async () => {
@@ -87,10 +133,115 @@ describe("createWorkspacePersistArchive", () => {
       return zstdProc;
     });
 
-    const { createWorkspacePersistArchive } = await import("./dev-server.mjs");
-
     await expect(
       createWorkspacePersistArchive("/workspace"),
     ).rejects.toThrowError(/^tar archival failed \(code 2\): tar failed$/);
   });
 });
+
+describe("createWorkspacePersistUploadHeaders", () => {
+  it("forwards presigned upload headers and adds the archive content length", async () => {
+    const { createWorkspacePersistUploadHeaders } =
+      await import("./dev-server.mjs");
+
+    expect(
+      createWorkspacePersistUploadHeaders(123, {
+        "Content-Type": "application/custom-zstd",
+        "x-amz-server-side-encryption": "AES256",
+      }),
+    ).toEqual({
+      "content-length": "123",
+      "content-type": "application/custom-zstd",
+      "x-amz-server-side-encryption": "AES256",
+    });
+  });
+
+  it("normalizes presigned upload header names case-insensitively", async () => {
+    const { createWorkspacePersistUploadHeaders } =
+      await import("./dev-server.mjs");
+
+    expect(
+      createWorkspacePersistUploadHeaders(789, {
+        "content-type": "application/custom-zstd",
+        "content-length": "1",
+        "x-amz-server-side-encryption": "AES256",
+      }),
+    ).toEqual({
+      "content-length": "789",
+      "content-type": "application/custom-zstd",
+      "x-amz-server-side-encryption": "AES256",
+    });
+  });
+
+  it("keeps the legacy content headers when SABS sends only a URL", async () => {
+    const { createWorkspacePersistUploadHeaders } =
+      await import("./dev-server.mjs");
+
+    expect(createWorkspacePersistUploadHeaders(456)).toEqual({
+      "content-length": "456",
+      "content-type": "application/zstd",
+    });
+  });
+});
+
+describe("isWorkspacePersistUploadHeaders", () => {
+  it("accepts undefined (legacy SABS payloads with no uploadHeaders)", async () => {
+    const { isWorkspacePersistUploadHeaders } =
+      await import("./dev-server.mjs");
+
+    expect(isWorkspacePersistUploadHeaders(undefined)).toBe(true);
+  });
+
+  it("accepts a valid string map", async () => {
+    const { isWorkspacePersistUploadHeaders } =
+      await import("./dev-server.mjs");
+
+    expect(
+      isWorkspacePersistUploadHeaders({
+        "content-type": "application/zstd",
+        "x-amz-server-side-encryption": "AES256",
+      }),
+    ).toBe(true);
+  });
+
+  it("rejects null, arrays, and non-string values", async () => {
+    const { isWorkspacePersistUploadHeaders } =
+      await import("./dev-server.mjs");
+
+    expect(isWorkspacePersistUploadHeaders(null)).toBe(false);
+    expect(isWorkspacePersistUploadHeaders([])).toBe(false);
+    expect(isWorkspacePersistUploadHeaders({ "x-foo": 1 })).toBe(false);
+  });
+
+  it("rejects case-insensitive duplicate keys", async () => {
+    const { isWorkspacePersistUploadHeaders } =
+      await import("./dev-server.mjs");
+
+    expect(
+      isWorkspacePersistUploadHeaders({
+        "Content-Type": "application/zstd",
+        "content-type": "application/custom-zstd",
+      }),
+    ).toBe(false);
+  });
+
+  it("rejects header names with illegal characters", async () => {
+    const { isWorkspacePersistUploadHeaders } =
+      await import("./dev-server.mjs");
+
+    // Spaces are not allowed in HTTP token names.
+    expect(isWorkspacePersistUploadHeaders({ "bad header": "value" })).toBe(
+      false,
+    );
+  });
+
+  it("rejects header values with illegal characters", async () => {
+    const { isWorkspacePersistUploadHeaders } =
+      await import("./dev-server.mjs");
+
+    // CR/LF in header values is not allowed (header injection guard).
+    expect(isWorkspacePersistUploadHeaders({ "x-foo": "bad\r\nvalue" })).toBe(
+      false,
+    );
+  });
+});