agentflow-dashboard 0.3.0 → 0.3.1

package/dist/server.cjs

@@ -0,0 +1,1350 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  DashboardServer: () => DashboardServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_express = __toESM(require("express"), 1);
+var fs3 = __toESM(require("fs"), 1);
+var import_http = require("http");
+var path3 = __toESM(require("path"), 1);
+var import_url = require("url");
+var import_ws = require("ws");
+var import_agentflow_core3 = require("agentflow-core");
+
+// src/stats.ts
+var import_agentflow_core = require("agentflow-core");
+var AgentStats = class {
+  agentMetrics = /* @__PURE__ */ new Map();
+  processedTraces = /* @__PURE__ */ new Set();
+  processTrace(trace) {
+    const traceKey = `${trace.filename || trace.agentId}-${trace.startTime}`;
+    if (this.processedTraces.has(traceKey)) {
+      return;
+    }
+    this.processedTraces.add(traceKey);
+    const agentId = trace.agentId;
+    let metrics = this.agentMetrics.get(agentId);
+    if (!metrics) {
+      metrics = {
+        agentId,
+        totalExecutions: 0,
+        successfulExecutions: 0,
+        failedExecutions: 0,
+        successRate: 0,
+        avgExecutionTime: 0,
+        lastExecution: 0,
+        triggers: {},
+        recentActivity: []
+      };
+      this.agentMetrics.set(agentId, metrics);
+    }
+    const analysis = this.analyzeExecution(trace);
+    metrics.totalExecutions++;
+    metrics.lastExecution = Math.max(metrics.lastExecution, trace.startTime);
+    const trigger = trace.trigger || "unknown";
+    metrics.triggers[trigger] = (metrics.triggers[trigger] || 0) + 1;
+    if (analysis.success) {
+      metrics.successfulExecutions++;
+    } else {
+      metrics.failedExecutions++;
+    }
+    metrics.successRate = metrics.successfulExecutions / metrics.totalExecutions * 100;
+    if (analysis.executionTime > 0) {
+      const currentAvg = metrics.avgExecutionTime;
+      const count = metrics.totalExecutions;
+      metrics.avgExecutionTime = (currentAvg * (count - 1) + analysis.executionTime) / count;
+    }
+    metrics.recentActivity.push({
+      timestamp: trace.startTime,
+      success: analysis.success,
+      executionTime: analysis.executionTime,
+      trigger
+    });
+    if (metrics.recentActivity.length > 100) {
+      metrics.recentActivity = metrics.recentActivity.slice(-100);
+    }
+    metrics.recentActivity.sort((a, b) => b.timestamp - a.timestamp);
+  }
+  analyzeExecution(trace) {
+    try {
+      const stats = (0, import_agentflow_core.getStats)(trace);
+      const failures = (0, import_agentflow_core.getFailures)(trace);
+      const hungNodes = (0, import_agentflow_core.getHungNodes)(trace);
+      return {
+        success: failures.length === 0 && hungNodes.length === 0,
+        executionTime: stats.duration || 0,
+        nodeCount: stats.totalNodes || 0,
+        failureCount: failures.length,
+        hungCount: hungNodes.length
+      };
+    } catch (error) {
+      console.warn("Error analyzing trace with AgentFlow:", error);
+      const nodes = trace.nodes instanceof Map ? Array.from(trace.nodes.values()) : [];
+      const failedNodes = nodes.filter((node) => node.status === "failed").length;
+      return {
+        success: failedNodes === 0,
+        executionTime: 0,
+        nodeCount: nodes.length,
+        failureCount: failedNodes,
+        hungCount: 0
+      };
+    }
+  }
+  getAgentStats(agentId) {
+    return this.agentMetrics.get(agentId);
+  }
+  getAgentsList() {
+    return Array.from(this.agentMetrics.values()).sort((a, b) => b.lastExecution - a.lastExecution);
+  }
+  getGlobalStats() {
+    const agents = Array.from(this.agentMetrics.values());
+    const now = Date.now();
+    const oneHourAgo = now - 60 * 60 * 1e3;
+    const totalExecutions = agents.reduce((sum, agent) => sum + agent.totalExecutions, 0);
+    const totalSuccessful = agents.reduce((sum, agent) => sum + agent.successfulExecutions, 0);
+    const globalSuccessRate = totalExecutions > 0 ? totalSuccessful / totalExecutions * 100 : 0;
+    const activeAgents = agents.filter((agent) => agent.lastExecution > oneHourAgo).length;
+    const topAgents = agents.slice().sort((a, b) => b.totalExecutions - a.totalExecutions).slice(0, 10).map((agent) => ({
+      agentId: agent.agentId,
+      executionCount: agent.totalExecutions,
+      successRate: agent.successRate
+    }));
+    const recentActivity = [];
+    for (const agent of agents) {
+      for (const activity of agent.recentActivity.slice(0, 20)) {
+        recentActivity.push({
+          timestamp: activity.timestamp,
+          agentId: agent.agentId,
+          success: activity.success,
+          trigger: activity.trigger
+        });
+      }
+    }
+    recentActivity.sort((a, b) => b.timestamp - a.timestamp);
+    recentActivity.splice(200);
+    return {
+      totalAgents: agents.length,
+      totalExecutions,
+      globalSuccessRate,
+      activeAgents,
+      topAgents,
+      recentActivity
+    };
+  }
+  getPerformanceSummary() {
+    const global = this.getGlobalStats();
+    const agents = this.getAgentsList();
+    return {
+      overview: {
+        totalAgents: global.totalAgents,
+        totalExecutions: global.totalExecutions,
+        successRate: Math.round(global.globalSuccessRate * 100) / 100,
+        activeAgents: global.activeAgents
+      },
+      topPerformers: agents.slice(0, 5).map((agent) => ({
+        agentId: agent.agentId,
+        executions: agent.totalExecutions,
+        successRate: Math.round(agent.successRate * 100) / 100,
+        avgTime: Math.round(agent.avgExecutionTime * 100) / 100
+      })),
+      recentTrends: this.analyzeRecentTrends()
+    };
+  }
+  analyzeRecentTrends() {
+    const agents = Array.from(this.agentMetrics.values());
+    const now = Date.now();
+    const oneHourAgo = now - 60 * 60 * 1e3;
+    let recentExecutions = 0;
+    let recentFailures = 0;
+    for (const agent of agents) {
+      for (const activity of agent.recentActivity) {
+        if (activity.timestamp > oneHourAgo) {
+          recentExecutions++;
+          if (!activity.success) {
+            recentFailures++;
+          }
+        }
+      }
+    }
+    return {
+      hourlyExecutions: recentExecutions,
+      hourlyFailures: recentFailures,
+      hourlySuccessRate: recentExecutions > 0 ? Math.round((recentExecutions - recentFailures) / recentExecutions * 1e4) / 100 : 0
+    };
+  }
+  cleanup() {
+    const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1e3;
+    for (const [agentId, metrics] of this.agentMetrics.entries()) {
+      metrics.recentActivity = metrics.recentActivity.filter(
+        (activity) => activity.timestamp > cutoff
+      );
+      if (metrics.lastExecution < cutoff) {
+        this.agentMetrics.delete(agentId);
+      }
+    }
+    console.log(`Cleaned up old metrics, ${this.agentMetrics.size} agents remaining`);
+  }
+};
+
+// src/watcher.ts
+var import_agentflow_core2 = require("agentflow-core");
+var import_chokidar = __toESM(require("chokidar"), 1);
+var import_events = require("events");
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var TraceWatcher = class extends import_events.EventEmitter {
+  watchers = [];
+  traces = /* @__PURE__ */ new Map();
+  tracesDir;
+  dataDirs;
+  allWatchDirs;
+  constructor(tracesDirOrOptions) {
+    super();
+    if (typeof tracesDirOrOptions === "string") {
+      this.tracesDir = path.resolve(tracesDirOrOptions);
+      this.dataDirs = [];
+    } else {
+      this.tracesDir = path.resolve(tracesDirOrOptions.tracesDir);
+      this.dataDirs = (tracesDirOrOptions.dataDirs || []).map((d) => path.resolve(d));
+    }
+    this.allWatchDirs = [this.tracesDir, ...this.dataDirs];
+    this.ensureTracesDir();
+    this.loadExistingFiles();
+    this.startWatching();
+  }
+  ensureTracesDir() {
+    if (!fs.existsSync(this.tracesDir)) {
+      fs.mkdirSync(this.tracesDir, { recursive: true });
+      console.log(`Created traces directory: ${this.tracesDir}`);
+    }
+  }
+  loadExistingFiles() {
+    let totalFiles = 0;
+    for (const dir of this.allWatchDirs) {
+      if (!fs.existsSync(dir)) continue;
+      try {
+        const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json") || f.endsWith(".jsonl"));
+        totalFiles += files.length;
+        for (const file of files) {
+          this.loadFile(path.join(dir, file));
+        }
+      } catch (error) {
+        console.error(`Error scanning directory ${dir}:`, error);
+      }
+    }
+    console.log(`Scanned ${this.allWatchDirs.length} directories, loaded ${this.traces.size} items from ${totalFiles} files`);
+  }
+  /** Load a .json trace, .jsonl session file, or .log file. */
+  loadFile(filePath) {
+    if (filePath.endsWith(".jsonl")) {
+      return this.loadSessionFile(filePath);
+    }
+    if (filePath.endsWith(".log") || filePath.endsWith(".trace")) {
+      return this.loadLogFile(filePath);
+    }
+    return this.loadTraceFile(filePath);
+  }
+  loadLogFile(filePath) {
+    try {
+      const content = fs.readFileSync(filePath, "utf8");
+      const filename = path.basename(filePath);
+      const stats = fs.statSync(filePath);
+      const traces = this.parseUniversalLog(content, filename, filePath);
+      for (let i = 0; i < traces.length; i++) {
+        const trace = traces[i];
+        trace.filename = filename;
+        trace.lastModified = stats.mtime.getTime();
+        trace.sourceType = "trace";
+        trace.sourceDir = path.dirname(filePath);
+        const key = traces.length === 1 ? this.traceKey(filePath) : `${this.traceKey(filePath)}-${i}`;
+        this.traces.set(key, trace);
+      }
+      return traces.length > 0;
+    } catch (error) {
+      console.error(`Error loading log file ${filePath}:`, error);
+      return false;
+    }
+  }
+  /** Universal log parser - detects agent activities from any system */
+  parseUniversalLog(content, filename, filePath) {
+    const lines = content.split("\n").filter((line) => line.trim());
+    const activities = /* @__PURE__ */ new Map();
+    for (const line of lines) {
+      const activity = this.detectActivityPattern(line);
+      if (!activity) continue;
+      const sessionId = this.extractSessionIdentifier(activity);
+      if (!activities.has(sessionId)) {
+        activities.set(sessionId, {
+          id: sessionId,
+          rootNodeId: "",
+          agentId: this.detectAgentIdentifier(activity, filename, filePath),
+          name: this.generateActivityName(activity, sessionId),
+          trigger: this.detectTrigger(activity),
+          startTime: activity.timestamp,
+          endTime: activity.timestamp,
+          status: "completed",
+          nodes: {},
+          edges: [],
+          events: [],
+          metadata: { sessionId, source: filename }
+        });
+      }
+      const session = activities.get(sessionId);
+      this.addActivityNode(session, activity);
+      if (activity.timestamp > session.endTime) {
+        session.endTime = activity.timestamp;
+      }
+    }
+    const traces = Array.from(activities.values()).filter(
+      (session) => Object.keys(session.nodes).length > 0
+    );
+    if (traces.length === 0) {
+      const stats = fs.statSync(filePath);
+      traces.push({
+        id: "",
+        rootNodeId: "root",
+        nodes: {
+          "root": {
+            id: "root",
+            type: "log-file",
+            name: filename,
+            status: "completed",
+            startTime: stats.mtime.getTime(),
+            endTime: stats.mtime.getTime(),
+            metadata: { lineCount: lines.length, path: filePath }
+          }
+        },
+        edges: [],
+        startTime: stats.mtime.getTime(),
+        endTime: stats.mtime.getTime(),
+        status: "completed",
+        trigger: "file",
+        agentId: this.extractAgentFromPath(filePath),
+        events: [],
+        metadata: { type: "file-trace" }
+      });
+    }
+    return traces;
+  }
+  /** Detect activity patterns in log lines using universal heuristics */
+  detectActivityPattern(line) {
+    let timestamp = this.extractTimestamp(line);
+    let level = this.extractLogLevel(line);
+    let action = this.extractAction(line);
+    let kvPairs = this.extractKeyValuePairs(line);
+    if (!timestamp) {
+      const jsonMatch = line.match(/\{.*\}/);
+      if (jsonMatch) {
+        try {
+          const parsed = JSON.parse(jsonMatch[0]);
+          timestamp = this.parseTimestamp(parsed.timestamp || parsed.time || parsed.ts) || Date.now();
+          level = parsed.level || parsed.severity || "info";
+          action = parsed.action || parsed.event || parsed.message || "";
+          kvPairs = parsed;
+        } catch {
+        }
+      }
+    }
+    if (!timestamp) {
+      const kvMatches = line.match(/(\w+)=([^\s]+)/g);
+      if (kvMatches && kvMatches.length >= 2) {
+        const pairs = {};
+        kvMatches.forEach((match) => {
+          const [key, value] = match.split("=", 2);
+          pairs[key] = this.parseValue(value);
+        });
+        timestamp = this.parseTimestamp(pairs.timestamp || pairs.time) || Date.now();
+        level = pairs.level || "info";
+        action = pairs.action || pairs.event || "";
+        kvPairs = pairs;
+      }
+    }
+    if (!timestamp) {
+      const logMatch = line.match(/^(\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}[.\d]*Z?)\s+(\w+)?\s*:?\s*(.+)/);
+      if (logMatch) {
+        timestamp = new Date(logMatch[1]).getTime();
+        level = logMatch[2] || "info";
+        action = logMatch[3] || "";
+      }
+    }
+    if (!timestamp) return null;
+    return {
+      timestamp,
+      level: (level == null ? void 0 : level.toLowerCase()) || "info",
+      action,
+      component: this.detectComponent(action, kvPairs),
+      operation: this.detectOperation(action, kvPairs),
+      ...kvPairs
+    };
+  }
+  extractTimestamp(line) {
+    const coloredMatch = line.match(/^\[2m(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z)\[0m/);
+    if (coloredMatch) return new Date(coloredMatch[1]).getTime();
+    const isoMatch = line.match(/(\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}[.\d]*Z?)/);
+    if (isoMatch) return new Date(isoMatch[1]).getTime();
+    return null;
+  }
+  extractLogLevel(line) {
+    const coloredMatch = line.match(/\[\[(\d+)m\[\[1m(\w+)\s*\[0m\]/);
+    if (coloredMatch) return coloredMatch[2].toLowerCase();
+    const levelMatch = line.match(/\b(debug|info|warn|warning|error|fatal|trace)\b/i);
+    return levelMatch ? levelMatch[1].toLowerCase() : null;
+  }
+  extractAction(line) {
+    const coloredMatch = line.match(/\[1m([^\[]+?)\s*\[0m/);
+    if (coloredMatch) return coloredMatch[1].trim();
+    const afterLevel = line.replace(/^.*?(debug|info|warn|warning|error|fatal|trace)\s*:?\s*/i, "");
+    return afterLevel.split(" ")[0] || "";
+  }
+  extractKeyValuePairs(line) {
+    const pairs = {};
+    const coloredRegex = /\[36m(\w+)\[0m=\[35m([^\[]+?)\[0m/g;
+    let match;
+    while ((match = coloredRegex.exec(line)) !== null) {
+      pairs[match[1]] = this.parseValue(match[2]);
+    }
+    if (Object.keys(pairs).length === 0) {
+      const kvRegex = /(\w+)=([^\s]+)/g;
+      while ((match = kvRegex.exec(line)) !== null) {
+        pairs[match[1]] = this.parseValue(match[2]);
+      }
+    }
+    return pairs;
+  }
+  parseValue(value) {
+    if (value.match(/^\d+$/)) return parseInt(value);
+    if (value.match(/^\d+\.\d+$/)) return parseFloat(value);
+    if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+    if (value.startsWith('"') && value.endsWith('"')) return value.slice(1, -1);
+    return value;
+  }
+  parseTimestamp(value) {
+    if (!value) return null;
+    if (typeof value === "number") return value;
+    try {
+      return new Date(value).getTime();
+    } catch {
+      return null;
+    }
+  }
+  detectComponent(action, kvPairs) {
+    if (action.includes(".")) return action.split(".")[0];
+    if (kvPairs.component) return kvPairs.component;
+    if (kvPairs.service) return kvPairs.service;
+    if (kvPairs.module) return kvPairs.module;
+    return "unknown";
+  }
+  detectOperation(action, kvPairs) {
+    if (action.includes(".")) return action.split(".").slice(1).join(".");
+    if (kvPairs.operation) return kvPairs.operation;
+    if (kvPairs.method) return kvPairs.method;
+    return action || "activity";
+  }
+  extractSessionIdentifier(activity) {
+    return activity.run_id || activity.session_id || activity.request_id || activity.trace_id || activity.sweep_id || activity.transaction_id || "default";
+  }
+  detectAgentIdentifier(activity, filename, filePath) {
+    if (activity.component !== "unknown") {
+      const pathAgent = this.extractAgentFromPath(filePath);
+      if (pathAgent !== activity.component) {
+        return `${pathAgent}-${activity.component}`;
+      }
+      return activity.component;
+    }
+    return this.extractAgentFromPath(filePath);
+  }
+  extractAgentFromPath(filePath) {
+    const filename = path.basename(filePath, path.extname(filePath));
+    const pathParts = filePath.split(path.sep);
+    for (const part of pathParts.reverse()) {
+      if (part.match(/agent|worker|service|daemon|bot|ai|llm/i)) {
+        return part;
+      }
+    }
+    return filename;
+  }
+  generateActivityName(activity, sessionId) {
+    const component = activity.component !== "unknown" ? activity.component : "Activity";
+    const operation = activity.operation !== "activity" ? `: ${activity.operation}` : "";
+    return `${component}${operation} (${sessionId})`;
+  }
+  detectTrigger(activity) {
+    var _a, _b;
+    if (activity.trigger) return activity.trigger;
+    if (activity.method && activity.url) return "api-call";
+    if ((_a = activity.operation) == null ? void 0 : _a.includes("start")) return "startup";
+    if ((_b = activity.operation) == null ? void 0 : _b.includes("invoke")) return "invocation";
+    return "event";
+  }
+  addActivityNode(session, activity) {
+    const nodeId = `${activity.component}-${activity.operation}-${activity.timestamp}`;
+    const node = {
+      id: nodeId,
+      type: activity.component,
+      name: `${activity.component}: ${activity.operation}`,
+      status: this.getUniversalNodeStatus(activity),
+      startTime: activity.timestamp,
+      endTime: activity.timestamp,
+      metadata: activity
+    };
+    session.nodes[nodeId] = node;
+    if (!session.rootNodeId) {
+      session.rootNodeId = nodeId;
+    }
+  }
+  getUniversalNodeStatus(activity) {
+    var _a, _b;
+    if (activity.level === "error" || activity.level === "fatal") return "failed";
+    if (activity.level === "warn" || activity.level === "warning") return "warning";
+    if ((_a = activity.operation) == null ? void 0 : _a.match(/start|begin|init/i)) return "running";
+    if ((_b = activity.operation) == null ? void 0 : _b.match(/complete|finish|end|done/i)) return "completed";
+    return "completed";
+  }
+  loadTraceFile(filePath) {
+    try {
+      const content = fs.readFileSync(filePath, "utf8");
+      const graph = (0, import_agentflow_core2.loadGraph)(content);
+      const filename = path.basename(filePath);
+      const stats = fs.statSync(filePath);
+      graph.filename = filename;
+      graph.lastModified = stats.mtime.getTime();
+      graph.sourceType = "trace";
+      graph.sourceDir = path.dirname(filePath);
+      this.traces.set(this.traceKey(filePath), graph);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Parse a JSONL session log into a WatchedTrace (best-effort). */
+  loadSessionFile(filePath) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    try {
+      const content = fs.readFileSync(filePath, "utf8");
+      const lines = content.split("\n").filter((l) => l.trim());
+      if (lines.length === 0) return false;
+      const rawEvents = [];
+      for (const line of lines) {
+        try {
+          rawEvents.push(JSON.parse(line));
+        } catch {
+        }
+      }
+      if (rawEvents.length === 0) return false;
+      const sessionEvent = rawEvents.find((e) => e.type === "session");
+      const sessionId = (sessionEvent == null ? void 0 : sessionEvent.id) || path.basename(filePath, ".jsonl");
+      const sessionTimestamp = (sessionEvent == null ? void 0 : sessionEvent.timestamp) || ((_a = rawEvents[0]) == null ? void 0 : _a.timestamp);
+      const startTime = sessionTimestamp ? new Date(sessionTimestamp).getTime() : 0;
+      if (!startTime) return false;
+      const parentDir = path.basename(path.dirname(filePath));
+      const grandParentDir = path.basename(path.dirname(path.dirname(filePath)));
+      const agentId = grandParentDir === "agents" ? parentDir : parentDir;
+      const modelEvent = rawEvents.find((e) => e.type === "model_change");
+      const provider = (modelEvent == null ? void 0 : modelEvent.provider) || "";
+      const modelId = (modelEvent == null ? void 0 : modelEvent.modelId) || "";
+      const nodes = /* @__PURE__ */ new Map();
+      let lastTimestamp = startTime;
+      for (const evt of rawEvents) {
+        if (evt.timestamp) {
+          const ts = new Date(evt.timestamp).getTime();
+          if (ts > lastTimestamp) lastTimestamp = ts;
+        }
+      }
+      const firstMessage = rawEvents.find((e) => {
+        var _a2;
+        return e.type === "message" && ((_a2 = e.message) == null ? void 0 : _a2.role) === "user";
+      });
+      const userPrompt = ((_d = (_c = (_b = firstMessage == null ? void 0 : firstMessage.message) == null ? void 0 : _b.content) == null ? void 0 : _c[0]) == null ? void 0 : _d.text) || "";
+      const cronMatch = userPrompt.match(/\[cron:(\S+)\s+([^\]]+)\]/);
+      const triggerName = cronMatch ? cronMatch[2] : "";
+      const trigger = cronMatch ? "cron" : "message";
+      let totalInputTokens = 0;
+      let totalOutputTokens = 0;
+      let totalTokensSum = 0;
+      let totalCost = 0;
+      let userMessageCount = 0;
+      let assistantMessageCount = 0;
+      let toolCallCount = 0;
+      let thinkingBlockCount = 0;
+      const sessionEvents = [];
+      const toolCallMap = /* @__PURE__ */ new Map();
+      const rootId = `session-${sessionId.slice(0, 8)}`;
+      const rootName = triggerName || userPrompt.slice(0, 80) + (userPrompt.length > 80 ? "..." : "") || sessionId;
+      for (const evt of rawEvents) {
+        const evtTs = evt.timestamp ? new Date(evt.timestamp).getTime() : startTime;
+        if (evt.type === "session") {
+          sessionEvents.push({
+            type: "system",
+            timestamp: evtTs,
+            name: "Session Started",
+            content: `Version: ${evt.version || "unknown"}, CWD: ${evt.cwd || ""}`,
+            id: evt.id
+          });
+          continue;
+        }
+        if (evt.type === "model_change") {
+          sessionEvents.push({
+            type: "model_change",
+            timestamp: evtTs,
+            name: "Model Change",
+            model: evt.modelId,
+            provider: evt.provider,
+            content: `${evt.provider}/${evt.modelId}`,
+            id: evt.id
+          });
+          continue;
+        }
+        if (evt.type === "thinking_level_change") {
+          sessionEvents.push({
+            type: "system",
+            timestamp: evtTs,
+            name: "Thinking Level",
+            content: evt.thinkingLevel || "",
+            id: evt.id
+          });
+          continue;
+        }
+        if (evt.type === "custom" && evt.customType === "model-snapshot") {
+          sessionEvents.push({
+            type: "system",
+            timestamp: evtTs,
+            name: "Model Snapshot",
+            content: JSON.stringify(evt.data || {}).slice(0, 200),
+            id: evt.id
+          });
+          continue;
+        }
+        if (evt.type === "custom_message" && evt.customType === "openclaw.sessions_yield") {
+          sessionEvents.push({
+            type: "spawn",
+            timestamp: evtTs,
+            name: "Subagent Spawn",
+            content: ((_e = evt.data) == null ? void 0 : _e.sessionId) || "",
+            id: evt.id,
+            parentId: evt.parentId
+          });
+          const spawnId = `spawn-${toolCallCount + thinkingBlockCount + 1}`;
+          nodes.set(spawnId, {
+            id: spawnId,
+            type: "subagent",
+            name: "Subagent: " + (((_f = evt.data) == null ? void 0 : _f.sessionId) || "").slice(0, 12),
+            startTime: evtTs,
+            endTime: evtTs,
+            status: "completed",
+            parentId: rootId,
+            children: [],
+            metadata: { sessionId: (_g = evt.data) == null ? void 0 : _g.sessionId }
+          });
+          continue;
+        }
+        if (evt.type === "message" && evt.message) {
+          const msg = evt.message;
+          const role = msg.role;
+          const contentBlocks = Array.isArray(msg.content) ? msg.content : [];
+          if (role === "user") {
+            userMessageCount++;
+            const textContent = contentBlocks.filter((b) => b.type === "text").map((b) => b.text || "").join("\n");
+            sessionEvents.push({
+              type: "user",
+              timestamp: evtTs,
+              name: "User Message",
+              content: textContent,
+              id: evt.id,
+              parentId: evt.parentId
+            });
+          }
+          if (role === "assistant") {
+            assistantMessageCount++;
+            if (msg.usage) {
+              const u = msg.usage;
+              totalInputTokens += u.input || 0;
+              totalOutputTokens += u.output || 0;
+              totalTokensSum += u.totalTokens || 0;
+              if ((_h = u.cost) == null ? void 0 : _h.total) totalCost += u.cost.total;
+            }
+            for (const block of contentBlocks) {
+              if (block.type === "text" && block.text) {
+                sessionEvents.push({
+                  type: "assistant",
+                  timestamp: evtTs,
+                  name: "Assistant",
+                  content: block.text,
+                  id: evt.id,
+                  parentId: evt.parentId,
+                  tokens: msg.usage ? {
+                    input: msg.usage.input || 0,
+                    output: msg.usage.output || 0,
+                    total: msg.usage.totalTokens || 0,
+                    cost: (_i = msg.usage.cost) == null ? void 0 : _i.total
+                  } : void 0,
+                  model: modelId,
+                  provider
+                });
+              }
+              if (block.type === "thinking" && block.thinking) {
+                thinkingBlockCount++;
+                const thinkId = `thinking-${thinkingBlockCount}`;
+                sessionEvents.push({
+                  type: "thinking",
+                  timestamp: evtTs,
+                  name: "Thinking",
+                  content: block.thinking,
+                  id: thinkId,
+                  parentId: evt.id
+                });
+                nodes.set(thinkId, {
+                  id: thinkId,
+                  type: "decision",
+                  name: "Thinking",
+                  startTime: evtTs,
+                  endTime: evtTs,
+                  status: "completed",
+                  parentId: rootId,
+                  children: [],
+                  metadata: { preview: block.thinking.slice(0, 100) }
+                });
+              }
+              if (block.type === "toolCall") {
+                toolCallCount++;
+                const toolName = block.name || "unknown";
+                const toolId = `tool-${toolCallCount}`;
+                const toolCallId = block.id || toolId;
+                sessionEvents.push({
+                  type: "tool_call",
+                  timestamp: evtTs,
+                  name: toolName,
+                  toolName,
+                  toolArgs: block.arguments,
+                  id: toolCallId,
+                  parentId: evt.id
+                });
+                toolCallMap.set(toolCallId, sessionEvents.length - 1);
+                nodes.set(toolId, {
+                  id: toolId,
+                  type: "tool",
+                  name: toolName,
+                  startTime: evtTs,
+                  endTime: evtTs,
+                  // updated when result arrives
+                  status: "running",
+                  parentId: rootId,
+                  children: [],
+                  metadata: {
+                    toolCallId,
+                    args: block.arguments
+                  }
+                });
+              }
+            }
+          }
+          if (role === "toolResult") {
+            const toolCallId = ((_j = contentBlocks[0]) == null ? void 0 : _j.toolCallId) || evt.parentId;
+            const resultContent = contentBlocks.map((b) => b.text || b.content || "").join("\n");
+            const hasError = contentBlocks.some((b) => b.isError || b.error);
+            const errorText = hasError ? resultContent : void 0;
+            sessionEvents.push({
+              type: "tool_result",
+              timestamp: evtTs,
+              name: "Tool Result",
+              toolResult: resultContent.slice(0, 2e3),
+              toolError: errorText == null ? void 0 : errorText.slice(0, 500),
+              id: evt.id,
+              parentId: toolCallId
+            });
+            for (const [nodeId, node] of nodes) {
+              if (node.type === "tool" && ((_k = node.metadata) == null ? void 0 : _k.toolCallId) === toolCallId) {
+                node.endTime = evtTs;
+                node.status = hasError ? "failed" : "completed";
+                if (hasError) node.metadata.error = errorText == null ? void 0 : errorText.slice(0, 500);
+                const callIdx = toolCallMap.get(toolCallId);
+                if (callIdx !== void 0 && sessionEvents[callIdx]) {
+                  const callTs = sessionEvents[callIdx].timestamp;
+                  sessionEvents[sessionEvents.length - 1].duration = evtTs - callTs;
+                  sessionEvents[callIdx].duration = evtTs - callTs;
+                }
+                break;
+              }
+            }
+          }
+        }
+      }
+      const fileStat = fs.statSync(filePath);
+      const fileAge = Date.now() - fileStat.mtime.getTime();
+      const lastEvt = rawEvents[rawEvents.length - 1];
+      const hasToolError = sessionEvents.some((e) => e.type === "tool_result" && e.toolError);
+      const lastIsAssistant = (lastEvt == null ? void 0 : lastEvt.type) === "message" && ((_l = lastEvt == null ? void 0 : lastEvt.message) == null ? void 0 : _l.role) === "assistant";
+      const isRecentlyModified = fileAge < 5 * 60 * 1e3;
+      let status;
+      if (hasToolError) {
+        status = "failed";
+      } else if (lastIsAssistant) {
+        status = "completed";
+      } else if (isRecentlyModified) {
+        status = "running";
+      } else {
+        status = "completed";
+      }
+      const tokenUsage = {
+        input: totalInputTokens,
+        output: totalOutputTokens,
+        total: totalTokensSum || totalInputTokens + totalOutputTokens,
+        cost: totalCost
+      };
+      nodes.set(rootId, {
+        id: rootId,
+        type: "agent",
+        name: rootName,
+        startTime,
+        endTime: lastTimestamp,
+        status,
+        parentId: void 0,
+        children: Array.from(nodes.keys()).filter((k) => k !== rootId),
+        metadata: {
+          provider,
+          model: modelId,
+          sessionId,
+          trigger,
+          totalTokens: tokenUsage.total,
+          inputTokens: tokenUsage.input,
+          outputTokens: tokenUsage.output,
+          cost: tokenUsage.cost,
+          userMessages: userMessageCount,
+          assistantMessages: assistantMessageCount,
+          toolCalls: toolCallCount,
+          thinkingBlocks: thinkingBlockCount,
+          "gen_ai.system": provider,
+          "gen_ai.request.model": modelId
+        }
+      });
+      const filename = path.basename(filePath);
+      const trace = {
+        id: sessionId,
+        nodes,
+        edges: [],
+        events: [],
+        startTime,
+        agentId,
+        trigger,
+        name: rootName,
+        traceId: sessionId,
+        spanId: sessionId,
+        filename,
+        lastModified: fileStat.mtime.getTime(),
+        sourceType: "session",
+        sourceDir: path.dirname(filePath),
+        sessionEvents,
+        tokenUsage,
+        metadata: {
+          provider,
+          model: modelId,
+          userMessages: userMessageCount,
+          assistantMessages: assistantMessageCount,
+          toolCalls: toolCallCount,
+          thinkingBlocks: thinkingBlockCount,
+          totalEvents: rawEvents.length,
+          sessionVersion: sessionEvent == null ? void 0 : sessionEvent.version
+        }
+      };
+      this.traces.set(this.traceKey(filePath), trace);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Unique key for a file across directories. */
+  traceKey(filePath) {
+    for (const dir of this.allWatchDirs) {
+      if (filePath.startsWith(dir)) {
+        return path.relative(dir, filePath).replace(/\\/g, "/") + "@" + path.basename(dir);
+      }
+    }
+    return filePath;
+  }
+  startWatching() {
+    for (const dir of this.allWatchDirs) {
+      if (!fs.existsSync(dir)) continue;
+      const watcher = import_chokidar.default.watch(dir, {
+        ignored: /^\./,
+        persistent: true,
+        ignoreInitial: true,
+        depth: 0
+        // don't recurse into subdirectories
+      });
+      watcher.on("add", (filePath) => {
+        if (filePath.endsWith(".json") || filePath.endsWith(".jsonl") || filePath.endsWith(".log") || filePath.endsWith(".trace")) {
+          console.log(`New file: ${path.basename(filePath)}`);
+          if (this.loadFile(filePath)) {
+            const key = this.traceKey(filePath);
+            const trace = this.traces.get(key);
+            if (trace) {
+              this.emit("trace-added", trace);
+            }
+          }
+        }
+      });
+      watcher.on("change", (filePath) => {
+        if (filePath.endsWith(".json") || filePath.endsWith(".jsonl") || filePath.endsWith(".log") || filePath.endsWith(".trace")) {
+          if (this.loadFile(filePath)) {
+            const key = this.traceKey(filePath);
+            const trace = this.traces.get(key);
+            if (trace) {
+              this.emit("trace-updated", trace);
+            }
+          }
+        }
+      });
+      watcher.on("unlink", (filePath) => {
+        if (filePath.endsWith(".json") || filePath.endsWith(".jsonl") || filePath.endsWith(".log") || filePath.endsWith(".trace")) {
+          const key = this.traceKey(filePath);
+          this.traces.delete(key);
+          this.emit("trace-removed", key);
+        }
+      });
+      watcher.on("error", (error) => {
+        console.error(`Watcher error on ${dir}:`, error);
+      });
+      this.watchers.push(watcher);
+    }
+    console.log(`Watching ${this.allWatchDirs.length} directories for JSON/JSONL files`);
+  }
+  getAllTraces() {
+    return Array.from(this.traces.values()).sort((a, b) => {
+      return (b.lastModified || b.startTime) - (a.lastModified || a.startTime);
+    });
+  }
+  getTrace(filename) {
+    const exact = this.traces.get(filename);
+    if (exact) return exact;
+    for (const [key, trace] of this.traces) {
+      if (trace.filename === filename || key.endsWith(filename)) {
+        return trace;
+      }
+    }
+    return void 0;
+  }
+  getTracesByAgent(agentId) {
+    return this.getAllTraces().filter((trace) => trace.agentId === agentId);
+  }
+  getRecentTraces(limit = 50) {
+    return this.getAllTraces().slice(0, limit);
+  }
+  getTraceCount() {
+    return this.traces.size;
+  }
+  getAgentIds() {
+    const agentIds = /* @__PURE__ */ new Set();
+    for (const trace of this.traces.values()) {
+      agentIds.add(trace.agentId);
+    }
+    return Array.from(agentIds).sort();
+  }
+  stop() {
+    for (const w of this.watchers) {
+      w.close();
+    }
+    this.watchers = [];
+    console.log("Stopped watching all directories");
+  }
+  getTraceStats() {
+    const total = this.traces.size;
+    const agentCount = this.getAgentIds().length;
+    const recentCount = this.getRecentTraces(24).length;
+    const triggers = /* @__PURE__ */ new Map();
+    for (const trace of this.traces.values()) {
+      const trigger = trace.trigger || "unknown";
+      triggers.set(trigger, (triggers.get(trigger) || 0) + 1);
+    }
+    return {
+      total,
+      agentCount,
+      recentCount,
+      triggers: Object.fromEntries(triggers)
+    };
+  }
+};
+
+// src/cli.ts
+var fs2 = __toESM(require("fs"), 1);
+var os = __toESM(require("os"), 1);
+var path2 = __toESM(require("path"), 1);
+var VERSION = "0.3.1";
+function getLanAddress() {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name] || []) {
+      if (iface.family === "IPv4" && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return null;
+}
+function printBanner(config, traceCount, stats) {
+  var _a;
+  const lan = getLanAddress();
+  const host = config.host || "localhost";
+  const port = config.port;
+  const isPublic = host === "0.0.0.0";
+  console.log(`
+   ___                    _   _____ _
+  / _ \\  __ _  ___ _ __ | |_|  ___| | _____      __
+ | |_| |/ _\` |/ _ \\ '_ \\| __| |_  | |/ _ \\ \\ /\\ / /
+ |  _  | (_| |  __/ | | | |_|  _| | | (_) \\ V  V /
+ |_| |_|\\__, |\\___|_| |_|\\__|_|   |_|\\___/ \\_/\\_/
+        |___/              dashboard v${VERSION}
+
+  See your agents think.
+
+  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510              \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510              \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+  \u2502  \u{1F916} Agents          \u2502  TRACE FILES \u2502  \u{1F4CA} AgentFlow      \u2502  SHOWS YOU   \u2502  \u{1F310} Your browser   \u2502
+  \u2502  Execute tasks,   \u2502 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500> \u2502  Reads traces,    \u2502 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500> \u2502  Interactive      \u2502
+  \u2502  write JSON       \u2502              \u2502  builds graphs,  \u2502              \u2502  graph, timeline, \u2502
+  \u2502  trace files.     \u2502              \u2502  serves dashboard.\u2502              \u2502  metrics, health. \u2502
+  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518              \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518              \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+
+  Runs locally. Your data never leaves your machine.
+
+  Tabs: \u{1F3AF} Graph \xB7 \u23F1\uFE0F  Timeline \xB7 \u{1F4CA} Metrics \xB7 \u{1F6E0}\uFE0F  Process Health \xB7 \u26A0\uFE0F  Errors
+
+  Traces:     ${config.tracesDir}${((_a = config.dataDirs) == null ? void 0 : _a.length) ? "\n  Data dirs:  " + config.dataDirs.join("\n              ") : ""}
+  Loaded:     ${traceCount} traces \xB7 ${stats.totalAgents} agents \xB7 ${stats.totalExecutions} executions
+  Success:    ${stats.globalSuccessRate.toFixed(1)}%${stats.activeAgents > 0 ? ` \xB7 ${stats.activeAgents} active now` : ""}
+  CORS:       ${config.enableCors ? "enabled" : "disabled"}
+  WebSocket:  live updates enabled
+
+  \u2192 http://localhost:${port}${isPublic && lan ? `
+  \u2192 http://${lan}:${port}  (LAN)` : ""}
+`);
+}
+async function startDashboard() {
+  const args = process.argv.slice(2);
+  const config = {
+    port: 3e3,
+    tracesDir: "./traces",
+    host: "localhost",
+    enableCors: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case "--port":
+      case "-p":
+        config.port = parseInt(args[++i]) || 3e3;
+        break;
+      case "--traces":
+      case "-t":
+        config.tracesDir = args[++i];
+        break;
+      case "--host":
+      case "-h":
+        config.host = args[++i];
+        break;
+      case "--data-dir":
+        if (!config.dataDirs) config.dataDirs = [];
+        config.dataDirs.push(args[++i]);
+        break;
+      case "--cors":
+        config.enableCors = true;
+        break;
+      case "--help":
+        printHelp();
+        process.exit(0);
+    }
+  }
+  const tracesPath = path2.resolve(config.tracesDir);
+  if (!fs2.existsSync(tracesPath)) {
+    fs2.mkdirSync(tracesPath, { recursive: true });
+  }
+  config.tracesDir = tracesPath;
+  console.log("\nStarting AgentFlow Dashboard...\n");
+  const dashboard = new DashboardServer(config);
+  process.on("SIGINT", async () => {
+    console.log("\n\u{1F6D1} Shutting down dashboard...");
+    await dashboard.stop();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await dashboard.stop();
+    process.exit(0);
+  });
+  try {
+    await dashboard.start();
+    setTimeout(() => {
+      const stats = dashboard.getStats();
+      const traces = dashboard.getTraces();
+      printBanner(config, traces.length, stats);
+    }, 1500);
+  } catch (error) {
+    console.error("\u274C Failed to start dashboard:", error);
+    process.exit(1);
+  }
+}
+function printHelp() {
+  console.log(`
+\u{1F4CA} AgentFlow Dashboard v${VERSION} \u2014 See your agents think.
+
+Usage:
+  agentflow-dashboard [options]
+  npx agentflow-dashboard [options]
+
+Options:
+  -p, --port <number>     Server port (default: 3000)
+  -t, --traces <path>     Traces directory (default: ./traces)
+  -h, --host <address>    Host address (default: localhost)
+  --data-dir <path>       Extra data directory for process discovery (repeatable)
+  --cors                  Enable CORS headers
+  --help                  Show this help message
+
+Examples:
+  agentflow-dashboard --traces ./traces --host 0.0.0.0 --cors
+  agentflow-dashboard -p 8080 -t /var/log/agentflow
+  agentflow-dashboard --traces ./traces --data-dir ./workers --data-dir ./cron
+
+Tabs:
+  \u{1F3AF} Graph            Interactive Cytoscape.js execution graph
+  \u23F1\uFE0F  Timeline          Waterfall view of node durations
+  \u{1F4CA} Metrics           Success rates, durations, node breakdown
+  \u{1F6E0}\uFE0F  Process Health    PID files, systemd, workers, orphans
+  \u26A0\uFE0F  Errors            Failed and hung nodes with metadata
+`);
+}
+
+// src/server.ts
+var import_meta = {};
+var __filename = (0, import_url.fileURLToPath)(import_meta.url);
+var __dirname = path3.dirname(__filename);
+var DashboardServer = class {
+  constructor(config) {
+    this.config = config;
+    this.watcher = new TraceWatcher({
+      tracesDir: config.tracesDir,
+      dataDirs: config.dataDirs
+    });
+    this.stats = new AgentStats();
+    this.setupExpress();
+    this.setupWebSocket();
+    this.setupTraceWatcher();
+  }
+  app = (0, import_express.default)();
+  server = (0, import_http.createServer)(this.app);
+  wss = new import_ws.WebSocketServer({ server: this.server });
+  watcher;
+  stats;
+  processHealthCache = { result: null, ts: 0 };
+  setupExpress() {
+    if (this.config.enableCors) {
+      this.app.use((req, res, next) => {
+        res.header("Access-Control-Allow-Origin", "*");
+        res.header(
+          "Access-Control-Allow-Headers",
+          "Origin, X-Requested-With, Content-Type, Accept"
+        );
+        next();
+      });
+    }
+    const publicDir = path3.join(__dirname, "../public");
+    if (fs3.existsSync(publicDir)) {
+      this.app.use(import_express.default.static(publicDir));
+    }
+    this.app.get("/api/traces", (req, res) => {
+      try {
+        const traces = this.watcher.getAllTraces();
+        res.json(traces);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to load traces" });
+      }
+    });
+    this.app.get("/api/traces/:filename", (req, res) => {
+      try {
+        const trace = this.watcher.getTrace(req.params.filename);
+        if (!trace) {
+          return res.status(404).json({ error: "Trace not found" });
+        }
+        res.json(trace);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to load trace" });
+      }
+    });
+    this.app.get("/api/traces/:filename/events", (req, res) => {
+      try {
+        const trace = this.watcher.getTrace(req.params.filename);
+        if (!trace) {
+          return res.status(404).json({ error: "Trace not found" });
+        }
+        res.json({
+          events: trace.sessionEvents || [],
+          tokenUsage: trace.tokenUsage || null,
+          sourceType: trace.sourceType || "trace"
+        });
+      } catch (error) {
+        res.status(500).json({ error: "Failed to load trace events" });
+      }
+    });
+    this.app.get("/api/agents", (req, res) => {
+      try {
+        const agents = this.stats.getAgentsList();
+        res.json(agents);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to load agents" });
+      }
+    });
+    this.app.get("/api/stats", (req, res) => {
+      try {
+        const globalStats = this.stats.getGlobalStats();
+        res.json(globalStats);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to load statistics" });
+      }
+    });
+    this.app.get("/api/stats/:agentId", (req, res) => {
+      try {
+        const agentStats = this.stats.getAgentStats(req.params.agentId);
+        if (!agentStats) {
+          return res.status(404).json({ error: "Agent not found" });
+        }
+        res.json(agentStats);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to load agent statistics" });
+      }
+    });
+    this.app.get("/api/process-health", (req, res) => {
+      try {
+        const now = Date.now();
+        if (this.processHealthCache.result && now - this.processHealthCache.ts < 1e4) {
+          return res.json(this.processHealthCache.result);
+        }
+        const discoveryDirs = [
+          this.config.tracesDir,
+          path3.dirname(this.config.tracesDir),
+          ...this.config.dataDirs || []
+        ];
+        const processConfig = (0, import_agentflow_core3.discoverProcessConfig)(discoveryDirs);
+        if (!processConfig) {
+          return res.json(null);
+        }
+        const result = (0, import_agentflow_core3.auditProcesses)(processConfig);
+        this.processHealthCache = { result, ts: now };
+        res.json(result);
+      } catch (error) {
+        res.status(500).json({ error: "Failed to audit processes" });
+      }
+    });
+    this.app.get("*", (req, res) => {
+      const indexPath = path3.join(__dirname, "../public/index.html");
+      if (fs3.existsSync(indexPath)) {
+        res.sendFile(indexPath);
+      } else {
+        res.status(404).send("Dashboard not found - public files may not be built");
+      }
+    });
+  }
+  setupWebSocket() {
+    this.wss.on("connection", (ws) => {
+      console.log("Dashboard client connected");
+      ws.send(
+        JSON.stringify({
+          type: "init",
+          data: {
+            traces: this.watcher.getAllTraces(),
+            stats: this.stats.getGlobalStats()
+          }
+        })
+      );
+      ws.on("close", () => {
+        console.log("Dashboard client disconnected");
+      });
+      ws.on("error", (error) => {
+        console.error("WebSocket error:", error);
+      });
+    });
+  }
+  setupTraceWatcher() {
+    this.watcher.on("trace-added", (trace) => {
+      this.stats.processTrace(trace);
+      this.broadcast({
+        type: "trace-added",
+        data: trace
+      });
+    });
+    this.watcher.on("trace-updated", (trace) => {
+      this.stats.processTrace(trace);
+      this.broadcast({
+        type: "trace-updated",
+        data: trace
+      });
+    });
+    this.watcher.on("stats-updated", () => {
+      this.broadcast({
+        type: "stats-updated",
+        data: this.stats.getGlobalStats()
+      });
+    });
+  }
+  broadcast(message) {
+    this.wss.clients.forEach((client) => {
+      if (client.readyState === 1) {
+        client.send(JSON.stringify(message));
+      }
+    });
+  }
+  async start() {
+    return new Promise((resolve3) => {
+      const host = this.config.host || "localhost";
+      this.server.listen(this.config.port, host, () => {
+        console.log(`AgentFlow Dashboard running at http://${host}:${this.config.port}`);
+        console.log(`Watching traces in: ${this.config.tracesDir}`);
+        resolve3();
+      });
+    });
+  }
+  async stop() {
+    return new Promise((resolve3) => {
+      this.watcher.stop();
+      this.server.close(() => {
+        console.log("Dashboard server stopped");
+        resolve3();
+      });
+    });
+  }
+  getStats() {
+    return this.stats.getGlobalStats();
+  }
+  getTraces() {
+    return this.watcher.getAllTraces();
+  }
+};
+if (import_meta.url === `file://${process.argv[1]}`) {
+  startDashboard().catch(console.error);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DashboardServer
+});