@ryanfw/prompt-orchestration-pipeline 1.2.10 → 1.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanfw/prompt-orchestration-pipeline",
-  "version": "1.2.10",
+  "version": "1.2.11",
   "description": "A Prompt-orchestration pipeline (POP) is a framework for building, running, and experimenting with complex chains of LLM tasks.",
   "type": "module",
   "main": "src/ui/server/index.ts",

package/src/ui/server/__tests__/utils.test.ts

@@ -1,9 +1,21 @@
+import { unzipSync, zipSync } from "fflate";
 import { describe, expect, it } from "vitest";
 
 import { parseMultipartFormData, readRawBody, sendJson } from "../utils/http-utils";
 import { getMimeType, isTextMime } from "../utils/mime-types";
 import { ensureUniqueSlug, generateSlug } from "../utils/slug";
 
+function concatBytes(parts: Uint8Array[]): Uint8Array<ArrayBuffer> {
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+
 describe("server utils", () => {
   it("sends json responses", async () => {
     const response = sendJson(200, { ok: true });
@@ -46,6 +58,122 @@ describe("server utils", () => {
     expect(parsed.files[0]).toMatchObject({ filename: "seed.json", contentType: "application/json" });
   });
 
+  it("preserves binary zip payloads byte-for-byte", async () => {
+    const seed = { name: "binary-seed" };
+    const binary = new Uint8Array(256);
+    for (let i = 0; i < 256; i++) {
+      binary[i] = i;
+    }
+    const zip = zipSync({
+      "seed.json": new TextEncoder().encode(JSON.stringify(seed)),
+      "data.bin": binary,
+    });
+
+    const boundary = "binaryboundary";
+    const encoder = new TextEncoder();
+    const header = encoder.encode(
+      `--${boundary}\r\n` +
+        'Content-Disposition: form-data; name="file"; filename="bundle.zip"\r\n' +
+        "Content-Type: application/zip\r\n\r\n",
+    );
+    const footer = encoder.encode(`\r\n--${boundary}--\r\n`);
+    const body = concatBytes([header, zip, footer]);
+
+    const request = new Request("http://localhost", {
+      method: "POST",
+      headers: { "content-type": `multipart/form-data; boundary=${boundary}` },
+      body,
+    });
+
+    const parsed = await parseMultipartFormData(request);
+
+    // AC1: byte-for-byte identical recovery.
+    const file = parsed.files[0]!;
+    expect(file.content.length).toBe(zip.length);
+    expect(Array.from(file.content)).toEqual(Array.from(zip));
+
+    // AC2: recovered bytes unzip and include seed.json.
+    const extracted = unzipSync(file.content);
+    expect(Object.keys(extracted)).toContain("seed.json");
+  });
+
+  it("routes string fields and preserves text file metadata", async () => {
+    const boundary = "mixedboundary";
+    const body = [
+      `--${boundary}`,
+      'Content-Disposition: form-data; name="meta"',
+      "",
+      "value",
+      `--${boundary}`,
+      'Content-Disposition: form-data; name="file"; filename="seed.json"',
+      "Content-Type: application/json",
+      "",
+      '{"ok":true}',
+      `--${boundary}--`,
+      "",
+    ].join("\r\n");
+    const request = new Request("http://localhost", {
+      method: "POST",
+      headers: { "content-type": `multipart/form-data; boundary=${boundary}` },
+      body,
+    });
+
+    const parsed = await parseMultipartFormData(request);
+
+    // AC4: a part without a filename is returned under fields.
+    expect(parsed.fields).toEqual({ meta: "value" });
+
+    // AC5: a .json file part preserves filename and contentType.
+    expect(parsed.files[0]).toMatchObject({
+      filename: "seed.json",
+      contentType: "application/json",
+    });
+  });
+
+  it("rejects non-multipart content types", async () => {
+    const request = new Request("http://localhost", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: '{"ok":true}',
+    });
+
+    // AC6: non-multipart content type throws.
+    await expect(parseMultipartFormData(request)).rejects.toThrow(/multipart/);
+  });
+
+  it("rejects multipart content types without a boundary", async () => {
+    const request = new Request("http://localhost", {
+      method: "POST",
+      headers: { "content-type": "multipart/form-data" },
+      body: "irrelevant",
+    });
+
+    await expect(parseMultipartFormData(request)).rejects.toThrow(/boundary/);
+  });
+
+  it("enforces the multipart byte cap", async () => {
+    const boundary = "capboundary";
+    const encoder = new TextEncoder();
+    const body = concatBytes([
+      encoder.encode(
+        `--${boundary}\r\n` +
+          'Content-Disposition: form-data; name="file"; filename="big.bin"\r\n' +
+          "Content-Type: application/octet-stream\r\n\r\n",
+      ),
+      new Uint8Array(1024),
+      encoder.encode(`\r\n--${boundary}--\r\n`),
+    ]);
+
+    const request = new Request("http://localhost", {
+      method: "POST",
+      headers: { "content-type": `multipart/form-data; boundary=${boundary}` },
+      body,
+    });
+
+    // AC7: a body larger than the passed maxBytes throws.
+    await expect(parseMultipartFormData(request, 64)).rejects.toThrow(/exceeds/);
+  });
+
   it("maps mime types and text classification", () => {
     expect(getMimeType("file.json")).toBe("application/json");
     expect(getMimeType("file.unknown")).toBe("application/octet-stream");

package/src/ui/server/endpoints/__tests__/upload-endpoints.test.ts

@@ -0,0 +1,57 @@
+import { zipSync } from "fflate";
+import { describe, expect, it } from "vitest";
+
+import { normalizeSeedUpload } from "../upload-endpoints";
+
+function concatBytes(parts: Uint8Array[]): Uint8Array<ArrayBuffer> {
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+
+describe("normalizeSeedUpload", () => {
+  it("extracts seed and binary artifact from a multipart zip upload", async () => {
+    const seed = { name: "demo", pipeline: "x" };
+    const artifact = new Uint8Array(256);
+    for (let i = 0; i < 256; i++) {
+      artifact[i] = i;
+    }
+    const zip = zipSync({
+      "seed.json": new TextEncoder().encode(JSON.stringify(seed)),
+      "artifacts/blob.bin": artifact,
+    });
+
+    const boundary = "uploadboundary";
+    const encoder = new TextEncoder();
+    const header = encoder.encode(
+      `--${boundary}\r\n` +
+        'Content-Disposition: form-data; name="file"; filename="bundle.zip"\r\n' +
+        "Content-Type: application/zip\r\n\r\n",
+    );
+    const footer = encoder.encode(`\r\n--${boundary}--\r\n`);
+    const body = concatBytes([header, zip, footer]);
+
+    const request = new Request("http://localhost", {
+      method: "POST",
+      headers: { "content-type": `multipart/form-data; boundary=${boundary}` },
+      body,
+    });
+
+    const result = await normalizeSeedUpload(request);
+
+    // AC3: seedObject deep-equals the original seed.
+    expect(result.seedObject).toEqual(seed);
+
+    // AC3: exactly one artifact, byte-identical to the source blob.
+    expect(result.artifacts).toHaveLength(1);
+    const blob = result.artifacts![0]!;
+    expect(blob.filename).toBe("artifacts/blob.bin");
+    expect(blob.content.length).toBe(artifact.length);
+    expect(Array.from(blob.content)).toEqual(Array.from(artifact));
+  });
+});

package/src/ui/server/utils/http-utils.ts

@@ -20,7 +20,7 @@ export function sendJson(statusCode: number, data: unknown): Response {
 export async function readRawBody(
   req: Request,
   maxBytes: number = DEFAULT_MAX_BYTES,
-): Promise<Uint8Array> {
+): Promise<Uint8Array<ArrayBuffer>> {
   const buffer = new Uint8Array(await req.arrayBuffer());
   if (buffer.byteLength > maxBytes) {
     throw badRequest(`request body exceeds ${maxBytes} bytes`);
@@ -28,63 +28,40 @@ export async function readRawBody(
   return buffer;
 }
 
-function parseHeaders(block: string): Record<string, string> {
-  return Object.fromEntries(
-    block
-      .split("\r\n")
-      .filter(Boolean)
-      .flatMap((line) => {
-        const [name, ...rest] = line.split(":");
-        if (name === undefined) return [];
-        return [[name.trim().toLowerCase(), rest.join(":").trim()] as const];
-      }),
-  );
-}
-
-function getBoundary(contentType: string | null): string {
-  const match = /boundary=(?:"([^"]+)"|([^;]+))/i.exec(contentType ?? "");
-  if (!match) throw badRequest("multipart boundary is required");
-  return match[1] ?? match[2]!;
-}
-
 export async function parseMultipartFormData(
   req: Request,
+  maxBytes: number = DEFAULT_MAX_BYTES,
 ): Promise<{ fields: Record<string, string>; files: MultipartFile[] }> {
-  const boundary = getBoundary(req.headers.get("content-type"));
-  const body = new TextDecoder().decode(await readRawBody(req));
-  const parts = body.split(`--${boundary}`).slice(1, -1);
-  const fields: Record<string, string> = {};
-  const files: MultipartFile[] = [];
-
-  for (const rawPart of parts) {
-    const part = rawPart.trimStart().replace(/\r\n$/, "");
-    const separator = part.indexOf("\r\n\r\n");
-    if (separator < 0) continue;
-
-    const headerBlock = part.slice(0, separator);
-    const contentBlock = part.slice(separator + 4);
-    const headers = parseHeaders(headerBlock);
-    const disposition = headers["content-disposition"];
-    if (!disposition) continue;
+  const contentType = req.headers.get("content-type");
+  if (
+    !contentType ||
+    !contentType.toLowerCase().includes("multipart/form-data")
+  ) {
+    throw badRequest("expected multipart/form-data content-type");
+  }
+  if (!/boundary=/i.test(contentType)) {
+    throw badRequest("multipart boundary is required");
+  }
 
-    const nameMatch = /name="([^"]+)"/.exec(disposition);
-    const fieldName = nameMatch?.[1];
-    if (!fieldName) continue;
-    const filenameMatch = /filename="([^"]*)"/.exec(disposition);
+  const raw = await readRawBody(req, maxBytes); // enforces the size cap on actual bytes
+  const form = await new Response(raw, {
+    headers: { "content-type": contentType },
+  }).formData();
 
-    if (!filenameMatch) {
-      fields[fieldName] = contentBlock;
-      continue;
+  const fields: Record<string, string> = {};
+  const files: MultipartFile[] = [];
+  for (const name of new Set(form.keys())) {
+    for (const value of form.getAll(name)) {
+      if (typeof value === "string") {
+        fields[name] = value;
+      } else {
+        files.push({
+          filename: value.name,
+          contentType: value.type || "application/octet-stream",
+          content: new Uint8Array(await value.arrayBuffer()),
+        });
+      }
     }
-
-    const filename = filenameMatch[1];
-    if (filename === undefined) continue;
-    files.push({
-      filename,
-      contentType: headers["content-type"] ?? "application/octet-stream",
-      content: new TextEncoder().encode(contentBlock),
-    });
   }
-
   return { fields, files };
 }