agentflow-dashboard 0.2.0 → 0.3.0

package/dist/cli.cjs

@@ -33,6 +33,7 @@ __export(cli_exports, {
 });
 module.exports = __toCommonJS(cli_exports);
 var fs3 = __toESM(require("fs"), 1);
+var os = __toESM(require("os"), 1);
 var path3 = __toESM(require("path"), 1);
 
 // src/server.ts
@@ -226,14 +227,23 @@ var import_events = require("events");
 var fs = __toESM(require("fs"), 1);
 var path = __toESM(require("path"), 1);
 var TraceWatcher = class extends import_events.EventEmitter {
-  watcher;
+  watchers = [];
   traces = /* @__PURE__ */ new Map();
   tracesDir;
-  constructor(tracesDir) {
+  dataDirs;
+  allWatchDirs;
+  constructor(tracesDirOrOptions) {
     super();
-    this.tracesDir = path.resolve(tracesDir);
+    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.loadExistingTraces();
+    this.loadExistingFiles();
     this.startWatching();
   }
   ensureTracesDir() {
@@ -242,18 +252,288 @@ var TraceWatcher = class extends import_events.EventEmitter {
       console.log(`Created traces directory: ${this.tracesDir}`);
     }
   }
-  loadExistingTraces() {
+  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 files = fs.readdirSync(this.tracesDir).filter((file) => file.endsWith(".json"));
-      console.log(`Loading ${files.length} existing trace files...`);
-      for (const file of files) {
-        this.loadTraceFile(path.join(this.tracesDir, file));
+      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);
       }
-      console.log(`Loaded ${this.traces.size} traces`);
+      return traces.length > 0;
     } catch (error) {
-      console.error("Error loading existing traces:", 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");
@@ -262,55 +542,404 @@ var TraceWatcher = class extends import_events.EventEmitter {
       const stats = fs.statSync(filePath);
       graph.filename = filename;
       graph.lastModified = stats.mtime.getTime();
-      this.traces.set(filename, graph);
+      graph.sourceType = "trace";
+      graph.sourceDir = path.dirname(filePath);
+      this.traces.set(this.traceKey(filePath), graph);
       return true;
-    } catch (error) {
-      console.error(`Error loading trace file ${filePath}:`, error);
+    } catch {
       return false;
     }
   }
-  startWatching() {
-    this.watcher = import_chokidar.default.watch(this.tracesDir, {
-      ignored: /^\./,
-      persistent: true,
-      ignoreInitial: true
-    });
-    this.watcher.on("add", (filePath) => {
-      if (filePath.endsWith(".json")) {
-        console.log(`New trace file: ${path.basename(filePath)}`);
-        if (this.loadTraceFile(filePath)) {
-          const filename = path.basename(filePath);
-          const trace = this.traces.get(filename);
-          if (trace) {
-            this.emit("trace-added", trace);
-          }
+  /** 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 {
         }
       }
-    });
-    this.watcher.on("change", (filePath) => {
-      if (filePath.endsWith(".json")) {
-        console.log(`Trace file updated: ${path.basename(filePath)}`);
-        if (this.loadTraceFile(filePath)) {
-          const filename = path.basename(filePath);
-          const trace = this.traces.get(filename);
-          if (trace) {
-            this.emit("trace-updated", trace);
+      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;
+              }
+            }
           }
         }
       }
-    });
-    this.watcher.on("unlink", (filePath) => {
-      if (filePath.endsWith(".json")) {
-        const filename = path.basename(filePath);
-        console.log(`Trace file removed: ${filename}`);
-        this.traces.delete(filename);
-        this.emit("trace-removed", filename);
+      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";
       }
-    });
-    this.watcher.on("error", (error) => {
-      console.error("Trace watcher error:", error);
-    });
-    console.log(`Started watching traces directory: ${this.tracesDir}`);
+      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) => {
@@ -318,7 +947,14 @@ var TraceWatcher = class extends import_events.EventEmitter {
     });
   }
   getTrace(filename) {
-    return this.traces.get(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);
@@ -337,11 +973,11 @@ var TraceWatcher = class extends import_events.EventEmitter {
     return Array.from(agentIds).sort();
   }
   stop() {
-    if (this.watcher) {
-      this.watcher.close();
-      this.watcher = void 0;
-      console.log("Stopped watching traces directory");
+    for (const w of this.watchers) {
+      w.close();
     }
+    this.watchers = [];
+    console.log("Stopped watching all directories");
   }
   getTraceStats() {
     const total = this.traces.size;
@@ -368,7 +1004,10 @@ var __dirname = path2.dirname(__filename);
 var DashboardServer = class {
   constructor(config) {
     this.config = config;
-    this.watcher = new TraceWatcher(config.tracesDir);
+    this.watcher = new TraceWatcher({
+      tracesDir: config.tracesDir,
+      dataDirs: config.dataDirs
+    });
     this.stats = new AgentStats();
     this.setupExpress();
     this.setupWebSocket();
@@ -414,6 +1053,21 @@ var DashboardServer = class {
         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();
@@ -549,8 +1203,56 @@ var DashboardServer = class {
 };
 
 // src/cli.ts
-async function startDashboard() {
+var VERSION = "0.2.2";
+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,
@@ -586,43 +1288,27 @@ async function startDashboard() {
   }
   const tracesPath = path3.resolve(config.tracesDir);
   if (!fs3.existsSync(tracesPath)) {
-    console.log(`Traces directory doesn't exist: ${tracesPath}`);
-    console.log("Creating traces directory...");
     fs3.mkdirSync(tracesPath, { recursive: true });
   }
   config.tracesDir = tracesPath;
-  console.log("\u{1F680} Starting AgentFlow Dashboard...");
-  console.log(`   Port: ${config.port}`);
-  console.log(`   Host: ${config.host}`);
-  console.log(`   Traces: ${config.tracesDir}`);
-  console.log(`   CORS: ${config.enableCors ? "enabled" : "disabled"}`);
-  if ((_a = config.dataDirs) == null ? void 0 : _a.length) {
-    console.log(`   Data dirs: ${config.dataDirs.join(", ")}`);
-  }
+  console.log("\nStarting AgentFlow Dashboard...\n");
   const dashboard = new DashboardServer(config);
   process.on("SIGINT", async () => {
-    console.log("\\n\u{1F6D1} Shutting down dashboard...");
+    console.log("\n\u{1F6D1} Shutting down dashboard...");
     await dashboard.stop();
     process.exit(0);
   });
   process.on("SIGTERM", async () => {
-    console.log("\\n\u{1F6D1} Received SIGTERM, shutting down...");
     await dashboard.stop();
     process.exit(0);
   });
   try {
     await dashboard.start();
-    console.log("\u2705 Dashboard started successfully!");
-    console.log(`   Open: http://${config.host}:${config.port}`);
     setTimeout(() => {
       const stats = dashboard.getStats();
       const traces = dashboard.getTraces();
-      console.log(`\\n\u{1F4CA} Dashboard Status:`);
-      console.log(`   Total Traces: ${traces.length}`);
-      console.log(`   Total Agents: ${stats.totalAgents}`);
-      console.log(`   Success Rate: ${stats.globalSuccessRate.toFixed(1)}%`);
-      console.log(`   Active Agents: ${stats.activeAgents}`);
-    }, 1e3);
+      printBanner(config, traces.length, stats);
+    }, 1500);
   } catch (error) {
     console.error("\u274C Failed to start dashboard:", error);
     process.exit(1);
@@ -630,7 +1316,7 @@ async function startDashboard() {
 }
 function printHelp() {
   console.log(`
-\u{1F50D} AgentFlow Dashboard - Real-time monitoring for AI agent executions
+\u{1F4CA} AgentFlow Dashboard v${VERSION} \u2014 See your agents think.
 
 Usage:
   agentflow-dashboard [options]
@@ -640,23 +1326,21 @@ 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 directory for process discovery (repeatable)
+  --data-dir <path>       Extra data directory for process discovery (repeatable)
   --cors                  Enable CORS headers
   --help                  Show this help message
 
 Examples:
-  agentflow-dashboard --port 8080 --traces /var/log/agentflow
-  agentflow-dashboard --host 0.0.0.0 --cors
-  agentflow-dashboard --traces ./my-agent-traces
-
-Features:
-  \u2728 Real-time trace monitoring
-  \u{1F4CA} Agent performance analytics
-  \u{1F3AF} Execution graph visualization
-  \u{1F4C8} Success/failure tracking
-  \u{1F50D} Multi-agent system overview
+  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
 
-Visit: https://github.com/ClemenceChee/AgentFlow
+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
 `);
 }
 // Annotate the CommonJS export names for ESM import in node: