ralphflow 0.4.0 → 0.5.0

package/dist/server-DOSLU36L.js

@@ -0,0 +1,821 @@
+import {
+  BUILT_IN_TEMPLATES,
+  copyTemplate,
+  createCustomTemplate,
+  deleteCustomTemplate,
+  deleteFlowState,
+  getAllLoopStates,
+  getAvailableTemplates,
+  getDb,
+  listCustomTemplates,
+  listFlows,
+  loadConfig,
+  parseTracker,
+  resolveFlowDir,
+  resolveTemplatePathWithCustom,
+  validateTemplateName
+} from "./chunk-TCCMQDVT.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 readFileSync3, existsSync as existsSync3 } from "fs";
+import { join as join4, dirname } from "path";
+import { fileURLToPath } from "url";
+import { WebSocketServer as WebSocketServer3 } from "ws";
+import chalk from "chalk";
+
+// src/dashboard/api.ts
+import { Hono } from "hono";
+import { readFileSync, writeFileSync, readdirSync, existsSync, rmSync, cpSync, mkdirSync, statSync } from "fs";
+import { join, resolve, basename, relative } from "path";
+import { randomUUID } from "crypto";
+import { WebSocket } from "ws";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var notifications = [];
+function broadcastWs(wss, event) {
+  if (!wss) return;
+  const data = JSON.stringify(event);
+  for (const client of wss.clients) {
+    if (client.readyState === WebSocket.OPEN) {
+      client.send(data);
+    }
+  }
+}
+function createApiRoutes(cwd, port = 4242, wss) {
+  const api = new Hono();
+  api.get("/api/context", (c) => {
+    return c.json({
+      cwd,
+      projectName: basename(cwd),
+      port
+    });
+  });
+  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,
+          multiAgent: !!(loop.multi_agent && typeof loop.multi_agent === "object" && loop.multi_agent.enabled),
+          model: loop.model || null
+        }))
+      };
+    });
+    return c.json(apps);
+  });
+  api.post("/api/apps", async (c) => {
+    const body = await c.req.json();
+    const { template, name } = body;
+    const allTemplateNames = [
+      ...BUILT_IN_TEMPLATES,
+      ...listCustomTemplates(cwd)
+    ];
+    if (!template || !allTemplateNames.includes(template)) {
+      return c.json({ error: `Invalid template. Available: ${allTemplateNames.join(", ")}` }, 400);
+    }
+    if (!name || name.trim().length === 0) {
+      return c.json({ error: "Name is required" }, 400);
+    }
+    if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+      return c.json({ error: 'Invalid name: must not contain "..", "/", or "\\"' }, 400);
+    }
+    const appName = name.trim();
+    const flowDir = join(cwd, ".ralph-flow", appName);
+    if (existsSync(flowDir)) {
+      return c.json({ error: `App "${appName}" already exists` }, 409);
+    }
+    const claudeMdPath = join(cwd, "CLAUDE.md");
+    const warning = existsSync(claudeMdPath) ? null : "No CLAUDE.md found in project root. Consider creating one for better Claude context.";
+    try {
+      copyTemplate(template, flowDir, cwd);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return c.json({ error: `Failed to create app: ${msg}` }, 500);
+    }
+    return c.json({
+      ok: true,
+      appName,
+      warning,
+      commands: [
+        `npx ralphflow run story --flow ${appName}`,
+        `npx ralphflow e2e --flow ${appName}`
+      ]
+    }, 201);
+  });
+  api.delete("/api/apps/:app", (c) => {
+    const appName = c.req.param("app");
+    if (appName.includes("..") || appName.includes("/") || appName.includes("\\")) {
+      return c.json({ error: 'Invalid name: must not contain "..", "/", or "\\"' }, 400);
+    }
+    const flowDir = join(cwd, ".ralph-flow", appName);
+    if (!existsSync(flowDir)) {
+      return c.json({ error: `App "${appName}" not found` }, 404);
+    }
+    rmSync(flowDir, { recursive: true, force: true });
+    try {
+      const db = getDb(cwd);
+      deleteFlowState(db, appName);
+    } catch {
+    }
+    for (let i = notifications.length - 1; i >= 0; i--) {
+      if (notifications[i].app === appName) {
+        notifications.splice(i, 1);
+      }
+    }
+    return c.json({ ok: true, appName });
+  });
+  api.post("/api/apps/:app/archive", (c) => {
+    const appName = c.req.param("app");
+    if (appName.includes("..") || appName.includes("/") || appName.includes("\\")) {
+      return c.json({ error: 'Invalid name: must not contain "..", "/", or "\\"' }, 400);
+    }
+    const flowDir = join(cwd, ".ralph-flow", appName);
+    if (!existsSync(flowDir)) {
+      return c.json({ error: `App "${appName}" not found` }, 404);
+    }
+    let config;
+    try {
+      config = loadConfig(flowDir);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return c.json({ error: `Failed to load config: ${msg}` }, 500);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const timestamp = now.toISOString().slice(0, 16).replace("T", "_").replace(":", "-");
+    const archivesBase = join(cwd, ".ralph-flow", ".archives", appName);
+    let archiveDir = join(archivesBase, timestamp);
+    let archiveTimestamp = timestamp;
+    if (existsSync(archiveDir)) {
+      let seq = 2;
+      while (existsSync(`${archiveDir}-${seq}`)) seq++;
+      archiveDir = `${archiveDir}-${seq}`;
+      archiveTimestamp = `${timestamp}-${seq}`;
+    }
+    try {
+      mkdirSync(archiveDir, { recursive: true });
+      cpSync(flowDir, archiveDir, { recursive: true });
+      let templateDir;
+      try {
+        templateDir = resolveTemplatePathWithCustom(config.name, cwd);
+      } catch {
+      }
+      for (const loop of Object.values(config.loops)) {
+        if (templateDir) {
+          const templateTracker = join(templateDir, "loops", loop.tracker);
+          const appTracker = join(flowDir, loop.tracker);
+          if (existsSync(templateTracker)) {
+            writeFileSync(appTracker, readFileSync(templateTracker, "utf-8"));
+          }
+        }
+        if (loop.data_files && templateDir) {
+          for (const dataFile of loop.data_files) {
+            const templateData = join(templateDir, "loops", dataFile);
+            const appData = join(flowDir, dataFile);
+            if (existsSync(templateData)) {
+              writeFileSync(appData, readFileSync(templateData, "utf-8"));
+            }
+          }
+        }
+        const loopDir = resolve(flowDir, loop.tracker, "..");
+        const agentsPath = join(loopDir, ".agents");
+        if (existsSync(agentsPath)) {
+          rmSync(agentsPath, { recursive: true, force: true });
+        }
+        if (loop.lock) {
+          const lockPath = join(flowDir, loop.lock.file);
+          if (existsSync(lockPath)) {
+            rmSync(lockPath);
+          }
+        }
+      }
+      try {
+        const db = getDb(cwd);
+        deleteFlowState(db, appName);
+      } catch {
+      }
+      for (let i = notifications.length - 1; i >= 0; i--) {
+        if (notifications[i].app === appName) {
+          notifications.splice(i, 1);
+        }
+      }
+      const archivePath = `.ralph-flow/.archives/${appName}/${archiveTimestamp}`;
+      return c.json({ ok: true, archivePath, timestamp: archiveTimestamp });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return c.json({ error: `Archive failed: ${msg}` }, 500);
+    }
+  });
+  api.get("/api/apps/:app/archives", (c) => {
+    const appName = c.req.param("app");
+    if (appName.includes("..") || appName.includes("/") || appName.includes("\\")) {
+      return c.json({ error: "Invalid name" }, 400);
+    }
+    const archivesDir = join(cwd, ".ralph-flow", ".archives", appName);
+    if (!existsSync(archivesDir)) {
+      return c.json([]);
+    }
+    const entries = readdirSync(archivesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
+      const archiveDir = join(archivesDir, d.name);
+      const summary = parseArchiveSummary(archiveDir);
+      const fileCount = countFiles(archiveDir);
+      return {
+        timestamp: d.name,
+        summary,
+        fileCount
+      };
+    }).sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    return c.json(entries);
+  });
+  api.get("/api/apps/:app/archives/:timestamp/files", (c) => {
+    const appName = c.req.param("app");
+    const timestamp = c.req.param("timestamp");
+    if (appName.includes("..") || appName.includes("/") || appName.includes("\\")) {
+      return c.json({ error: "Invalid name" }, 400);
+    }
+    if (timestamp.includes("..") || timestamp.includes("/") || timestamp.includes("\\")) {
+      return c.json({ error: "Invalid timestamp" }, 400);
+    }
+    const archiveDir = resolve(cwd, ".ralph-flow", ".archives", appName, timestamp);
+    if (!validatePath(archiveDir, cwd)) {
+      return c.json({ error: "Invalid path" }, 403);
+    }
+    if (!existsSync(archiveDir)) {
+      return c.json({ error: "Archive not found" }, 404);
+    }
+    const files = listFilesRecursive(archiveDir, archiveDir);
+    return c.json(files);
+  });
+  api.get("/api/apps/:app/archives/:timestamp/files/*", (c) => {
+    const appName = c.req.param("app");
+    const timestamp = c.req.param("timestamp");
+    const filePath = c.req.path.replace(`/api/apps/${encodeURIComponent(appName)}/archives/${encodeURIComponent(timestamp)}/files/`, "");
+    if (appName.includes("..") || appName.includes("/") || appName.includes("\\")) {
+      return c.json({ error: "Invalid name" }, 400);
+    }
+    if (timestamp.includes("..") || timestamp.includes("/") || timestamp.includes("\\")) {
+      return c.json({ error: "Invalid timestamp" }, 400);
+    }
+    if (!filePath || filePath.includes("..")) {
+      return c.json({ error: "Invalid file path" }, 400);
+    }
+    const fullPath = resolve(cwd, ".ralph-flow", ".archives", appName, timestamp, filePath);
+    if (!validatePath(fullPath, cwd)) {
+      return c.json({ error: "Invalid path" }, 403);
+    }
+    if (!existsSync(fullPath) || statSync(fullPath).isDirectory()) {
+      return c.json({ error: "File not found" }, 404);
+    }
+    const content = readFileSync(fullPath, "utf-8");
+    return c.json({ path: filePath, content });
+  });
+  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);
+    const configPath = join(flowDir, "ralphflow.yaml");
+    const rawYaml = existsSync(configPath) ? readFileSync(configPath, "utf-8") : "";
+    return c.json({ ...config, _rawYaml: rawYaml });
+  });
+  api.put("/api/apps/:app/config/model", async (c) => {
+    const appName = c.req.param("app");
+    const flowDir = resolveFlowDir(cwd, appName);
+    const configPath = join(flowDir, "ralphflow.yaml");
+    if (!existsSync(configPath)) {
+      return c.json({ error: "ralphflow.yaml not found" }, 404);
+    }
+    const body = await c.req.json();
+    const { loop: loopKey, model } = body;
+    if (!loopKey) {
+      return c.json({ error: "loop is required" }, 400);
+    }
+    const rawYaml = readFileSync(configPath, "utf-8");
+    const config = parseYaml(rawYaml);
+    if (!config.loops || !config.loops[loopKey]) {
+      return c.json({ error: `Loop "${loopKey}" not found in config` }, 404);
+    }
+    if (model === null || model === "") {
+      delete config.loops[loopKey].model;
+    } else {
+      config.loops[loopKey].model = model;
+    }
+    writeFileSync(configPath, stringifyYaml(config, { lineWidth: 0 }), "utf-8");
+    return c.json({ ok: true, loop: loopKey, model: model || null });
+  });
+  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 });
+  });
+  api.get("/api/templates", (c) => {
+    return c.json(getAvailableTemplates(cwd));
+  });
+  api.post("/api/templates", async (c) => {
+    let definition;
+    try {
+      definition = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON body" }, 400);
+    }
+    if (!definition.name) {
+      return c.json({ error: "Template name is required" }, 400);
+    }
+    const validation = validateTemplateName(definition.name);
+    if (!validation.valid) {
+      return c.json({ error: validation.error }, 400);
+    }
+    if (!definition.loops || !Array.isArray(definition.loops) || definition.loops.length === 0) {
+      return c.json({ error: "At least one loop is required" }, 400);
+    }
+    for (let i = 0; i < definition.loops.length; i++) {
+      const loop = definition.loops[i];
+      if (!loop.name) {
+        return c.json({ error: `Loop ${i + 1}: name is required` }, 400);
+      }
+      if (!loop.stages || !Array.isArray(loop.stages) || loop.stages.length === 0) {
+        return c.json({ error: `Loop "${loop.name}": at least one stage is required` }, 400);
+      }
+      if (!loop.completion) {
+        return c.json({ error: `Loop "${loop.name}": completion string is required` }, 400);
+      }
+    }
+    const customDir = join(cwd, ".ralph-flow", ".templates", definition.name);
+    if (existsSync(customDir)) {
+      return c.json({ error: `Template "${definition.name}" already exists` }, 409);
+    }
+    try {
+      createCustomTemplate(cwd, definition);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return c.json({ error: `Failed to create template: ${msg}` }, 500);
+    }
+    return c.json({
+      ok: true,
+      templateName: definition.name,
+      message: `Template "${definition.name}" created successfully`
+    }, 201);
+  });
+  api.delete("/api/templates/:name", (c) => {
+    const name = c.req.param("name");
+    if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+      return c.json({ error: 'Invalid name: must not contain "..", "/", or "\\"' }, 400);
+    }
+    if (BUILT_IN_TEMPLATES.includes(name)) {
+      return c.json({ error: "Cannot delete built-in templates" }, 403);
+    }
+    try {
+      deleteCustomTemplate(cwd, name);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("not found")) {
+        return c.json({ error: msg }, 404);
+      }
+      return c.json({ error: msg }, 500);
+    }
+    return c.json({ ok: true, templateName: name });
+  });
+  api.post("/api/notification", async (c) => {
+    const app = c.req.query("app") || "unknown";
+    const loop = c.req.query("loop") || "unknown";
+    let payload = {};
+    try {
+      payload = await c.req.json();
+    } catch {
+    }
+    const notification = {
+      id: randomUUID(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      app,
+      loop,
+      payload
+    };
+    notifications.push(notification);
+    broadcastWs(wss, { type: "notification:attention", notification });
+    return c.json(notification, 200);
+  });
+  api.get("/api/notifications", (c) => {
+    return c.json(notifications);
+  });
+  api.delete("/api/notification/:id", (c) => {
+    const id = c.req.param("id");
+    const idx = notifications.findIndex((n) => n.id === id);
+    if (idx === -1) {
+      return c.json({ error: "Notification not found" }, 404);
+    }
+    notifications.splice(idx, 1);
+    broadcastWs(wss, { type: "notification:dismissed", id });
+    return c.json({ ok: true });
+  });
+  return api;
+}
+function validatePath(resolvedPath, cwd) {
+  const ralphFlowDir = resolve(cwd, ".ralph-flow");
+  return resolvedPath.startsWith(ralphFlowDir) && !resolvedPath.includes("..");
+}
+function parseArchiveSummary(archiveDir) {
+  let storyCount = 0;
+  let taskCount = 0;
+  const mdFiles = listFilesRecursive(archiveDir, archiveDir).filter((f) => f.path.endsWith(".md"));
+  for (const file of mdFiles) {
+    try {
+      const content = readFileSync(join(archiveDir, file.path), "utf-8");
+      const storyMatches = content.match(/^## STORY-\d+:/gm);
+      if (storyMatches) storyCount += storyMatches.length;
+      const taskMatches = content.match(/^## TASK-\d+:/gm);
+      if (taskMatches) taskCount += taskMatches.length;
+    } catch {
+    }
+  }
+  return { storyCount, taskCount };
+}
+function countFiles(dir) {
+  let count = 0;
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      count += countFiles(join(dir, entry.name));
+    } else {
+      count++;
+    }
+  }
+  return count;
+}
+function listFilesRecursive(dir, baseDir) {
+  const results = [];
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    const relPath = relative(baseDir, fullPath);
+    if (entry.isDirectory()) {
+      results.push(...listFilesRecursive(fullPath, baseDir));
+    } else {
+      results.push({ path: relPath, isDirectory: false });
+    }
+  }
+  return results;
+}
+
+// src/dashboard/watcher.ts
+import { watch } from "chokidar";
+import { join as join2, relative as relative2, sep } from "path";
+import { WebSocket as WebSocket2 } 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 = relative2(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 === WebSocket2.OPEN) {
+      client.send(data);
+    }
+  }
+}
+
+// src/dashboard/hooks.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+var RALPHFLOW_MARKER = "# ralphflow-managed";
+function settingsPath(cwd) {
+  return join3(cwd, ".claude", "settings.local.json");
+}
+function readSettings(cwd) {
+  const path = settingsPath(cwd);
+  if (!existsSync2(path)) return {};
+  try {
+    const raw = readFileSync2(path, "utf-8").trim();
+    if (!raw) return {};
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function writeSettings(cwd, settings) {
+  const dir = join3(cwd, ".claude");
+  mkdirSync2(dir, { recursive: true });
+  writeFileSync2(settingsPath(cwd), JSON.stringify(settings, null, 2) + "\n", "utf-8");
+}
+function buildHookCommand(port) {
+  return `cat | curl --connect-timeout 2 --max-time 5 -s -X POST "http://127.0.0.1:${port}/api/notification?app=$RALPHFLOW_APP&loop=$RALPHFLOW_LOOP" -H 'Content-Type: application/json' -d @- ${RALPHFLOW_MARKER}`;
+}
+function isRalphFlowHook(entry) {
+  return entry.command?.includes(RALPHFLOW_MARKER) ?? false;
+}
+function installNotificationHook(cwd, port) {
+  const settings = readSettings(cwd);
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  const notificationHooks = settings.hooks.Notification ?? [];
+  const cleaned = notificationHooks.map((matcher) => ({
+    ...matcher,
+    hooks: matcher.hooks.filter((h) => !isRalphFlowHook(h))
+  })).filter((matcher) => matcher.hooks.length > 0);
+  cleaned.push({
+    matcher: "",
+    hooks: [{ type: "command", command: buildHookCommand(port) }]
+  });
+  settings.hooks.Notification = cleaned;
+  writeSettings(cwd, settings);
+}
+function removeNotificationHook(cwd) {
+  const path = settingsPath(cwd);
+  if (!existsSync2(path)) return;
+  const settings = readSettings(cwd);
+  if (!settings.hooks?.Notification) return;
+  settings.hooks.Notification = settings.hooks.Notification.map((matcher) => ({
+    ...matcher,
+    hooks: matcher.hooks.filter((h) => !isRalphFlowHook(h))
+  })).filter((matcher) => matcher.hooks.length > 0);
+  if (settings.hooks.Notification.length === 0) {
+    delete settings.hooks.Notification;
+  }
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+  writeSettings(cwd, settings);
+}
+
+// src/dashboard/server.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function resolveUiPath() {
+  const candidates = [
+    join4(__dirname, "..", "dashboard", "ui", "index.html"),
+    // dev: src/dashboard/ -> src/dashboard/ui/
+    join4(__dirname, "..", "src", "dashboard", "ui", "index.html")
+    // bundled: dist/ -> src/dashboard/ui/
+  ];
+  for (const candidate of candidates) {
+    if (existsSync3(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();
+  const wss = new WebSocketServer3({ noServer: true });
+  app.use("*", cors({
+    origin: (origin) => origin || "*",
+    allowMethods: ["GET", "PUT", "POST", "DELETE"]
+  }));
+  const apiRoutes = createApiRoutes(cwd, port, wss);
+  app.route("/", apiRoutes);
+  app.get("/", (c) => {
+    const htmlPath = resolveUiPath();
+    const html = readFileSync3(htmlPath, "utf-8");
+    return c.html(html);
+  });
+  const server = serve({
+    fetch: app.fetch,
+    port,
+    hostname: "127.0.0.1"
+  });
+  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);
+  try {
+    installNotificationHook(cwd, port);
+    console.log(chalk.dim(`  Configured Claude hook \u2192 .claude/settings.local.json`));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(chalk.yellow(`  \u26A0 Could not configure Claude hook: ${msg}`));
+  }
+  console.log();
+  console.log(chalk.bold(`  Dashboard ${chalk.dim("\u2192")} http://localhost:${port}`));
+  console.log(chalk.dim(`  Watching ${cwd}/.ralph-flow/`));
+  console.log();
+  let closed = false;
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    watcherHandle.close();
+    wss.close();
+    server.close();
+    try {
+      removeNotificationHook(cwd);
+      console.log(chalk.dim("  Removed Claude hook"));
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(chalk.yellow(`  \u26A0 Could not remove Claude hook: ${msg}`));
+    }
+  };
+  const onSignal = () => {
+    close();
+    process.exit();
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  process.on("exit", () => {
+    if (!closed) {
+      try {
+        removeNotificationHook(cwd);
+      } catch {
+      }
+    }
+  });
+  return { close };
+}
+export {
+  startDashboard
+};