npm - @ryanfw/prompt-orchestration-pipeline - Versions diffs - 0.10.0 → 0.11.0 - Mend

@ryanfw/prompt-orchestration-pipeline 0.10.0 → 0.11.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/package.json +2 -1
package/src/api/index.js +38 -1
package/src/components/DAGGrid.jsx +24 -7
package/src/components/JobDetail.jsx +11 -0
package/src/components/TaskDetailSidebar.jsx +27 -3
package/src/components/UploadSeed.jsx +2 -2
package/src/core/orchestrator.js +32 -0
package/src/core/status-initializer.js +155 -0
package/src/core/status-writer.js +151 -13
package/src/ui/client/adapters/job-adapter.js +21 -2
package/src/ui/client/hooks/useJobDetailWithUpdates.js +92 -0
package/src/ui/dist/assets/{index-DqkbzXZ1.js → index-DeDzq-Kk.js} +129 -14
package/src/ui/dist/assets/style-aBtD_Yrs.css +62 -0
package/src/ui/dist/index.html +2 -2
package/src/ui/server.js +201 -109
package/src/ui/zip-utils.js +103 -0
package/src/ui/dist/assets/style-DBF9NQGk.css +0 -62

package/src/ui/dist/index.html CHANGED Viewed

@@ -11,8 +11,8 @@
     />
     <title>Prompt Pipeline Dashboard</title>
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
-    <script type="module" crossorigin src="/assets/index-DqkbzXZ1.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/style-DBF9NQGk.css">
+    <script type="module" crossorigin src="/assets/index-DeDzq-Kk.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/style-aBtD_Yrs.css">
   </head>
   <body>
     <div id="root"></div>

package/src/ui/server.js CHANGED Viewed

@@ -12,7 +12,10 @@ import * as state from "./state.js";
 // Import orchestrator-related functions only in non-test mode
 let submitJobWithValidation;
 import { sseRegistry } from "./sse.js";
-import { resetJobToCleanSlate } from "../core/status-writer.js";
+import {
+  resetJobToCleanSlate,
+  initializeJobArtifacts,
+} from "../core/status-writer.js";
 import { spawn } from "node:child_process";
 import {
   getPendingSeedPath,
@@ -23,6 +26,7 @@ import {
 } from "../config/paths.js";
 import { handleJobList, handleJobDetail } from "./endpoints/job-endpoints.js";
 import { generateJobId } from "../utils/id-generator.js";
+import { extractSeedZip } from "./zip-utils.js";
 // Get __dirname equivalent in ES modules
 const __filename = fileURLToPath(import.meta.url);
@@ -102,9 +106,14 @@ function hasValidPayload(seed) {
  * Handle seed upload directly without starting orchestrator (for test environment)
  * @param {Object} seedObject - Seed object to upload
  * @param {string} dataDir - Base data directory
+ * @param {Array} uploadArtifacts - Array of {filename, content} objects
  * @returns {Promise<Object>} Result object
  */
-async function handleSeedUploadDirect(seedObject, dataDir) {
+async function handleSeedUploadDirect(
+  seedObject,
+  dataDir,
+  uploadArtifacts = []
+) {
   let partialFiles = [];
   try {
@@ -124,16 +133,39 @@ async function handleSeedUploadDirect(seedObject, dataDir) {
       return { success: false, message: "Required fields missing" };
     }
-    // Validate name format
-    const nameRegex = /^[a-zA-Z0-9_-]+$/;
-    if (!nameRegex.test(seedObject.name)) {
+    // Validate name format using the same logic as seed validator
+    if (
+      !seedObject.name ||
+      typeof seedObject.name !== "string" ||
+      seedObject.name.trim() === ""
+    ) {
       return {
         success: false,
-        message:
-          "name must contain only alphanumeric characters, hyphens, and underscores",
+        message: "name field is required",
       };
     }
+    const trimmedName = seedObject.name.trim();
+    if (trimmedName.length > 120) {
+      return {
+        success: false,
+        message: "name must be 120 characters or less",
+      };
+    }
+    // Allow spaces and common punctuation for better UX
+    // Still disallow control characters and path traversal patterns
+    const dangerousPattern = /[\x00-\x1f\x7f-\x9f]/;
+    if (dangerousPattern.test(trimmedName)) {
+      return {
+        success: false,
+        message: "name must contain only printable characters",
+      };
+    }
+    // Update seedObject with validated trimmed name
+    seedObject.name = trimmedName;
     // Generate a random job ID
     const jobId = generateJobId();
@@ -197,6 +229,16 @@ async function handleSeedUploadDirect(seedObject, dataDir) {
       JSON.stringify(pipelineSnapshot, null, 2)
     );
+    // Initialize job artifacts if any provided
+    if (uploadArtifacts.length > 0) {
+      try {
+        await initializeJobArtifacts(currentJobDir, uploadArtifacts);
+      } catch (artifactError) {
+        // Don't fail the upload if artifact initialization fails, just log the error
+        console.error("Failed to initialize job artifacts:", artifactError);
+      }
+    }
     return {
       success: true,
       jobId,
@@ -298,6 +340,82 @@ function prioritizeJobStatusChange(changes = []) {
   return statusChange || normalized[0] || null;
 }
+/**
+ * Normalize seed upload from various input formats
+ * @param {http.IncomingMessage} req - HTTP request
+ * @param {string} contentTypeHeader - Content-Type header
+ * @returns {Promise<{seedObject: Object, uploadArtifacts: Array<{filename: string, content: Buffer}>}>}
+ */
+async function normalizeSeedUpload({ req, contentTypeHeader }) {
+  // Handle application/json uploads
+  if (contentTypeHeader.includes("application/json")) {
+    const buffer = await readRawBody(req);
+    try {
+      const seedObject = JSON.parse(buffer.toString("utf8") || "{}");
+      return {
+        seedObject,
+        uploadArtifacts: [{ filename: "seed.json", content: buffer }],
+      };
+    } catch (error) {
+      throw new Error("Invalid JSON");
+    }
+  }
+  // Handle multipart form data uploads
+  const formData = await parseMultipartFormData(req);
+  if (!formData.contentBuffer) {
+    throw new Error("No file content found");
+  }
+  // Check if this is a zip file
+  const isZipFile =
+    formData.contentType === "application/zip" ||
+    formData.filename?.toLowerCase().endsWith(".zip");
+  if (isZipFile) {
+    console.log("[UPLOAD] Detected zip upload", {
+      filename: formData.filename,
+      contentType: formData.contentType,
+      bufferSize: formData.contentBuffer.length,
+    });
+    // Handle zip upload
+    try {
+      const { seedObject, artifacts } = await extractSeedZip(
+        formData.contentBuffer
+      );
+      console.log("[UPLOAD] Zip extraction completed", {
+        artifactCount: artifacts.length,
+        artifactNames: artifacts.map((a) => a.filename),
+        seedKeys: Object.keys(seedObject),
+      });
+      return {
+        seedObject,
+        uploadArtifacts: artifacts,
+      };
+    } catch (error) {
+      console.log("[UPLOAD] Zip extraction failed", {
+        error: error.message,
+        filename: formData.filename,
+      });
+      // Re-throw zip-specific errors with clear messages
+      throw new Error(error.message);
+    }
+  } else {
+    // Handle regular JSON file upload
+    try {
+      const seedObject = JSON.parse(formData.contentBuffer.toString("utf8"));
+      const filename = formData.filename || "seed.json";
+      return {
+        seedObject,
+        uploadArtifacts: [{ filename, content: formData.contentBuffer }],
+      };
+    } catch (error) {
+      throw new Error("Invalid JSON");
+    }
+  }
+}
 function broadcastStateUpdate(currentState) {
   try {
     const recentChanges = (currentState && currentState.recentChanges) || [];
@@ -365,7 +483,7 @@ function startHeartbeat() {
 /**
  * Parse multipart form data
  * @param {http.IncomingMessage} req - HTTP request
- * @returns {Promise<Object>} Parsed form data with file content
+ * @returns {Promise<Object>} Parsed form data with file content as Buffer
  */
 function parseMultipartFormData(req) {
   return new Promise((resolve, reject) => {
@@ -394,47 +512,54 @@ function parseMultipartFormData(req) {
     req.on("end", () => {
       try {
         const buffer = Buffer.concat(chunks);
-        const data = buffer.toString("utf8");
-        console.log("Raw multipart data length:", data.length);
-        console.log("Boundary:", JSON.stringify(boundary));
-        // Simple multipart parsing - look for file field
+        // 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);
-        console.log("Number of parts:", parts.length);
         for (let i = 0; i < parts.length; i++) {
           const part = parts[i];
-          console.log(`Part ${i} length:`, part.length);
-          console.log(
-            `Part ${i} starts with:`,
-            JSON.stringify(part.substring(0, 50))
-          );
           if (part.includes('name="file"') && part.includes("filename")) {
-            console.log("Found file part at index", i);
             // Extract filename
             const filenameMatch = part.match(/filename="([^"]+)"/);
-            console.log("Filename match:", filenameMatch);
             if (!filenameMatch) continue;
             // Extract content type
             const contentTypeMatch = part.match(/Content-Type:\s*([^\r\n]+)/);
-            console.log("Content-Type match:", contentTypeMatch);
-            // Extract file content (everything after the headers)
-            const contentStart = part.indexOf("\r\n\r\n") + 4;
-            const contentEnd = part.lastIndexOf("\r\n");
-            console.log(
-              "Content start:",
-              contentStart,
-              "Content end:",
-              contentEnd
+            // 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 fileContent = part.substring(contentStart, contentEnd);
-            console.log("File content length:", fileContent.length);
-            console.log(
-              "File content:",
-              JSON.stringify(fileContent.substring(0, 100))
+            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({
@@ -442,13 +567,12 @@ function parseMultipartFormData(req) {
               contentType: contentTypeMatch
                 ? contentTypeMatch[1]
                 : "application/octet-stream",
-              content: fileContent,
+              contentBuffer: contentBuffer,
             });
             return;
           }
         }
-        console.log("No file field found in form data");
         reject(new Error("No file field found in form data"));
       } catch (error) {
         console.error("Error parsing multipart:", error);
@@ -466,57 +590,64 @@ function parseMultipartFormData(req) {
  * @param {http.ServerResponse} res - HTTP response
  */
 async function handleSeedUpload(req, res) {
+  // Add logging at the very start of the upload handler
+  console.log("[UPLOAD] Incoming seed upload", {
+    method: req.method,
+    url: req.url,
+    contentType: req.headers["content-type"],
+    userAgent: req.headers["user-agent"],
+  });
   try {
     const ct = req.headers["content-type"] || "";
-    let seedObject;
-    if (ct.includes("application/json")) {
-      const raw = await readRawBody(req);
-      try {
-        seedObject = JSON.parse(raw.toString("utf8") || "{}");
-      } catch {
-        res.writeHead(400, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ success: false, message: "Invalid JSON" }));
-        return;
-      }
-    } else {
-      // Parse multipart form data (existing behavior)
-      const formData = await parseMultipartFormData(req);
-      if (!formData.content) {
-        res.writeHead(400, { "Content-Type": "application/json" });
-        res.end(
-          JSON.stringify({ success: false, message: "No file content found" })
-        );
-        return;
-      }
-      try {
-        seedObject = JSON.parse(formData.content);
-      } catch {
-        res.writeHead(400, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ success: false, message: "Invalid JSON" }));
-        return;
+    // Use the new normalization function to handle all upload formats
+    let normalizedUpload;
+    try {
+      normalizedUpload = await normalizeSeedUpload({
+        req,
+        contentTypeHeader: ct,
+      });
+    } catch (error) {
+      console.log("[UPLOAD] Normalization failed", {
+        error: error.message,
+        contentType: ct,
+      });
+      // Handle specific zip-related errors with appropriate messages
+      let errorMessage = error.message;
+      if (error.message === "Invalid JSON") {
+        errorMessage = "Invalid JSON";
+      } else if (error.message === "seed.json not found in zip") {
+        errorMessage = "seed.json not found in zip";
       }
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, message: errorMessage }));
+      return;
     }
+    const { seedObject, uploadArtifacts } = normalizedUpload;
     // Use current PO_ROOT or fallback to DATA_DIR
     const currentDataDir = process.env.PO_ROOT || DATA_DIR;
     // For test environment, use simplified validation without starting orchestrator
-    console.log("NODE_ENV:", process.env.NODE_ENV);
     if (process.env.NODE_ENV === "test") {
-      console.log("Using test mode for seed upload");
       // Simplified validation for tests - just write to pending directory
-      const result = await handleSeedUploadDirect(seedObject, currentDataDir);
-      console.log("handleSeedUploadDirect result:", result);
+      const result = await handleSeedUploadDirect(
+        seedObject,
+        currentDataDir,
+        uploadArtifacts
+      );
       // Return appropriate status code based on success
       if (result.success) {
-        console.log("Sending 200 response");
         res.writeHead(200, {
           "Content-Type": "application/json",
           Connection: "close",
         });
         res.end(JSON.stringify(result));
-        console.log("Response sent successfully");
         // Broadcast SSE event for successful upload
         sseRegistry.broadcast({
@@ -524,17 +655,13 @@ async function handleSeedUpload(req, res) {
           data: { name: result.jobName },
         });
       } else {
-        console.log("Sending 400 response");
         res.writeHead(400, {
           "Content-Type": "application/json",
           Connection: "close",
         });
         res.end(JSON.stringify(result));
-        console.log("Response sent successfully");
       }
       return;
-    } else {
-      console.log("Using production mode for seed upload");
     }
     // Submit job with validation (for production)
@@ -546,6 +673,7 @@ async function handleSeedUpload(req, res) {
       const result = await submitJobWithValidation({
         dataDir: currentDataDir,
         seedObject,
+        uploadArtifacts,
       });
       // Send appropriate response
@@ -1082,7 +1210,6 @@ function serveStatic(res, filePath) {
  * Create and start the HTTP server
  */
 function createServer() {
-  console.log("Creating HTTP server...");
   const server = http.createServer(async (req, res) => {
     // Use WHATWG URL API instead of deprecated url.parse
     const { pathname, searchParams } = new URL(
@@ -1090,11 +1217,6 @@ function createServer() {
       `http://${req.headers.host}`
     );
-    // DEBUG: Log all API requests
-    if (pathname.startsWith("/api/")) {
-      console.log(`DEBUG: API Request: ${req.method} ${pathname}`);
-    }
     // CORS headers for API endpoints
     if (pathname.startsWith("/api/")) {
       // Important for tests: avoid idle keep-alive sockets on short API calls
@@ -1593,10 +1715,6 @@ function createServer() {
             mode: "clean-slate",
             spawned: true,
           });
-          console.log(
-            `Job ${jobId} restarted successfully, detached runner PID: ${child.pid}`
-          );
         } finally {
           // Always end restart guard
           endRestart(jobId);
@@ -1860,13 +1978,6 @@ function start(customPort) {
  */
 async function startServer({ dataDir, port: customPort }) {
   try {
-    console.log(
-      "DEBUG: startServer called with dataDir:",
-      dataDir,
-      "customPort:",
-      customPort
-    );
     // Initialize config-bridge paths early to ensure consistent path resolution
     // This prevents path caching issues when dataDir changes between tests
     const { initPATHS } = await import("./config-bridge.node.js");
@@ -1897,8 +2008,6 @@ async function startServer({ dataDir, port: customPort }) {
           ? parseInt(process.env.PORT)
           : 0;
-    console.log("DEBUG: About to create server...");
     // In development, start Vite in middlewareMode so the Node server can serve
     // the client with HMR in a single process. We dynamically import Vite here
     // to avoid including it in production bundles.
@@ -1916,22 +2025,15 @@ async function startServer({ dataDir, port: customPort }) {
           server: { middlewareMode: true },
           appType: "custom",
         });
-        console.log("DEBUG: Vite dev server started (middleware mode)");
       } catch (err) {
         console.error("Failed to start Vite dev server:", err);
         viteServer = null;
       }
-    } else if (process.env.NODE_ENV === "test") {
-      console.log("DEBUG: Vite disabled in test mode (API-only mode)");
-    } else if (process.env.DISABLE_VITE === "1") {
-      console.log("DEBUG: Vite disabled via DISABLE_VITE=1 (API-only mode)");
     }
     const server = createServer();
-    console.log("DEBUG: Server created successfully");
     // Robust promise with proper error handling and race condition prevention
-    console.log(`Attempting to start server on port ${port}...`);
     await new Promise((resolve, reject) => {
       let settled = false;
@@ -1955,7 +2057,6 @@ async function startServer({ dataDir, port: customPort }) {
         if (!settled) {
           settled = true;
           server.removeListener("error", errorHandler);
-          console.log(`Server successfully started on port ${port}`);
           resolve();
         }
       };
@@ -1981,18 +2082,10 @@ async function startServer({ dataDir, port: customPort }) {
     const address = server.address();
     const baseUrl = `http://localhost:${address.port}`;
-    console.log(`Server running at ${baseUrl}`);
-    if (dataDir) {
-      console.log(`Data directory: ${dataDir}`);
-    }
     // Only initialize watcher and heartbeat in non-test environments
     if (process.env.NODE_ENV !== "test") {
-      console.log(`Watching paths: ${WATCHED_PATHS.join(", ")}`);
       initializeWatcher();
       startHeartbeat();
-    } else {
-      console.log("Server started in test mode - skipping watcher/heartbeat");
     }
     return {
@@ -2016,7 +2109,6 @@ async function startServer({ dataDir, port: customPort }) {
           try {
             await viteServer.close();
             viteServer = null;
-            console.log("DEBUG: Vite dev server closed");
           } catch (err) {
             console.error("Error closing Vite dev server:", err);
           }

package/src/ui/zip-utils.js ADDED Viewed

@@ -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;
+  }
+}