@ryanfw/prompt-orchestration-pipeline 0.10.0 → 0.12.0

package/src/ui/sse-broadcast.js

@@ -0,0 +1,93 @@
+/**
+ * SSE broadcast module for state updates
+ * Extracted from router.js to support Express migration
+ */
+
+import { sseRegistry } from "./sse.js";
+
+/**
+ * Decorate change with job ID extracted from file path
+ */
+function decorateChangeWithJobId(change) {
+  if (!change || typeof change !== "object") return change;
+  const normalizedPath = String(change.path || "").replace(/\\/g, "/");
+  const match = normalizedPath.match(
+    /pipeline-data\/(current|complete|pending|rejected)\/([^/]+)/
+  );
+  if (!match) {
+    return change;
+  }
+  return {
+    ...change,
+    lifecycle: match[1],
+    jobId: match[2],
+  };
+}
+
+/**
+ * Prioritize job status changes over other changes
+ */
+function prioritizeJobStatusChange(changes = []) {
+  const normalized = changes.map((change) => decorateChangeWithJobId(change));
+  const statusChange = normalized.find(
+    (change) =>
+      typeof change?.path === "string" &&
+      /tasks-status\.json$/.test(change.path)
+  );
+  return statusChange || normalized[0] || null;
+}
+
+/**
+ * Broadcast state update to all SSE clients
+ *
+ * NOTE: Per plan, SSE should emit compact, incremental events rather than
+ * streaming full application state. Use /api/state for full snapshot
+ * retrieval on client bootstrap. This function will emit only the most
+ * recent change when available (type: "state:change") and fall back to a
+ * lightweight summary event if no recent change is present.
+ */
+function broadcastStateUpdate(currentState) {
+  try {
+    const recentChanges = (currentState && currentState.recentChanges) || [];
+    const latest = prioritizeJobStatusChange(recentChanges);
+    if (latest) {
+      // Emit only the most recent change as a compact, typed event
+      const eventData = { type: "state:change", data: latest };
+      sseRegistry.broadcast(eventData);
+    } else {
+      // Fallback: emit a minimal summary so clients can observe a state "tick"
+      const eventData = {
+        type: "state:summary",
+        data: {
+          changeCount:
+            currentState && currentState.changeCount
+              ? currentState.changeCount
+              : 0,
+        },
+      };
+      sseRegistry.broadcast(eventData);
+    }
+  } catch (err) {
+    // Defensive: if something unexpected happens, fall back to a lightweight notification
+    try {
+      console.error("[Router] Error in broadcastStateUpdate:", err);
+      sseRegistry.broadcast({
+        type: "state:summary",
+        data: {
+          changeCount:
+            currentState && currentState.changeCount
+              ? currentState.changeCount
+              : 0,
+        },
+      });
+    } catch (fallbackErr) {
+      // Log error to aid debugging; this should never happen unless sseRegistry.broadcast is broken
+      console.error(
+        "Failed to broadcast fallback state summary in broadcastStateUpdate:",
+        fallbackErr
+      );
+    }
+  }
+}
+
+export { broadcastStateUpdate };

package/src/ui/utils/http-utils.js

@@ -0,0 +1,139 @@
+/**
+ * HTTP utility functions for request/response handling
+ */
+
+/**
+ * Send JSON response with proper headers
+ * @param {http.ServerResponse} res - HTTP response object
+ * @param {number} code - HTTP status code
+ * @param {Object} obj - Response body object
+ */
+export const sendJson = (res, code, obj) => {
+  res.writeHead(code, {
+    "content-type": "application/json",
+    connection: "close",
+  });
+  res.end(JSON.stringify(obj));
+};
+
+/**
+ * Read raw request body with size limit
+ * @param {http.IncomingMessage} req - HTTP request object
+ * @param {number} maxBytes - Maximum bytes to read (default: 2MB)
+ * @returns {Promise<Buffer>} Raw request body as Buffer
+ */
+export async function readRawBody(req, maxBytes = 2 * 1024 * 1024) {
+  // 2MB guard
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of req) {
+    total += chunk.length;
+    if (total > maxBytes) throw new Error("Payload too large");
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks);
+}
+
+/**
+ * Parse multipart form data from request
+ * @param {http.IncomingMessage} req - HTTP request object
+ * @returns {Promise<Object>} Parsed form data with file content as Buffer
+ */
+export function parseMultipartFormData(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let boundary = null;
+
+    // Extract boundary from content-type header
+    const contentType = req.headers["content-type"];
+    if (!contentType || !contentType.includes("multipart/form-data")) {
+      reject(new Error("Invalid content-type: expected multipart/form-data"));
+      return;
+    }
+
+    const boundaryMatch = contentType.match(/boundary=([^;]+)/);
+    if (!boundaryMatch) {
+      reject(new Error("Missing boundary in content-type"));
+      return;
+    }
+
+    boundary = `--${boundaryMatch[1].trim()}`;
+
+    req.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+
+    req.on("end", () => {
+      try {
+        const buffer = Buffer.concat(chunks);
+
+        // Find file part in the buffer using string operations for headers
+        const data = buffer.toString(
+          "utf8",
+          0,
+          Math.min(buffer.length, 1024 * 1024)
+        ); // First MB for header search
+        const parts = data.split(boundary);
+
+        for (let i = 0; i < parts.length; i++) {
+          const part = parts[i];
+
+          if (part.includes('name="file"') && part.includes("filename")) {
+            // Extract filename
+            const filenameMatch = part.match(/filename="([^"]+)"/);
+            if (!filenameMatch) continue;
+
+            // Extract content type
+            const contentTypeMatch = part.match(/Content-Type:\s*([^\r\n]+)/);
+
+            // Find this specific part's start in the data string
+            const partIndexInData = data.indexOf(part);
+            const headerEndInPart = part.indexOf("\r\n\r\n");
+            if (headerEndInPart === -1) {
+              reject(
+                new Error("Could not find end of headers in multipart part")
+              );
+              return;
+            }
+
+            // Calculate the actual byte positions in the buffer for this part
+            const headerEndInData = partIndexInData + headerEndInPart + 4;
+
+            // Use binary buffer to find the next boundary
+            const boundaryBuf = Buffer.from(boundary, "ascii");
+            const nextBoundaryIndex = buffer.indexOf(
+              boundaryBuf,
+              headerEndInData
+            );
+            const contentEndInData =
+              nextBoundaryIndex !== -1
+                ? nextBoundaryIndex - 2 // Subtract 2 for \r\n before boundary
+                : buffer.length;
+
+            // Extract the file content as Buffer
+            const contentBuffer = buffer.slice(
+              headerEndInData,
+              contentEndInData
+            );
+
+            resolve({
+              filename: filenameMatch[1],
+              contentType: contentTypeMatch
+                ? contentTypeMatch[1]
+                : "application/octet-stream",
+              contentBuffer: contentBuffer,
+            });
+            return;
+          }
+        }
+
+        reject(new Error("No file field found in form data"));
+      } catch (error) {
+        console.error("Error parsing multipart:", error);
+        reject(error);
+      }
+    });
+
+    req.on("error", reject);
+  });
+}

package/src/ui/utils/mime-types.js

@@ -0,0 +1,196 @@
+import path from "path";
+
+// MIME type detection map
+const MIME_MAP = {
+  // Text types
+  ".txt": "text/plain",
+  ".log": "text/plain",
+  ".md": "text/markdown",
+  ".csv": "text/csv",
+  ".json": "application/json",
+  ".xml": "application/xml",
+  ".yaml": "application/x-yaml",
+  ".yml": "application/x-yaml",
+  ".toml": "application/toml",
+  ".ini": "text/plain",
+  ".conf": "text/plain",
+  ".config": "text/plain",
+  ".env": "text/plain",
+  ".gitignore": "text/plain",
+  ".dockerfile": "text/plain",
+  ".sh": "application/x-sh",
+  ".bash": "application/x-sh",
+  ".zsh": "application/x-sh",
+  ".fish": "application/x-fish",
+  ".ps1": "application/x-powershell",
+  ".bat": "application/x-bat",
+  ".cmd": "application/x-cmd",
+
+  // Code types
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".cjs": "application/javascript",
+  ".ts": "application/typescript",
+  ".mts": "application/typescript",
+  ".cts": "application/typescript",
+  ".jsx": "application/javascript",
+  ".tsx": "application/typescript",
+  ".py": "text/x-python",
+  ".rb": "text/x-ruby",
+  ".php": "application/x-php",
+  ".java": "text/x-java-source",
+  ".c": "text/x-c",
+  ".cpp": "text/x-c++",
+  ".cc": "text/x-c++",
+  ".cxx": "text/x-c++",
+  ".h": "text/x-c",
+  ".hpp": "text/x-c++",
+  ".cs": "text/x-csharp",
+  ".go": "text/x-go",
+  ".rs": "text/x-rust",
+  ".swift": "text/x-swift",
+  ".kt": "text/x-kotlin",
+  ".scala": "text/x-scala",
+  ".r": "text/x-r",
+  ".sql": "application/sql",
+  ".pl": "text/x-perl",
+  ".lua": "text/x-lua",
+  ".vim": "text/x-vim",
+  ".el": "text/x-elisp",
+  ".lisp": "text/x-lisp",
+  ".hs": "text/x-haskell",
+  ".ml": "text/x-ocaml",
+  ".ex": "text/x-elixir",
+  ".exs": "text/x-elixir",
+  ".erl": "text/x-erlang",
+  ".beam": "application/x-erlang-beam",
+
+  // Web types
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".xhtml": "application/xhtml+xml",
+  ".css": "text/css",
+  ".scss": "text/x-scss",
+  ".sass": "text/x-sass",
+  ".less": "text/x-less",
+  ".styl": "text/x-stylus",
+  ".vue": "text/x-vue",
+  ".svelte": "text/x-svelte",
+
+  // Data formats
+  ".pdf": "application/pdf",
+  ".doc": "application/msword",
+  ".docx":
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx":
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".odt": "application/vnd.oasis.opendocument.text",
+  ".ods": "application/vnd.oasis.opendocument.spreadsheet",
+  ".odp": "application/vnd.oasis.opendocument.presentation",
+
+  // Images
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".bmp": "image/bmp",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".tiff": "image/tiff",
+  ".tif": "image/tiff",
+  ".psd": "image/vnd.adobe.photoshop",
+  ".ai": "application/pdf", // Illustrator files often saved as PDF
+  ".eps": "application/postscript",
+
+  // Audio
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".flac": "audio/flac",
+  ".aac": "audio/aac",
+  ".m4a": "audio/mp4",
+  ".wma": "audio/x-ms-wma",
+
+  // Video
+  ".mp4": "video/mp4",
+  ".avi": "video/x-msvideo",
+  ".mov": "video/quicktime",
+  ".wmv": "video/x-ms-wmv",
+  ".flv": "video/x-flv",
+  ".webm": "video/webm",
+  ".mkv": "video/x-matroska",
+  ".m4v": "video/mp4",
+
+  // Archives
+  ".zip": "application/zip",
+  ".rar": "application/x-rar-compressed",
+  ".tar": "application/x-tar",
+  ".gz": "application/gzip",
+  ".tgz": "application/gzip",
+  ".bz2": "application/x-bzip2",
+  ".xz": "application/x-xz",
+  ".7z": "application/x-7z-compressed",
+  ".deb": "application/x-debian-package",
+  ".rpm": "application/x-rpm",
+  ".dmg": "application/x-apple-diskimage",
+  ".iso": "application/x-iso9660-image",
+
+  // Fonts
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".eot": "application/vnd.ms-fontobject",
+
+  // Misc
+  ".bin": "application/octet-stream",
+  ".exe": "application/x-msdownload",
+  ".dll": "application/x-msdownload",
+  ".so": "application/x-sharedlib",
+  ".dylib": "application/x-mach-binary",
+  ".class": "application/java-vm",
+  ".jar": "application/java-archive",
+  ".war": "application/java-archive",
+  ".ear": "application/java-archive",
+  ".apk": "application/vnd.android.package-archive",
+  ".ipa": "application/x-itunes-ipa",
+};
+
+/**
+ * Determine MIME type from file extension
+ * @param {string} filename - File name
+ * @returns {string} MIME type
+ */
+function getMimeType(filename) {
+  const ext = path.extname(filename).toLowerCase();
+  return MIME_MAP[ext] || "application/octet-stream";
+}
+
+/**
+ * Check if MIME type should be treated as text
+ * @param {string} mime - MIME type
+ * @returns {boolean} True if text-like
+ */
+function isTextMime(mime) {
+  return (
+    mime.startsWith("text/") ||
+    mime === "application/json" ||
+    mime === "application/javascript" ||
+    mime === "application/xml" ||
+    mime === "application/x-yaml" ||
+    mime === "application/x-sh" ||
+    mime === "application/x-bat" ||
+    mime === "application/x-cmd" ||
+    mime === "application/x-powershell" ||
+    mime === "image/svg+xml" ||
+    mime === "application/x-ndjson" ||
+    mime === "text/csv" ||
+    mime === "text/markdown"
+  );
+}
+
+export { MIME_MAP, getMimeType, isTextMime };

package/src/ui/vite.config.js

@@ -0,0 +1,22 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+
+// Fix the publicDir path to resolve the static assets issue.
+// Vite was looking in src/ui/client/public (relative to root),
+// but public assets are in src/ui/public.
+// By setting publicDir to an absolute path, Vite will copy
+// contents of src/ui/public to dist during build.
+const publicDir = new URL("./public", import.meta.url).pathname;
+
+export default defineConfig({
+  plugins: [react()],
+  root: "src/ui/client",
+  build: {
+    outDir: "../../dist", // Output to src/ui/dist
+    sourcemap: true,
+  },
+  publicDir,
+  server: {
+    cors: true,
+  },
+});

package/src/ui/zip-utils.js

@@ -0,0 +1,103 @@
+import { unzipSync } from "fflate";
+import path from "node:path";
+
+/**
+ * Extract seed JSON and artifacts from a zip buffer using fflate
+ * @param {Buffer|Uint8Array} zipBuffer - Buffer containing zip data
+ * @returns {Promise<{seedObject: Object, artifacts: Array<{filename: string, content: Buffer}>}>}
+ */
+export async function extractSeedZip(zipBuffer) {
+  // Normalize to Uint8Array for fflate
+  const zipData = Buffer.isBuffer(zipBuffer)
+    ? new Uint8Array(zipBuffer)
+    : zipBuffer;
+
+  console.log("[ZIP] Starting real zip parsing", {
+    bufferSize: zipData.length,
+  });
+
+  try {
+    // Check if this looks like a valid zip by looking for PK signature
+    if (zipData.length < 4 || zipData[0] !== 0x50 || zipData[1] !== 0x4b) {
+      throw new Error("Invalid ZIP file signature");
+    }
+
+    // Use fflate to extract all entries
+    const entries = unzipSync(zipData);
+    const artifacts = [];
+    let seedObject = null;
+    let seedJsonCount = 0;
+
+    console.log("[ZIP] Extracted entries from zip", {
+      entryCount: Object.keys(entries).length,
+      entryNames: Object.keys(entries),
+    });
+
+    // Process each entry
+    for (const [entryName, rawContent] of Object.entries(entries)) {
+      // Skip directory entries (names ending with /)
+      if (entryName.endsWith("/")) {
+        console.log("[ZIP] Skipping directory entry", { entryName });
+        continue;
+      }
+
+      // Derive filename using basename (flatten directory structure)
+      const filename = path.basename(entryName);
+      console.log("[ZIP] Processing entry", { entryName, filename });
+
+      // Convert Uint8Array to Buffer
+      const content = Buffer.from(rawContent);
+
+      // Add to artifacts
+      artifacts.push({ filename, content });
+
+      // Check if this is seed.json
+      if (filename === "seed.json") {
+        seedJsonCount++;
+        try {
+          const jsonContent = content.toString("utf8");
+          seedObject = JSON.parse(jsonContent);
+          console.log("[ZIP] Successfully parsed seed.json", {
+            seedName: seedObject.name,
+            seedPipeline: seedObject.pipeline,
+          });
+        } catch (parseError) {
+          console.error("[ZIP] Failed to parse seed.json", {
+            error: parseError.message,
+            filename,
+          });
+          throw new Error("Invalid JSON");
+        }
+      }
+    }
+
+    // Validate that we found at least one seed.json
+    if (seedJsonCount === 0) {
+      throw new Error("seed.json not found in zip");
+    }
+
+    if (seedJsonCount > 1) {
+      console.log(
+        "[ZIP] Warning: multiple seed.json files found, using last one",
+        {
+          count: seedJsonCount,
+        }
+      );
+    }
+
+    console.log("[ZIP] Zip extraction completed", {
+      artifactCount: artifacts.length,
+      artifactNames: artifacts.map((a) => a.filename),
+      seedKeys: seedObject ? Object.keys(seedObject) : [],
+      seedJsonCount,
+    });
+
+    return { seedObject, artifacts };
+  } catch (error) {
+    console.error("[ZIP] Zip extraction failed", {
+      error: error.message,
+      bufferSize: zipData.length,
+    });
+    throw error;
+  }
+}

package/src/utils/jobs.js

@@ -1,3 +1,5 @@
+import { normalizeTaskState } from "../config/statuses.js";
+
 export const countCompleted = (job) => {
   const list = Array.isArray(job?.tasks)
     ? job.tasks
@@ -5,3 +7,40 @@ export const countCompleted = (job) => {
   return list.filter((t) => t?.state === "done" || t?.state === "completed")
     .length;
 };
+
+export const DisplayCategory = Object.freeze({
+  ERRORS: "errors",
+  CURRENT: "current",
+  COMPLETE: "complete",
+});
+
+export function classifyJobForDisplay(job) {
+  if (!job) return DisplayCategory.CURRENT;
+
+  const tasks = Array.isArray(job?.tasks)
+    ? job.tasks
+    : Object.values(job?.tasks || {});
+
+  const normalizedStates = tasks.map((task) => normalizeTaskState(task?.state));
+
+  // Precedence: errors > current > complete > fallback to current
+  if (
+    job.status === "failed" ||
+    normalizedStates.some((state) => state === "failed")
+  ) {
+    return DisplayCategory.ERRORS;
+  }
+
+  if (
+    job.status === "running" ||
+    normalizedStates.some((state) => state === "running")
+  ) {
+    return DisplayCategory.CURRENT;
+  }
+
+  if (tasks.length > 0 && normalizedStates.every((state) => state === "done")) {
+    return DisplayCategory.COMPLETE;
+  }
+
+  return DisplayCategory.CURRENT;
+}