agentflow-dashboard 0.2.0 → 0.3.0

package/dist/chunk-2FTN742J.js

@@ -0,0 +1,1168 @@
+// src/stats.ts
+import { getFailures, getHungNodes, getStats } from "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 = getStats(trace);
+      const failures = getFailures(trace);
+      const hungNodes = 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
+import { loadGraph } from "agentflow-core";
+import chokidar from "chokidar";
+import { EventEmitter } from "events";
+import * as fs from "fs";
+import * as path from "path";
+var TraceWatcher = class extends 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 = 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 = chokidar.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/server.ts
+import express from "express";
+import * as fs2 from "fs";
+import { createServer } from "http";
+import * as path2 from "path";
+import { fileURLToPath } from "url";
+import { WebSocketServer } from "ws";
+import { discoverProcessConfig, auditProcesses } from "agentflow-core";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.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 = express();
+  server = createServer(this.app);
+  wss = new 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 = path2.join(__dirname, "../public");
+    if (fs2.existsSync(publicDir)) {
+      this.app.use(express.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,
+          path2.dirname(this.config.tracesDir),
+          ...this.config.dataDirs || []
+        ];
+        const processConfig = discoverProcessConfig(discoveryDirs);
+        if (!processConfig) {
+          return res.json(null);
+        }
+        const result = 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 = path2.join(__dirname, "../public/index.html");
+      if (fs2.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((resolve2) => {
+      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}`);
+        resolve2();
+      });
+    });
+  }
+  async stop() {
+    return new Promise((resolve2) => {
+      this.watcher.stop();
+      this.server.close(() => {
+        console.log("Dashboard server stopped");
+        resolve2();
+      });
+    });
+  }
+  getStats() {
+    return this.stats.getGlobalStats();
+  }
+  getTraces() {
+    return this.watcher.getAllTraces();
+  }
+};
+
+export {
+  AgentStats,
+  TraceWatcher,
+  DashboardServer
+};