@ryanfw/prompt-orchestration-pipeline 0.11.0 → 0.13.0

package/src/ui/express-app.js

@@ -0,0 +1,227 @@
+import express from "express";
+import path from "path";
+import { fileURLToPath } from "url";
+import { sseRegistry } from "./sse.js";
+import { handleApiState } from "./endpoints/state-endpoint.js";
+import { handleSeedUpload } from "./endpoints/upload-endpoints.js";
+import {
+  handleJobListRequest,
+  handleJobDetailRequest,
+} from "./endpoints/job-endpoints.js";
+import {
+  handleJobRescan,
+  handleJobRestart,
+  handleJobStop,
+  handleTaskStart,
+} from "./endpoints/job-control-endpoints.js";
+import {
+  handleTaskFileListRequest,
+  handleTaskFileRequest,
+} from "./endpoints/file-endpoints.js";
+import { handlePipelinesHttpRequest } from "./endpoints/pipelines-endpoint.js";
+import { handleCreatePipeline } from "./endpoints/create-pipeline-endpoint.js";
+import { handlePipelineTypeDetailRequest } from "./endpoints/pipeline-type-detail-endpoint.js";
+import { handlePipelineAnalysis } from "./endpoints/pipeline-analysis-endpoint.js";
+import { handleTaskAnalysisRequest } from "./endpoints/task-analysis-endpoint.js";
+import { handleSchemaFileRequest } from "./endpoints/schema-file-endpoint.js";
+import { handleTaskPlan } from "./endpoints/task-creation-endpoint.js";
+import { handleTaskSave } from "./endpoints/task-save-endpoint.js";
+import { sendJson } from "./utils/http-utils.js";
+import { PROVIDER_FUNCTIONS } from "../config/models.js";
+
+// Get __dirname equivalent in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Build Express application with API routes, SSE, and static serving
+ * @param {Object} params - Configuration parameters
+ * @param {string} params.dataDir - Base data directory
+ * @param {Object} [params.viteServer] - Vite dev server instance (optional)
+ * @returns {express.Application} Configured Express app
+ */
+export function buildExpressApp({ dataDir, viteServer }) {
+  const app = express();
+
+  // Parse JSON request bodies
+  app.use(express.json());
+
+  // Parse URL-encoded request bodies (for form submissions)
+  app.use(express.urlencoded({ extended: true }));
+
+  // API guard middleware mounted on /api
+  app.use("/api", (req, res, next) => {
+    // Set CORS headers
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+    // Handle OPTIONS preflight
+    if (req.method === "OPTIONS") {
+      return res.status(204).end();
+    }
+
+    // Set Connection: close for non-SSE requests
+    const isSSE = req.path === "/events" || req.path === "/sse";
+    if (!isSSE) {
+      res.setHeader("Connection", "close");
+    }
+
+    next();
+  });
+
+  // SSE routes
+  app.get(["/api/events", "/api/sse"], (req, res) => {
+    // Set SSE headers
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+
+    // Flush headers if available
+    if (typeof res.flushHeaders === "function") {
+      res.flushHeaders();
+    }
+
+    const jobId = req.query.jobId;
+    sseRegistry.addClient(res, { jobId });
+
+    req.on("close", () => {
+      sseRegistry.removeClient(res);
+    });
+  });
+
+  // REST routes
+
+  // GET /api/state
+  app.get("/api/state", async (req, res) => {
+    await handleApiState(req, res);
+  });
+
+  // POST /api/upload/seed
+  app.post("/api/upload/seed", async (req, res) => {
+    await handleSeedUpload(req, res);
+  });
+
+  // GET /api/llm/functions
+  app.get("/api/llm/functions", (req, res) => {
+    try {
+      sendJson(res, 200, { ok: true, data: PROVIDER_FUNCTIONS });
+    } catch (error) {
+      console.error("Error serving LLM functions:", error);
+      sendJson(res, 500, {
+        ok: false,
+        error: "internal_error",
+        message: "Failed to load LLM functions",
+      });
+    }
+  });
+
+  // GET /api/pipelines
+  app.get("/api/pipelines", async (req, res) => {
+    await handlePipelinesHttpRequest(req, res);
+  });
+
+  // POST /api/pipelines
+  app.post("/api/pipelines", handleCreatePipeline);
+
+  // GET /api/pipelines/:slug
+  app.get("/api/pipelines/:slug", async (req, res) => {
+    await handlePipelineTypeDetailRequest(req, res);
+  });
+
+  // POST /api/pipelines/:slug/analyze
+  app.post("/api/pipelines/:slug/analyze", handlePipelineAnalysis);
+
+  // GET /api/pipelines/:slug/tasks/:taskId/analysis
+  app.get(
+    "/api/pipelines/:slug/tasks/:taskId/analysis",
+    handleTaskAnalysisRequest
+  );
+
+  // GET /api/pipelines/:slug/schemas/:fileName
+  app.get("/api/pipelines/:slug/schemas/:fileName", handleSchemaFileRequest);
+
+  // GET /api/jobs
+  app.get("/api/jobs", async (req, res) => {
+    await handleJobListRequest(req, res);
+  });
+
+  // GET /api/jobs/:jobId
+  app.get("/api/jobs/:jobId", async (req, res) => {
+    const { jobId } = req.params;
+    await handleJobDetailRequest(req, res, jobId);
+  });
+
+  // POST /api/jobs/:jobId/rescan
+  app.post("/api/jobs/:jobId/rescan", async (req, res) => {
+    const { jobId } = req.params;
+    await handleJobRescan(req, res, jobId, dataDir, sendJson);
+  });
+
+  // POST /api/jobs/:jobId/restart
+  app.post("/api/jobs/:jobId/restart", async (req, res) => {
+    const { jobId } = req.params;
+    await handleJobRestart(req, res, jobId, dataDir, sendJson);
+  });
+
+  // POST /api/jobs/:jobId/stop
+  app.post("/api/jobs/:jobId/stop", async (req, res) => {
+    const { jobId } = req.params;
+    await handleJobStop(req, res, jobId, dataDir, sendJson);
+  });
+
+  // POST /api/jobs/:jobId/tasks/:taskId/start
+  app.post("/api/jobs/:jobId/tasks/:taskId/start", async (req, res) => {
+    const { jobId, taskId } = req.params;
+    await handleTaskStart(req, res, jobId, taskId, dataDir, sendJson);
+  });
+
+  // GET /api/jobs/:jobId/tasks/:taskId/files
+  app.get("/api/jobs/:jobId/tasks/:taskId/files", async (req, res) => {
+    const { jobId, taskId } = req.params;
+    const { type } = req.query;
+    await handleTaskFileListRequest(req, res, {
+      jobId,
+      taskId,
+      type,
+      dataDir,
+    });
+  });
+
+  // GET /api/jobs/:jobId/tasks/:taskId/file
+  app.get("/api/jobs/:jobId/tasks/:taskId/file", async (req, res) => {
+    const { jobId, taskId } = req.params;
+    const { type, filename } = req.query;
+    await handleTaskFileRequest(req, res, {
+      jobId,
+      taskId,
+      type,
+      filename,
+      dataDir,
+    });
+  });
+
+  // POST /api/ai/task-plan
+  app.post("/api/ai/task-plan", handleTaskPlan);
+
+  // POST /api/tasks/create
+  app.post("/api/tasks/create", handleTaskSave);
+
+  // Dev middleware (mount after all API routes)
+  if (viteServer && viteServer.middlewares) {
+    app.use(viteServer.middlewares);
+  } else {
+    // Production static serving
+    app.use("/public", express.static(path.join(__dirname, "public")));
+    app.use("/assets", express.static(path.join(__dirname, "dist", "assets")));
+    app.use(express.static(path.join(__dirname, "dist")));
+
+    // SPA fallback
+    app.get("*", (_, res) => {
+      res.sendFile(path.join(__dirname, "dist", "index.html"));
+    });
+  }
+
+  return app;
+}

package/src/ui/lib/analysis-lock.js

@@ -0,0 +1,67 @@
+/**
+ * In-memory lock for pipeline analysis operations.
+ * Ensures only one pipeline can be analyzed at a time.
+ */
+
+let currentLock = null;
+
+/**
+ * Attempt to acquire the analysis lock for a pipeline.
+ * @param {string} pipelineSlug - The pipeline identifier
+ * @returns {{ acquired: true } | { acquired: false, heldBy: string }}
+ */
+export function acquireLock(pipelineSlug) {
+  if (!pipelineSlug || typeof pipelineSlug !== "string") {
+    throw new Error(
+      `Invalid pipelineSlug: expected non-empty string, got ${typeof pipelineSlug}`
+    );
+  }
+
+  if (currentLock === null) {
+    currentLock = {
+      pipelineSlug,
+      startedAt: new Date(),
+    };
+    return { acquired: true };
+  }
+
+  return {
+    acquired: false,
+    heldBy: currentLock.pipelineSlug,
+  };
+}
+
+/**
+ * Release the analysis lock for a pipeline.
+ * @param {string} pipelineSlug - The pipeline identifier that holds the lock
+ * @throws {Error} If the lock is not held by this pipeline
+ */
+export function releaseLock(pipelineSlug) {
+  if (!pipelineSlug || typeof pipelineSlug !== "string") {
+    throw new Error(
+      `Invalid pipelineSlug: expected non-empty string, got ${typeof pipelineSlug}`
+    );
+  }
+
+  if (currentLock === null) {
+    throw new Error(
+      `Cannot release lock for '${pipelineSlug}': no lock is currently held`
+    );
+  }
+
+  if (currentLock.pipelineSlug !== pipelineSlug) {
+    throw new Error(
+      `Cannot release lock for '${pipelineSlug}': lock is held by '${currentLock.pipelineSlug}'`
+    );
+  }
+
+  currentLock = null;
+}
+
+/**
+ * Get the current lock status.
+ * @returns {{ pipelineSlug: string, startedAt: Date } | null}
+ */
+export function getLockStatus() {
+  return currentLock;
+}

package/src/ui/lib/sse.js

@@ -0,0 +1,30 @@
+export function streamSSE(res) {
+  console.log("[sse] Creating new SSE stream");
+
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection", "keep-alive");
+  res.flushHeaders();
+
+  console.log("[sse] SSE headers set and flushed");
+
+  return {
+    send(event, data) {
+      console.log("[sse] Sending event:", {
+        eventType: event,
+        hasData: !!data,
+        dataKeys: data ? Object.keys(data) : [],
+      });
+
+      const eventData = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+      res.write(eventData);
+
+      console.log("[sse] Event sent successfully");
+    },
+    end() {
+      console.log("[sse] Ending SSE stream");
+      res.end();
+      console.log("[sse] SSE stream ended");
+    },
+  };
+}