ralphflow 0.2.0 → 0.4.0

package/dist/server-O6J52DZT.js

@@ -0,0 +1,323 @@
+import {
+  getAllLoopStates,
+  getDb,
+  listFlows,
+  loadConfig,
+  parseTracker,
+  resolveFlowDir
+} from "./chunk-GVOJO5IN.js";
+
+// src/dashboard/server.ts
+import { Hono as Hono2 } from "hono";
+import { cors } from "hono/cors";
+import { serve } from "@hono/node-server";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join3, dirname } from "path";
+import { fileURLToPath } from "url";
+import { WebSocketServer as WebSocketServer2 } from "ws";
+import chalk from "chalk";
+
+// src/dashboard/api.ts
+import { Hono } from "hono";
+import { readFileSync, writeFileSync, readdirSync, existsSync } from "fs";
+import { resolve } from "path";
+function createApiRoutes(cwd) {
+  const api = new Hono();
+  api.get("/api/apps", (c) => {
+    const flows = listFlows(cwd);
+    const apps = flows.map((appName) => {
+      const flowDir = resolveFlowDir(cwd, appName);
+      const config = loadConfig(flowDir);
+      const sortedLoops = Object.entries(config.loops).sort(([, a], [, b]) => a.order - b.order);
+      return {
+        appName,
+        appType: config.name,
+        description: config.description || "",
+        loops: sortedLoops.map(([key, loop]) => ({
+          key,
+          name: loop.name,
+          order: loop.order,
+          stages: loop.stages
+        }))
+      };
+    });
+    return c.json(apps);
+  });
+  api.get("/api/apps/:app/status", (c) => {
+    const appName = c.req.param("app");
+    const flowDir = resolveFlowDir(cwd, appName);
+    const config = loadConfig(flowDir);
+    const sortedLoops = Object.entries(config.loops).sort(([, a], [, b]) => a.order - b.order);
+    const statuses = sortedLoops.map(([key, loop]) => ({
+      key,
+      ...parseTracker(loop.tracker, flowDir, loop.name)
+    }));
+    return c.json(statuses);
+  });
+  api.get("/api/apps/:app/config", (c) => {
+    const appName = c.req.param("app");
+    const flowDir = resolveFlowDir(cwd, appName);
+    const config = loadConfig(flowDir);
+    return c.json(config);
+  });
+  api.get("/api/apps/:app/db", (c) => {
+    const appName = c.req.param("app");
+    const db = getDb(cwd);
+    const rows = getAllLoopStates(db, appName);
+    return c.json(rows);
+  });
+  api.get("/api/apps/:app/loops/:loop/prompt", (c) => {
+    const { app: appName, loop: loopKey } = c.req.param();
+    const flowDir = resolveFlowDir(cwd, appName);
+    const config = loadConfig(flowDir);
+    const loopConfig = config.loops[loopKey];
+    if (!loopConfig) return c.json({ error: `Loop "${loopKey}" not found` }, 404);
+    const promptPath = resolve(flowDir, loopConfig.prompt);
+    if (!validatePath(promptPath, cwd)) {
+      return c.json({ error: "Invalid path" }, 403);
+    }
+    if (!existsSync(promptPath)) {
+      return c.json({ error: "prompt.md not found" }, 404);
+    }
+    const content = readFileSync(promptPath, "utf-8");
+    return c.json({ path: loopConfig.prompt, content });
+  });
+  api.put("/api/apps/:app/loops/:loop/prompt", async (c) => {
+    const { app: appName, loop: loopKey } = c.req.param();
+    const flowDir = resolveFlowDir(cwd, appName);
+    const config = loadConfig(flowDir);
+    const loopConfig = config.loops[loopKey];
+    if (!loopConfig) return c.json({ error: `Loop "${loopKey}" not found` }, 404);
+    const promptPath = resolve(flowDir, loopConfig.prompt);
+    if (!validatePath(promptPath, cwd)) {
+      return c.json({ error: "Invalid path" }, 403);
+    }
+    const body = await c.req.json();
+    writeFileSync(promptPath, body.content, "utf-8");
+    return c.json({ ok: true });
+  });
+  api.get("/api/apps/:app/loops/:loop/tracker", (c) => {
+    const { app: appName, loop: loopKey } = c.req.param();
+    const flowDir = resolveFlowDir(cwd, appName);
+    const config = loadConfig(flowDir);
+    const loopConfig = config.loops[loopKey];
+    if (!loopConfig) return c.json({ error: `Loop "${loopKey}" not found` }, 404);
+    const trackerPath = resolve(flowDir, loopConfig.tracker);
+    if (!validatePath(trackerPath, cwd)) {
+      return c.json({ error: "Invalid path" }, 403);
+    }
+    if (!existsSync(trackerPath)) {
+      return c.json({ error: "tracker.md not found", content: "" }, 404);
+    }
+    const content = readFileSync(trackerPath, "utf-8");
+    return c.json({ path: loopConfig.tracker, content });
+  });
+  api.get("/api/apps/:app/loops/:loop/files", (c) => {
+    const { app: appName, loop: loopKey } = c.req.param();
+    const flowDir = resolveFlowDir(cwd, appName);
+    const config = loadConfig(flowDir);
+    const loopConfig = config.loops[loopKey];
+    if (!loopConfig) return c.json({ error: `Loop "${loopKey}" not found` }, 404);
+    const loopDir = resolve(flowDir, loopConfig.prompt, "..");
+    if (!validatePath(loopDir, cwd)) {
+      return c.json({ error: "Invalid path" }, 403);
+    }
+    if (!existsSync(loopDir)) {
+      return c.json({ files: [] });
+    }
+    const files = readdirSync(loopDir, { withFileTypes: true }).map((d) => ({
+      name: d.name,
+      isDirectory: d.isDirectory()
+    }));
+    return c.json({ files });
+  });
+  return api;
+}
+function validatePath(resolvedPath, cwd) {
+  const ralphFlowDir = resolve(cwd, ".ralph-flow");
+  return resolvedPath.startsWith(ralphFlowDir) && !resolvedPath.includes("..");
+}
+
+// src/dashboard/watcher.ts
+import { watch } from "chokidar";
+import { join as join2, relative, sep } from "path";
+import { WebSocket } from "ws";
+function setupWatcher(cwd, wss) {
+  const ralphFlowDir = join2(cwd, ".ralph-flow");
+  const debounceTimers = /* @__PURE__ */ new Map();
+  const watcher = watch(ralphFlowDir, {
+    ignoreInitial: true
+  });
+  watcher.on("change", (filePath) => {
+    if (!filePath.endsWith(".md") && !filePath.endsWith(".yaml")) return;
+    const existing = debounceTimers.get(filePath);
+    if (existing) clearTimeout(existing);
+    debounceTimers.set(filePath, setTimeout(() => {
+      debounceTimers.delete(filePath);
+      handleFileChange(filePath, cwd, wss);
+    }, 300));
+  });
+  let cachedDbState = "";
+  const dbPollInterval = setInterval(() => {
+    try {
+      const db = getDb(cwd);
+      const flows = listFlows(cwd);
+      const allStates = {};
+      for (const flow of flows) {
+        allStates[flow] = getAllLoopStates(db, flow);
+      }
+      const stateStr = JSON.stringify(allStates);
+      if (stateStr !== cachedDbState) {
+        cachedDbState = stateStr;
+        const fullStatus = buildFullStatus(cwd);
+        broadcast(wss, { type: "status:full", apps: fullStatus });
+      }
+    } catch {
+    }
+  }, 2e3);
+  wss.on("connection", (ws) => {
+    const fullStatus = buildFullStatus(cwd);
+    ws.send(JSON.stringify({ type: "status:full", apps: fullStatus }));
+  });
+  return {
+    close() {
+      watcher.close();
+      clearInterval(dbPollInterval);
+      for (const timer of debounceTimers.values()) clearTimeout(timer);
+      debounceTimers.clear();
+    }
+  };
+}
+function handleFileChange(filePath, cwd, wss) {
+  const ralphFlowDir = join2(cwd, ".ralph-flow");
+  const rel = relative(ralphFlowDir, filePath);
+  const parts = rel.split(sep);
+  if (parts.length < 2) return;
+  const appName = parts[0];
+  if (filePath.endsWith("tracker.md")) {
+    try {
+      const flowDir = resolveFlowDir(cwd, appName);
+      const config = loadConfig(flowDir);
+      for (const [key, loop] of Object.entries(config.loops)) {
+        const trackerFullPath = join2(flowDir, loop.tracker);
+        if (trackerFullPath === filePath) {
+          const status = parseTracker(loop.tracker, flowDir, loop.name);
+          broadcast(wss, {
+            type: "tracker:updated",
+            app: appName,
+            loop: key,
+            status: { key, ...status }
+          });
+          return;
+        }
+      }
+    } catch {
+    }
+  }
+  broadcast(wss, {
+    type: "file:changed",
+    app: appName,
+    path: rel
+  });
+}
+function buildFullStatus(cwd) {
+  const flows = listFlows(cwd);
+  return flows.map((appName) => {
+    try {
+      const flowDir = resolveFlowDir(cwd, appName);
+      const config = loadConfig(flowDir);
+      const sortedLoops = Object.entries(config.loops).sort(([, a], [, b]) => a.order - b.order);
+      return {
+        appName,
+        appType: config.name,
+        description: config.description || "",
+        loops: sortedLoops.map(([key, loop]) => ({
+          key,
+          name: loop.name,
+          order: loop.order,
+          stages: loop.stages,
+          status: parseTracker(loop.tracker, flowDir, loop.name)
+        }))
+      };
+    } catch {
+      return {
+        appName,
+        appType: "unknown",
+        description: "",
+        loops: []
+      };
+    }
+  });
+}
+function broadcast(wss, event) {
+  const data = JSON.stringify(event);
+  for (const client of wss.clients) {
+    if (client.readyState === WebSocket.OPEN) {
+      client.send(data);
+    }
+  }
+}
+
+// src/dashboard/server.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function resolveUiPath() {
+  const candidates = [
+    join3(__dirname, "..", "dashboard", "ui", "index.html"),
+    // dev: src/dashboard/ -> src/dashboard/ui/
+    join3(__dirname, "..", "src", "dashboard", "ui", "index.html")
+    // bundled: dist/ -> src/dashboard/ui/
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) return candidate;
+  }
+  throw new Error(
+    `Dashboard UI not found. Searched:
+${candidates.join("\n")}`
+  );
+}
+async function startDashboard(options) {
+  const { cwd, port = 4242 } = options;
+  const app = new Hono2();
+  app.use("*", cors({
+    origin: (origin) => origin || "*",
+    allowMethods: ["GET", "PUT", "POST", "DELETE"]
+  }));
+  const apiRoutes = createApiRoutes(cwd);
+  app.route("/", apiRoutes);
+  app.get("/", (c) => {
+    const htmlPath = resolveUiPath();
+    const html = readFileSync2(htmlPath, "utf-8");
+    return c.html(html);
+  });
+  const server = serve({
+    fetch: app.fetch,
+    port,
+    hostname: "127.0.0.1"
+  });
+  const wss = new WebSocketServer2({ noServer: true });
+  server.on("upgrade", (request, socket, head) => {
+    const url = new URL(request.url || "/", `http://${request.headers.host}`);
+    if (url.pathname === "/ws") {
+      wss.handleUpgrade(request, socket, head, (ws) => {
+        wss.emit("connection", ws, request);
+      });
+    } else {
+      socket.destroy();
+    }
+  });
+  const watcherHandle = setupWatcher(cwd, wss);
+  console.log();
+  console.log(chalk.bold(`  Dashboard ${chalk.dim("\u2192")} http://localhost:${port}`));
+  console.log(chalk.dim(`  Watching ${cwd}/.ralph-flow/`));
+  console.log();
+  return {
+    close() {
+      watcherHandle.close();
+      wss.close();
+      server.close();
+    }
+  };
+}
+export {
+  startDashboard
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ralphflow",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Multi-agent AI workflow orchestration framework for Claude Code. Define pipelines as loops, coordinate parallel agents, and ship structured work.",
   "type": "module",
   "bin": {
@@ -47,9 +47,13 @@
   },
   "files": [
     "dist/",
-    "src/templates/"
+    "src/templates/",
+    "src/dashboard/ui/"
   ],
   "dependencies": {
+    "@hono/node-server": "^1.19.11",
+    "@inquirer/prompts": "^8.3.0",
+    "better-sqlite3": "^12.6.2",
     "chalk": "^5.3.0",
     "chokidar": "^4.0.0",
     "cli-table3": "^0.6.5",
@@ -60,6 +64,7 @@
     "yaml": "^2.6.0"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.0.0",
     "@types/ws": "^8.5.0",
     "tsup": "^8.3.0",