@ryanfw/prompt-orchestration-pipeline 0.0.1

package/src/ui/server.js

@@ -0,0 +1,230 @@
+/**
+ * Single Node.js server handling static files, API, and SSE
+ * Serves UI and provides real-time file change updates
+ */
+
+import http from "http";
+import fs from "fs";
+import path from "path";
+import url from "url";
+import { fileURLToPath } from "url";
+import { start as startWatcher, stop as stopWatcher } from "./watcher.js";
+import * as state from "./state.js";
+
+// Get __dirname equivalent in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Configuration
+const PORT = process.env.PORT || 4000;
+const WATCHED_PATHS = (process.env.WATCHED_PATHS || "pipeline-config,runs")
+  .split(",")
+  .map((p) => p.trim());
+const HEARTBEAT_INTERVAL = 30000; // 30 seconds
+
+// SSE clients management
+const sseClients = new Set();
+let heartbeatTimer = null;
+
+/**
+ * Send SSE message to a client
+ */
+function sendSSE(res, event, data) {
+  res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+}
+
+/**
+ * Broadcast state update to all SSE clients
+ */
+function broadcastStateUpdate(currentState) {
+  const deadClients = new Set();
+
+  sseClients.forEach((client) => {
+    try {
+      sendSSE(client, "state", currentState);
+    } catch (err) {
+      deadClients.add(client);
+    }
+  });
+
+  // Clean up dead connections
+  deadClients.forEach((client) => sseClients.delete(client));
+}
+
+/**
+ * Start heartbeat to keep connections alive
+ */
+function startHeartbeat() {
+  if (heartbeatTimer) clearInterval(heartbeatTimer);
+
+  heartbeatTimer = setInterval(() => {
+    const deadClients = new Set();
+
+    sseClients.forEach((client) => {
+      try {
+        client.write(":heartbeat\n\n");
+      } catch (err) {
+        deadClients.add(client);
+      }
+    });
+
+    deadClients.forEach((client) => sseClients.delete(client));
+  }, HEARTBEAT_INTERVAL);
+}
+
+/**
+ * Serve static files from public directory
+ */
+function serveStatic(res, filePath) {
+  const ext = path.extname(filePath);
+  const contentTypes = {
+    ".html": "text/html",
+    ".js": "application/javascript",
+    ".css": "text/css",
+  };
+
+  fs.readFile(filePath, (err, content) => {
+    if (err) {
+      res.writeHead(404);
+      res.end("Not Found");
+    } else {
+      res.writeHead(200, { "Content-Type": contentTypes[ext] || "text/plain" });
+      res.end(content);
+    }
+  });
+}
+
+/**
+ * Create and start the HTTP server
+ */
+function createServer() {
+  const server = http.createServer((req, res) => {
+    const parsedUrl = url.parse(req.url, true);
+    const pathname = parsedUrl.pathname;
+
+    // CORS headers for API endpoints
+    if (pathname.startsWith("/api/")) {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+    }
+
+    // Route: GET /api/state
+    if (pathname === "/api/state" && req.method === "GET") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(state.getState()));
+      return;
+    }
+
+    // Route: GET /api/events (SSE)
+    if (pathname === "/api/events" && req.method === "GET") {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Access-Control-Allow-Origin": "*",
+      });
+
+      // Send initial state
+      sendSSE(res, "state", state.getState());
+
+      // Add to clients
+      sseClients.add(res);
+
+      // Remove client on disconnect
+      req.on("close", () => {
+        sseClients.delete(res);
+      });
+
+      return;
+    }
+
+    // Serve static files
+    if (pathname === "/" || pathname === "/index.html") {
+      serveStatic(res, path.join(__dirname, "public", "index.html"));
+    } else if (pathname === "/app.js") {
+      serveStatic(res, path.join(__dirname, "public", "app.js"));
+    } else if (pathname === "/style.css") {
+      serveStatic(res, path.join(__dirname, "public", "style.css"));
+    } else {
+      res.writeHead(404);
+      res.end("Not Found");
+    }
+  });
+
+  return server;
+}
+
+/**
+ * Initialize file watcher
+ */
+let watcher = null;
+
+function initializeWatcher() {
+  state.setWatchedPaths(WATCHED_PATHS);
+
+  watcher = startWatcher(WATCHED_PATHS, (changes) => {
+    // Update state for each change
+    changes.forEach(({ path, type }) => {
+      state.recordChange(path, type);
+    });
+
+    // Broadcast updated state
+    broadcastStateUpdate(state.getState());
+  });
+}
+
+/**
+ * Start the server
+ */
+function start(customPort) {
+  const port = customPort || PORT;
+  const server = createServer();
+
+  server.listen(port, () => {
+    console.log(`Server running at http://localhost:${port}`);
+    console.log(`Watching paths: ${WATCHED_PATHS.join(", ")}`);
+
+    initializeWatcher();
+    startHeartbeat();
+  });
+
+  // Graceful shutdown
+  process.on("SIGINT", async () => {
+    console.log("\nShutting down gracefully...");
+
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    if (watcher) await stopWatcher(watcher);
+
+    sseClients.forEach((client) => client.end());
+    sseClients.clear();
+
+    server.close(() => {
+      console.log("Server closed");
+      process.exit(0);
+    });
+  });
+
+  return server;
+}
+
+// Export for testing
+export {
+  createServer,
+  start,
+  broadcastStateUpdate,
+  sseClients,
+  initializeWatcher,
+  state,
+};
+
+// Start server if run directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  start();
+}

package/src/ui/state.js

@@ -0,0 +1,67 @@
+/**
+ * Simple state manager for tracking file changes
+ * Maintains an in-memory state with change history
+ */
+
+const MAX_RECENT_CHANGES = 10;
+
+let state = {
+  updatedAt: new Date().toISOString(),
+  changeCount: 0,
+  recentChanges: [],
+  watchedPaths: [],
+};
+
+/**
+ * Get the current state
+ * @returns {Object} Current state object
+ */
+export function getState() {
+  return { ...state };
+}
+
+/**
+ * Record a file change event
+ * @param {string} path - File path that changed
+ * @param {string} type - Type of change: 'created', 'modified', or 'deleted'
+ * @returns {Object} Updated state
+ */
+export function recordChange(path, type) {
+  const timestamp = new Date().toISOString();
+
+  // Add to recent changes (FIFO)
+  const recentChanges = [
+    { path, type, timestamp },
+    ...state.recentChanges,
+  ].slice(0, MAX_RECENT_CHANGES);
+
+  // Update state
+  state = {
+    ...state,
+    updatedAt: timestamp,
+    changeCount: state.changeCount + 1,
+    recentChanges,
+  };
+
+  return getState();
+}
+
+/**
+ * Reset state to initial values
+ */
+export function reset() {
+  state = {
+    updatedAt: new Date().toISOString(),
+    changeCount: 0,
+    recentChanges: [],
+    watchedPaths: state.watchedPaths, // Preserve watched paths
+  };
+}
+
+/**
+ * Set the paths being watched
+ * @param {string[]} paths - Array of watched directory paths
+ */
+export function setWatchedPaths(paths) {
+  state.watchedPaths = [...paths];
+}

package/src/ui/watcher.js

@@ -0,0 +1,85 @@
+/**
+ * File watcher for monitoring pipeline directories
+ * Provides real-time file change notifications
+ */
+
+import chokidar from "chokidar";
+
+/**
+ * Start watching specified paths for file changes
+ * @param {string[]} paths - Array of directory paths to watch
+ * @param {Function} onChange - Callback function to handle file changes
+ * @param {Object} options - Configuration options
+ * @param {number} options.debounceMs - Debounce time in milliseconds (default: 200)
+ * @returns {Object} Watcher instance with close method
+ */
+export function start(paths, onChange, options = {}) {
+  const debounceMs = options.debounceMs || 200;
+  let debounceTimer = null;
+  let pendingChanges = [];
+
+  // Initialize chokidar watcher
+  const watcher = chokidar.watch(paths, {
+    ignored: /(^|[\/\\])(\.git|node_modules|dist)([\/\\]|$)/,
+    persistent: true,
+    ignoreInitial: true,
+  });
+
+  // Debounced change handler
+  const flushChanges = () => {
+    if (pendingChanges.length > 0) {
+      const changes = [...pendingChanges];
+      pendingChanges = [];
+      onChange(changes);
+    }
+  };
+
+  const scheduleFlush = () => {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(flushChanges, debounceMs);
+  };
+
+  // Handle file events
+  watcher.on("add", (path) => {
+    pendingChanges.push({ path, type: "created" });
+    scheduleFlush();
+  });
+
+  watcher.on("change", (path) => {
+    pendingChanges.push({ path, type: "modified" });
+    scheduleFlush();
+  });
+
+  watcher.on("unlink", (path) => {
+    pendingChanges.push({ path, type: "deleted" });
+    scheduleFlush();
+  });
+
+  // Return watcher with enhanced close method
+  return {
+    _chokidarWatcher: watcher,
+    _debounceTimer: debounceTimer,
+    close: async () => {
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      pendingChanges = [];
+      await watcher.close();
+    },
+  };
+}
+
+/**
+ * Stop watching files
+ * @param {Object} watcher - Watcher instance to stop
+ * @returns {Promise<void>}
+ */
+export async function stop(watcher) {
+  if (!watcher) {
+    return;
+  }
+  await watcher.close();
+}