agentflow-dashboard 0.6.0 → 0.7.0

package/dist/index.cjs

@@ -45,6 +45,422 @@ var import_agentflow_core3 = require("agentflow-core");
 var import_express = __toESM(require("express"), 1);
 var import_ws = require("ws");
 
+// src/adapters/agentflow.ts
+var SKIP_FILES = /* @__PURE__ */ new Set([
+  "workers.json",
+  "package.json",
+  "package-lock.json",
+  "tsconfig.json",
+  "biome.json",
+  "auth.json",
+  "models.json",
+  "config.json"
+]);
+var SKIP_SUFFIXES = ["-state.json", "-config.json", "-watch-state.json", ".tmp", ".bak", ".backup"];
+var AgentFlowAdapter = class {
+  name = "agentflow";
+  detect(_dirPath) {
+    return true;
+  }
+  canHandle(filePath) {
+    const filename = filePath.split("/").pop() ?? "";
+    if (SKIP_FILES.has(filename)) return false;
+    if (SKIP_SUFFIXES.some((s) => filename.endsWith(s))) return false;
+    return filename.endsWith(".json") || filename.endsWith(".jsonl") || filename.endsWith(".log") || filename.endsWith(".trace");
+  }
+  parse(_filePath) {
+    return [];
+  }
+};
+
+// src/adapters/openclaw.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var jobCache = /* @__PURE__ */ new Map();
+function loadJobs(openclawDir) {
+  const cached = jobCache.get(openclawDir);
+  if (cached) return cached;
+  const jobsPath = (0, import_node_path.join)(openclawDir, "cron", "jobs.json");
+  const map = /* @__PURE__ */ new Map();
+  try {
+    if ((0, import_node_fs.existsSync)(jobsPath)) {
+      const data = JSON.parse((0, import_node_fs.readFileSync)(jobsPath, "utf-8"));
+      const jobs = Array.isArray(data) ? data : data.jobs ?? [];
+      for (const job of jobs) {
+        if (job.id) map.set(job.id, job);
+      }
+    }
+  } catch {
+  }
+  jobCache.set(openclawDir, map);
+  return map;
+}
+function findOpenClawRoot(filePath) {
+  let dir = (0, import_node_path.dirname)(filePath);
+  for (let i = 0; i < 5; i++) {
+    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "cron", "jobs.json")) || (0, import_node_path.basename)(dir) === ".openclaw") {
+      return dir;
+    }
+    dir = (0, import_node_path.dirname)(dir);
+  }
+  return null;
+}
+var OpenClawAdapter = class {
+  name = "openclaw";
+  detect(dirPath) {
+    return (0, import_node_fs.existsSync)((0, import_node_path.join)(dirPath, "cron", "jobs.json")) || dirPath.includes(".openclaw") || (0, import_node_fs.existsSync)((0, import_node_path.join)(dirPath, "cron", "runs"));
+  }
+  canHandle(filePath) {
+    if (!filePath.endsWith(".jsonl")) return false;
+    return filePath.includes("/cron/runs/") || filePath.includes("\\cron\\runs\\");
+  }
+  parse(filePath) {
+    const traces = [];
+    try {
+      const content = (0, import_node_fs.readFileSync)(filePath, "utf-8");
+      const root = findOpenClawRoot(filePath);
+      const jobs = root ? loadJobs(root) : /* @__PURE__ */ new Map();
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        let entry;
+        try {
+          entry = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (entry.action !== "finished") continue;
+        const jobId = entry.jobId ?? (0, import_node_path.basename)(filePath, ".jsonl");
+        const job = jobs.get(jobId);
+        const jobName = (job == null ? void 0 : job.name) ?? jobId;
+        const startTime = entry.runAtMs ?? entry.ts;
+        const duration = entry.durationMs ?? 0;
+        const trace = {
+          id: entry.sessionId ?? `${jobId}-${entry.ts}`,
+          agentId: `openclaw:${jobId}`,
+          name: jobName,
+          status: entry.status === "ok" ? "completed" : entry.status === "error" ? "failed" : "unknown",
+          startTime,
+          endTime: startTime + duration,
+          trigger: "cron",
+          source: "openclaw",
+          nodes: {
+            root: {
+              id: "root",
+              type: "cron-job",
+              name: jobName,
+              status: entry.status === "ok" ? "completed" : entry.status === "error" ? "failed" : "unknown",
+              startTime,
+              endTime: startTime + duration,
+              parentId: null,
+              children: [],
+              metadata: {
+                jobId,
+                summary: entry.summary,
+                error: entry.error,
+                delivered: entry.delivered,
+                deliveryStatus: entry.deliveryStatus
+              }
+            }
+          },
+          metadata: {
+            model: entry.model,
+            provider: entry.provider,
+            usage: entry.usage,
+            sessionId: entry.sessionId,
+            sessionKey: entry.sessionKey,
+            nextRunAtMs: entry.nextRunAtMs
+          },
+          filePath
+        };
+        traces.push(trace);
+      }
+    } catch {
+    }
+    return traces;
+  }
+};
+
+// src/adapters/otel.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var SPAN_TYPE_MAP = {
+  "gen_ai.chat": "llm",
+  "gen_ai.completion": "llm",
+  "gen_ai.embeddings": "embedding",
+  "gen_ai.content.prompt": "llm",
+  "gen_ai.content.completion": "llm"
+};
+function mapSpanType(spanName, attributes) {
+  for (const [prefix, type] of Object.entries(SPAN_TYPE_MAP)) {
+    if (spanName.startsWith(prefix)) return type;
+  }
+  if (attributes["tool.name"] || attributes["code.function"]) return "tool";
+  if (attributes["gen_ai.system"] || attributes["llm.vendor"]) return "llm";
+  if (attributes["db.system"]) return "database";
+  if (attributes["http.method"] || attributes["http.request.method"]) return "http";
+  return "span";
+}
+function extractAttributes(attrs) {
+  const result = {};
+  if (!Array.isArray(attrs)) return result;
+  for (const attr of attrs) {
+    const a = attr;
+    if (!a.key || !a.value) continue;
+    result[a.key] = a.value.stringValue ?? a.value.intValue ?? a.value.doubleValue ?? a.value.boolValue;
+  }
+  return result;
+}
+function parseOtlpPayload(payload) {
+  var _a, _b, _c;
+  const traceMap = /* @__PURE__ */ new Map();
+  for (const rs of payload.resourceSpans ?? []) {
+    const resourceAttrs = extractAttributes(((_a = rs.resource) == null ? void 0 : _a.attributes) ?? []);
+    for (const ss of rs.scopeSpans ?? []) {
+      for (const span of ss.spans ?? []) {
+        if (!span.traceId) continue;
+        let entry = traceMap.get(span.traceId);
+        if (!entry) {
+          entry = { spans: [], resource: resourceAttrs };
+          traceMap.set(span.traceId, entry);
+        }
+        entry.spans.push(span);
+      }
+    }
+  }
+  const traces = [];
+  for (const [traceId, { spans, resource }] of traceMap) {
+    const nodes = {};
+    const childMap = /* @__PURE__ */ new Map();
+    let traceStart = Number.MAX_SAFE_INTEGER;
+    let traceEnd = 0;
+    let hasFailed = false;
+    for (const span of spans) {
+      const attrs = extractAttributes(span.attributes ?? []);
+      const startNs = span.startTimeUnixNano ? Number(BigInt(span.startTimeUnixNano) / 1000000n) : 0;
+      const endNs = span.endTimeUnixNano ? Number(BigInt(span.endTimeUnixNano) / 1000000n) : null;
+      const failed = ((_b = span.status) == null ? void 0 : _b.code) === 2;
+      if (failed) hasFailed = true;
+      if (startNs < traceStart) traceStart = startNs;
+      if (endNs && endNs > traceEnd) traceEnd = endNs;
+      nodes[span.spanId] = {
+        id: span.spanId,
+        type: mapSpanType(span.name, attrs),
+        name: span.name,
+        status: failed ? "failed" : endNs ? "completed" : "running",
+        startTime: startNs,
+        endTime: endNs,
+        parentId: span.parentSpanId ?? null,
+        children: [],
+        metadata: {
+          ...attrs,
+          model: attrs["gen_ai.request.model"] ?? attrs["llm.request.model"],
+          inputTokens: attrs["gen_ai.usage.input_tokens"] ?? attrs["llm.usage.input_tokens"],
+          outputTokens: attrs["gen_ai.usage.output_tokens"] ?? attrs["llm.usage.output_tokens"]
+        }
+      };
+      if (span.parentSpanId) {
+        const siblings = childMap.get(span.parentSpanId) ?? [];
+        siblings.push(span.spanId);
+        childMap.set(span.parentSpanId, siblings);
+      }
+    }
+    for (const [parentId, children] of childMap) {
+      if (nodes[parentId]) {
+        nodes[parentId].children = children;
+      }
+    }
+    const serviceName = resource["service.name"] ?? "unknown-service";
+    traces.push({
+      id: traceId,
+      agentId: `otel:${serviceName}`,
+      name: ((_c = spans.find((s) => !s.parentSpanId)) == null ? void 0 : _c.name) ?? traceId,
+      status: hasFailed ? "failed" : "completed",
+      startTime: traceStart === Number.MAX_SAFE_INTEGER ? 0 : traceStart,
+      endTime: traceEnd,
+      trigger: "otel",
+      source: "otel",
+      nodes,
+      metadata: { ...resource }
+    });
+  }
+  return traces;
+}
+var OTelAdapter = class {
+  name = "otel";
+  detect(dirPath) {
+    try {
+      if ((0, import_node_fs2.existsSync)((0, import_node_path2.join)(dirPath, "otel-traces"))) return true;
+      const files = (0, import_node_fs2.readdirSync)(dirPath);
+      return files.some((f) => f.endsWith(".otlp.json"));
+    } catch {
+      return false;
+    }
+  }
+  canHandle(filePath) {
+    return filePath.endsWith(".otlp.json");
+  }
+  parse(filePath) {
+    try {
+      const content = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
+      const payload = JSON.parse(content);
+      const traces = parseOtlpPayload(payload);
+      for (const t of traces) t.filePath = filePath;
+      return traces;
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/adapters/registry.ts
+var adapters = [];
+function registerAdapter(adapter) {
+  adapters.push(adapter);
+}
+function findAdapter(filePath) {
+  for (const adapter of adapters) {
+    if (adapter.canHandle(filePath)) return adapter;
+  }
+  return null;
+}
+
+// src/adapters/index.ts
+registerAdapter(new OpenClawAdapter());
+registerAdapter(new OTelAdapter());
+registerAdapter(new AgentFlowAdapter());
+
+// src/agent-clustering.ts
+var PURPOSE_KEYWORDS = [
+  { keywords: ["email", "mail", "inbox", "smtp"], group: "Email Processors" },
+  { keywords: ["monitor", "watch", "alert", "surveillance"], group: "Monitors" },
+  { keywords: ["digest", "newsletter", "summary", "report", "briefing"], group: "Digests & Reports" },
+  { keywords: ["curator", "janitor", "distiller", "surveyor", "worker", "indexer"], group: "Workers" },
+  { keywords: ["cron", "schedule", "timer", "periodic"], group: "Scheduled Jobs" },
+  { keywords: ["search", "scrape", "crawl", "fetch"], group: "Data Collection" },
+  { keywords: ["embed", "vector", "index"], group: "Embeddings" }
+];
+function extractSource(agentId) {
+  const colonIdx = agentId.indexOf(":");
+  if (colonIdx > 0 && colonIdx < 20) {
+    const prefix = agentId.slice(0, colonIdx);
+    if (["openclaw", "otel", "langchain", "crewai", "mastra"].includes(prefix)) {
+      return { source: prefix, localId: agentId.slice(colonIdx + 1) };
+    }
+  }
+  return { source: "agentflow", localId: agentId };
+}
+function extractSuffix(localId) {
+  const dashIdx = localId.indexOf("-");
+  if (dashIdx > 0 && dashIdx < localId.length - 1) {
+    const suffix = localId.slice(dashIdx + 1);
+    if (suffix.length >= 4) return suffix;
+  }
+  return null;
+}
+function findPurpose(name) {
+  const lower = name.toLowerCase();
+  for (const { keywords, group } of PURPOSE_KEYWORDS) {
+    if (keywords.some((kw) => lower.includes(kw))) return group;
+  }
+  return "General";
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function deduplicateAgents(agents) {
+  const tagged = agents.map((a) => ({
+    ...a,
+    ...extractSource(a.agentId)
+  }));
+  const suffixGroups = /* @__PURE__ */ new Map();
+  for (const a of tagged) {
+    const suffix = extractSuffix(a.localId);
+    if (!suffix) continue;
+    const group = suffixGroups.get(suffix) ?? [];
+    group.push(a);
+    suffixGroups.set(suffix, group);
+  }
+  const mergedIds = /* @__PURE__ */ new Set();
+  const mergedAgents = [];
+  for (const [suffix, group] of suffixGroups) {
+    if (group.length < 2) continue;
+    const prefixes = new Set(group.map((a) => a.localId.split("-")[0]));
+    if (prefixes.size < 2) continue;
+    const merged = {
+      agentId: group[0].source === "agentflow" ? suffix : `${group[0].source}:${suffix}`,
+      displayName: suffix,
+      totalExecutions: group.reduce((s, a) => s + a.totalExecutions, 0),
+      successfulExecutions: group.reduce((s, a) => s + a.successfulExecutions, 0),
+      failedExecutions: group.reduce((s, a) => s + a.failedExecutions, 0),
+      successRate: 0,
+      avgExecutionTime: 0,
+      lastExecution: Math.max(...group.map((a) => a.lastExecution)),
+      triggers: {},
+      recentActivity: group.flatMap((a) => a.recentActivity).sort((a, b) => b.timestamp - a.timestamp).slice(0, 50),
+      sources: group.map((a) => a.agentId),
+      adapterSource: group[0].source
+    };
+    merged.successRate = merged.totalExecutions > 0 ? merged.successfulExecutions / merged.totalExecutions * 100 : 0;
+    const totalExecTime = group.reduce((s, a) => s + a.avgExecutionTime * a.totalExecutions, 0);
+    merged.avgExecutionTime = merged.totalExecutions > 0 ? totalExecTime / merged.totalExecutions : 0;
+    for (const a of group) {
+      for (const [k, v] of Object.entries(a.triggers)) {
+        merged.triggers[k] = (merged.triggers[k] ?? 0) + v;
+      }
+    }
+    mergedAgents.push(merged);
+    for (const a of group) mergedIds.add(a.agentId);
+  }
+  const result = [];
+  for (const a of agents) {
+    if (mergedIds.has(a.agentId)) continue;
+    const { source, localId } = extractSource(a.agentId);
+    result.push({
+      ...a,
+      displayName: a.displayName ?? localId,
+      adapterSource: source
+    });
+  }
+  return [...result, ...mergedAgents];
+}
+function groupAgents(agents) {
+  const sourceMap = /* @__PURE__ */ new Map();
+  for (const a of agents) {
+    const source = a.adapterSource ?? extractSource(a.agentId).source;
+    const list = sourceMap.get(source) ?? [];
+    list.push(a);
+    sourceMap.set(source, list);
+  }
+  const SOURCE_DISPLAY = {
+    agentflow: "AgentFlow",
+    openclaw: "OpenClaw",
+    otel: "OpenTelemetry",
+    langchain: "LangChain",
+    crewai: "CrewAI"
+  };
+  const groups = [];
+  for (const [source, sourceAgents] of sourceMap) {
+    const subMap = /* @__PURE__ */ new Map();
+    for (const a of sourceAgents) {
+      const purpose = findPurpose(a.displayName ?? a.agentId);
+      const list = subMap.get(purpose) ?? [];
+      list.push(a.agentId);
+      subMap.set(purpose, list);
+    }
+    const subGroups = [...subMap.entries()].map(([name, agentIds]) => ({ name, agentIds })).sort((a, b) => b.agentIds.length - a.agentIds.length);
+    groups.push({
+      name: source,
+      displayName: SOURCE_DISPLAY[source] ?? capitalize(source),
+      totalExecutions: sourceAgents.reduce((s, a) => s + a.totalExecutions, 0),
+      failedExecutions: sourceAgents.reduce((s, a) => s + a.failedExecutions, 0),
+      agents: sourceAgents.sort((a, b) => b.totalExecutions - a.totalExecutions),
+      subGroups
+    });
+  }
+  groups.sort((a, b) => b.totalExecutions - a.totalExecutions);
+  return { groups };
+}
+
 // src/stats.ts
 var import_agentflow_core = require("agentflow-core");
 var AgentStats = class {
@@ -369,7 +785,7 @@ function openClawSessionIdToAgent(sessionId) {
   if (sessionId.startsWith("janitor-")) return "vault-janitor";
   if (sessionId.startsWith("curator-")) return "vault-curator";
   if (sessionId.startsWith("distiller-")) return "vault-distiller";
-  if (sessionId.startsWith("main-")) return "main";
+  if (sessionId.startsWith("main-")) return "alfred-main";
   const firstSegment = sessionId.split("-")[0];
   if (firstSegment) return firstSegment;
   return "openclaw";
@@ -454,10 +870,14 @@ var TraceWatcher = class _TraceWatcher extends import_node_events.EventEmitter {
     "package-lock.json",
     "tsconfig.json",
     "biome.json",
-    "jobs.json",
     "auth.json",
     "models.json",
-    "config.json"
+    "config.json",
+    "runs.json",
+    "sessions.json",
+    "containers.json",
+    "update-check.json",
+    "exec-approvals.json"
   ]);
   static SKIP_SUFFIXES = [
     "-state.json",
@@ -467,11 +887,15 @@ var TraceWatcher = class _TraceWatcher extends import_node_events.EventEmitter {
     ".bak",
     ".backup"
   ];
-  /** Load a .json trace, .jsonl session file, or .log file. */
+  /** Load a file using the adapter registry, falling back to built-in parsing. */
   loadFile(filePath) {
     const filename = path.basename(filePath);
     if (_TraceWatcher.SKIP_FILES.has(filename)) return false;
     if (_TraceWatcher.SKIP_SUFFIXES.some((s) => filename.endsWith(s))) return false;
+    const adapter = findAdapter(filePath);
+    if (adapter && adapter.name !== "agentflow") {
+      return this.loadViaAdapter(filePath, adapter.name);
+    }
     if (filePath.endsWith(".jsonl")) {
       return this.loadSessionFile(filePath);
     }
@@ -480,6 +904,57 @@ var TraceWatcher = class _TraceWatcher extends import_node_events.EventEmitter {
     }
     return this.loadTraceFile(filePath);
   }
+  /** Load a file using a specific adapter and store normalized traces. */
+  loadViaAdapter(filePath, adapterName) {
+    try {
+      const adapter = findAdapter(filePath);
+      if (!adapter) return false;
+      const normalized = adapter.parse(filePath);
+      if (normalized.length === 0) return false;
+      for (const trace of normalized) {
+        const nodes = /* @__PURE__ */ new Map();
+        for (const [id, node] of Object.entries(trace.nodes)) {
+          nodes.set(id, {
+            id: node.id,
+            type: node.type,
+            name: node.name,
+            status: node.status,
+            startTime: node.startTime,
+            endTime: node.endTime,
+            parentId: node.parentId,
+            children: node.children,
+            metadata: node.metadata,
+            state: {}
+          });
+        }
+        const watched = {
+          id: trace.id,
+          rootNodeId: Object.keys(trace.nodes)[0] ?? "",
+          agentId: trace.agentId,
+          name: trace.name,
+          trigger: trace.trigger,
+          startTime: trace.startTime,
+          endTime: trace.endTime,
+          status: trace.status,
+          nodes,
+          edges: [],
+          events: [],
+          metadata: { ...trace.metadata, adapterSource: adapterName },
+          sessionEvents: trace.sessionEvents ?? [],
+          sourceType: "session",
+          filename: path.basename(filePath),
+          lastModified: Date.now(),
+          sourceDir: path.dirname(filePath)
+        };
+        const key = `${adapterName}:${trace.id}`;
+        this.traces.set(key, watched);
+      }
+      return true;
+    } catch (error) {
+      console.error(`Adapter ${adapterName} failed for ${filePath}:`, error);
+      return false;
+    }
+  }
   loadLogFile(filePath) {
     try {
       const content = fs.readFileSync(filePath, "utf8");
@@ -592,21 +1067,46 @@ var TraceWatcher = class _TraceWatcher extends import_node_events.EventEmitter {
     }
     return traces;
   }
+  /**
+   * Normalise agent identifiers so that the same worker is never shown
+   * under two different names (e.g. "vault-curator" vs "openclaw-vault-curator").
+   *
+   * Canonical names:  alfred-main, vault-curator, vault-janitor,
+   *                   vault-distiller, vault-surveyor
+   */
+  static AGENT_ALIASES = {
+    "openclaw-main": "alfred-main",
+    "openclaw-vault-curator": "vault-curator",
+    "openclaw-vault-janitor": "vault-janitor",
+    "openclaw-vault-distiller": "vault-distiller",
+    "openclaw-vault-surveyor": "vault-surveyor",
+    "alfred-curator": "vault-curator",
+    "alfred-janitor": "vault-janitor",
+    "alfred-distiller": "vault-distiller",
+    "alfred-surveyor": "vault-surveyor",
+    curator: "vault-curator",
+    janitor: "vault-janitor",
+    distiller: "vault-distiller",
+    surveyor: "vault-surveyor"
+  };
+  normaliseAgentId(raw) {
+    return _TraceWatcher.AGENT_ALIASES[raw] ?? raw;
+  }
   detectAgentIdentifier(activity, _filename, filePath) {
     if (activity.agent_id) {
       const agentId = activity.agent_id;
-      if (agentId.startsWith("vault-")) return agentId;
-      if (agentId === "main" && filePath.includes(".alfred/")) return "alfred-main";
-      return agentId;
+      if (agentId === "main" && filePath.includes(".alfred/")) return this.normaliseAgentId("alfred-main");
+      return this.normaliseAgentId(agentId);
     }
     const pathAgent = this.extractAgentFromPath(filePath);
     if (filePath.includes(".alfred/") && !pathAgent.startsWith("alfred-")) {
-      const basename2 = path.basename(filePath, path.extname(filePath));
-      if (basename2.match(/^(janitor|curator|distiller|surveyor|alfred)$/)) {
-        return basename2 === "alfred" ? "alfred" : `alfred-${basename2}`;
+      const basename3 = path.basename(filePath, path.extname(filePath));
+      if (basename3.match(/^(janitor|curator|distiller|surveyor|alfred)$/)) {
+        const raw = basename3 === "alfred" ? "alfred" : `alfred-${basename3}`;
+        return this.normaliseAgentId(raw);
       }
     }
-    return pathAgent;
+    return this.normaliseAgentId(pathAgent);
   }
   extractAgentFromPath(filePath) {
     const filename = path.basename(filePath, path.extname(filePath));
@@ -1437,8 +1937,23 @@ var TraceWatcher = class _TraceWatcher extends import_node_events.EventEmitter {
   getTrace(filename) {
     const exact = this.traces.get(filename);
     if (exact) return exact;
+    if (filename.includes("::")) {
+      const [fname, startTimeStr] = filename.split("::");
+      const startTime = Number(startTimeStr);
+      if (fname && !Number.isNaN(startTime)) {
+        for (const trace of this.traces.values()) {
+          if (trace.filename === fname && trace.startTime === startTime) {
+            return trace;
+          }
+        }
+      }
+    }
+    for (const prefix of ["openclaw:", "otel:", ""]) {
+      const prefixed = this.traces.get(prefix + filename);
+      if (prefixed) return prefixed;
+    }
     for (const [key, trace] of this.traces) {
-      if (trace.filename === filename || key.endsWith(filename)) {
+      if (trace.filename === filename || trace.id === filename || key.endsWith(filename)) {
         return trace;
       }
     }
@@ -1650,6 +2165,31 @@ function serializeTrace(trace) {
 var DashboardServer = class {
   constructor(config) {
     this.config = config;
+    const home = process.env.HOME ?? "/home/trader";
+    const configPath = path3.join(home, ".agentflow/dashboard-config.json");
+    if (!config.dataDirs) config.dataDirs = [];
+    try {
+      if (fs3.existsSync(configPath)) {
+        const saved = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+        const extraDirs = saved.extraDirs ?? [];
+        for (const d of extraDirs) {
+          if (!config.dataDirs.includes(d)) config.dataDirs.push(d);
+        }
+      }
+    } catch {
+    }
+    const autoDiscoverPaths = [
+      path3.join(home, ".openclaw/cron/runs"),
+      path3.join(home, ".openclaw/workspace/traces"),
+      path3.join(home, ".openclaw/subagents"),
+      path3.join(home, ".openclaw/agents/main/sessions"),
+      path3.join(home, ".agentflow/traces")
+    ];
+    for (const p of autoDiscoverPaths) {
+      if (fs3.existsSync(p) && !config.dataDirs.includes(p)) {
+        config.dataDirs.push(p);
+      }
+    }
     this.watcher = new TraceWatcher({
       tracesDir: config.tracesDir,
       dataDirs: config.dataDirs
@@ -1698,9 +2238,13 @@ var DashboardServer = class {
         next();
       });
     }
+    const clientDir = path3.join(__dirname, "../dist/client");
+    if (fs3.existsSync(clientDir)) {
+      this.app.use(import_express.default.static(clientDir));
+    }
     const publicDir = path3.join(__dirname, "../public");
     if (fs3.existsSync(publicDir)) {
-      this.app.use(import_express.default.static(publicDir));
+      this.app.use("/v1", import_express.default.static(publicDir));
     }
     this.app.get("/api/traces", (_req, res) => {
       try {
@@ -1736,10 +2280,28 @@ var DashboardServer = class {
         res.status(500).json({ error: "Failed to load trace events" });
       }
     });
-    this.app.get("/api/agents", (_req, res) => {
+    this.app.get("/api/agents", (req, res) => {
       try {
-        const agents = this.stats.getAgentsList();
-        res.json(agents);
+        const raw = this.stats.getAgentsList();
+        for (const agent of raw) {
+          if (!agent.displayName) {
+            const traces = this.watcher.getTracesByAgent(agent.agentId);
+            if (traces.length > 0) {
+              const latest = traces[traces.length - 1];
+              const name = latest == null ? void 0 : latest.name;
+              if (name && name !== "default" && name !== agent.agentId && !name.startsWith("pipeline:") && name.length < 40) {
+                agent.displayName = name;
+              }
+            }
+            if (!agent.displayName) agent.displayName = agent.agentId;
+          }
+        }
+        if (req.query.flat === "true") {
+          return res.json(raw);
+        }
+        const deduped = deduplicateAgents(raw);
+        const grouped = groupAgents(deduped);
+        res.json(grouped);
       } catch (_error) {
         res.status(500).json({ error: "Failed to load agents" });
       }
@@ -1889,6 +2451,84 @@ var DashboardServer = class {
         res.status(500).json({ error: "Failed to load agent profile" });
       }
     });
+    this.app.get("/api/process-model/:agentId", (req, res) => {
+      try {
+        const agentId = req.params.agentId;
+        const allTraces = this.watcher.getTracesByAgent(agentId);
+        if (allTraces.length === 0) {
+          return res.status(404).json({ error: "No traces for agent" });
+        }
+        const transMap = /* @__PURE__ */ new Map();
+        const nodeTypeMap = /* @__PURE__ */ new Map();
+        const variantMap = /* @__PURE__ */ new Map();
+        const durationMap = /* @__PURE__ */ new Map();
+        for (const trace of allTraces) {
+          const serialized = serializeTrace(trace);
+          const nodes = serialized.nodes;
+          if (!nodes || typeof nodes !== "object") continue;
+          const nodeArr = Object.values(nodes);
+          const sorted = nodeArr.filter((n) => n.name && typeof n.startTime === "number" && n.startTime > 0).sort((a, b) => (a.startTime ?? 0) - (b.startTime ?? 0));
+          for (let i = 0; i < sorted.length - 1; i++) {
+            const from = sorted[i].name;
+            const to = sorted[i + 1].name;
+            const key = `${from}|||${to}`;
+            transMap.set(key, (transMap.get(key) ?? 0) + 1);
+          }
+          for (const n of sorted) {
+            if (n.name && n.type) nodeTypeMap.set(n.name, n.type);
+          }
+          const sig = sorted.map((n) => n.name).join("\u2192");
+          if (sig) variantMap.set(sig, (variantMap.get(sig) ?? 0) + 1);
+          for (const n of sorted) {
+            if (n.name && n.endTime && n.startTime) {
+              const dur = n.endTime - n.startTime;
+              if (dur > 0) {
+                const arr = durationMap.get(n.name) ?? [];
+                arr.push(dur);
+                durationMap.set(n.name, arr);
+              }
+            }
+          }
+        }
+        const model = {
+          transitions: [...transMap.entries()].map(([key, count]) => {
+            const [from, to] = key.split("|||");
+            return { from, to, count };
+          }),
+          nodeTypes: Object.fromEntries(nodeTypeMap)
+        };
+        const totalTraces = allTraces.length;
+        const variants = [...variantMap.entries()].sort((a, b) => b[1] - a[1]).slice(0, 20).map(([sig, count]) => ({
+          pathSignature: sig,
+          count,
+          percentage: totalTraces > 0 ? count / totalTraces * 100 : 0
+        }));
+        const bottlenecks = [...durationMap.entries()].map(([name, durations]) => {
+          const sorted = durations.sort((a, b) => a - b);
+          const p95 = sorted[Math.floor(sorted.length * 0.95)] ?? 0;
+          return { nodeName: name, nodeType: nodeTypeMap.get(name) ?? "unknown", p95 };
+        }).sort((a, b) => b.p95 - a.p95).slice(0, 15);
+        const graphs = this.getGraphTraces(agentId);
+        if (graphs.length > 0) {
+          try {
+            const coreBottlenecks = (0, import_agentflow_core3.getBottlenecks)(graphs).map((b) => ({
+              nodeName: b.nodeName,
+              nodeType: b.nodeType,
+              p95: b.durations.sort((a, b2) => a - b2)[Math.floor(b.durations.length * 0.95)] ?? 0
+            }));
+            if (coreBottlenecks.length > bottlenecks.length) {
+              bottlenecks.length = 0;
+              bottlenecks.push(...coreBottlenecks);
+            }
+          } catch {
+          }
+        }
+        res.json({ model, variants, bottlenecks });
+      } catch (error) {
+        console.error("Process model error:", error);
+        res.status(500).json({ error: "Failed to compute process model" });
+      }
+    });
     this.app.get("/api/stats/:agentId", (req, res) => {
       try {
         const agentStats = this.stats.getAgentStats(req.params.agentId);
@@ -1901,6 +2541,7 @@ var DashboardServer = class {
       }
     });
     this.app.get("/api/process-health", (_req, res) => {
+      var _a, _b;
       try {
         const now = Date.now();
         if (this.processHealthCache.result && now - this.processHealthCache.ts < 1e4) {
@@ -1911,67 +2552,203 @@ var DashboardServer = class {
           path3.dirname(this.config.tracesDir),
           ...this.config.dataDirs || []
         ];
-        const processConfig = (0, import_agentflow_core3.discoverProcessConfig)(discoveryDirs);
-        if (!processConfig) {
+        const configs = (0, import_agentflow_core3.discoverAllProcessConfigs)(discoveryDirs);
+        if (configs.length === 0) {
           return res.json(null);
         }
-        const alfredResult = (0, import_agentflow_core3.auditProcesses)(processConfig);
-        const openclawConfig = {
-          processName: "openclaw",
-          pidFile: void 0,
-          workersFile: void 0,
-          systemdUnit: null
-        };
-        const openclawResult = (0, import_agentflow_core3.auditProcesses)(openclawConfig);
-        const clawmetryConfig = {
-          processName: "clawmetry",
-          pidFile: void 0,
-          workersFile: void 0,
-          systemdUnit: null
-        };
-        const clawmetryResult = (0, import_agentflow_core3.auditProcesses)(clawmetryConfig);
-        const allOsProcesses = [
-          ...alfredResult.osProcesses,
-          ...openclawResult.osProcesses,
-          ...clawmetryResult.osProcesses
-        ];
+        const services = [];
+        const allKnownPids = /* @__PURE__ */ new Set();
+        for (const config of configs) {
+          const audit = (0, import_agentflow_core3.auditProcesses)(config);
+          services.push({ name: config.processName, audit });
+          if (((_a = audit.pidFile) == null ? void 0 : _a.pid) && !audit.pidFile.stale) allKnownPids.add(audit.pidFile.pid);
+          if ((_b = audit.systemd) == null ? void 0 : _b.mainPid) allKnownPids.add(audit.systemd.mainPid);
+          if (audit.workers) {
+            if (audit.workers.orchestratorPid) allKnownPids.add(audit.workers.orchestratorPid);
+            for (const w of audit.workers.workers) {
+              if (w.pid) allKnownPids.add(w.pid);
+            }
+          }
+          for (const p of audit.osProcesses) allKnownPids.add(p.pid);
+        }
+        const primary = services.find((s) => s.audit.pidFile) ?? services[0];
+        const allOsProcesses = services.flatMap((s) => s.audit.osProcesses);
         const uniqueProcesses = allOsProcesses.filter(
           (proc, index, arr) => arr.findIndex((p) => p.pid === proc.pid) === index
         );
+        const orphans = uniqueProcesses.filter(
+          (p) => !allKnownPids.has(p.pid) && p.pid !== process.pid && p.pid !== process.ppid
+        );
+        const problems = services.flatMap(
+          (s) => s.audit.problems.map((p) => `[${s.name}] ${p}`)
+        );
         const result = {
-          ...alfredResult,
+          // Backward-compatible fields from primary service
+          pidFile: (primary == null ? void 0 : primary.audit.pidFile) ?? null,
+          systemd: (primary == null ? void 0 : primary.audit.systemd) ?? null,
+          workers: (primary == null ? void 0 : primary.audit.workers) ?? null,
           osProcesses: uniqueProcesses,
-          // Recalculate orphans based on all processes
-          orphans: uniqueProcesses.filter((p) => {
-            var _a;
-            const alfredKnownPids = /* @__PURE__ */ new Set();
-            if (((_a = alfredResult.pidFile) == null ? void 0 : _a.pid) && !alfredResult.pidFile.stale)
-              alfredKnownPids.add(alfredResult.pidFile.pid);
-            if (alfredResult.workers) {
-              if (alfredResult.workers.orchestratorPid)
-                alfredKnownPids.add(alfredResult.workers.orchestratorPid);
-              for (const w of alfredResult.workers.workers) {
-                if (w.pid) alfredKnownPids.add(w.pid);
+          orphans,
+          problems,
+          // All discovered services with their individual audit results + metrics
+          services: services.map((s) => {
+            var _a2, _b2;
+            const mainPid = ((_a2 = s.audit.pidFile) == null ? void 0 : _a2.pid) ?? ((_b2 = s.audit.systemd) == null ? void 0 : _b2.mainPid);
+            const osProc = mainPid ? uniqueProcesses.find((p) => p.pid === mainPid) : void 0;
+            return {
+              name: s.name,
+              pidFile: s.audit.pidFile,
+              systemd: s.audit.systemd,
+              workers: s.audit.workers,
+              problems: s.audit.problems,
+              metrics: osProc ? { cpu: osProc.cpu, mem: osProc.mem, elapsed: osProc.elapsed } : void 0
+            };
+          }),
+          // Topology edges: parent-child relationships from process ppid
+          topology: uniqueProcesses.map((p) => {
+            try {
+              const statusContent = fs3.readFileSync(`/proc/${p.pid}/status`, "utf8");
+              const ppidMatch = statusContent.match(/^PPid:\s+(\d+)/m);
+              const ppid = ppidMatch ? parseInt(ppidMatch[1] ?? "0", 10) : 0;
+              if (ppid > 1 && allKnownPids.has(ppid)) {
+                return { source: ppid, target: p.pid };
               }
+            } catch {
             }
-            const isOpenClawProcess = p.cmdline.includes("openclaw") || p.cmdline.includes("clawmetry");
-            return !alfredKnownPids.has(p.pid) && !isOpenClawProcess && p.pid !== process.pid && p.pid !== process.ppid;
-          })
+            return null;
+          }).filter(Boolean)
         };
-        const openclawProblems = [];
-        if (openclawResult.osProcesses.length === 0) {
-          openclawProblems.push("No OpenClaw gateway processes detected");
-        }
-        if (clawmetryResult.osProcesses.length === 0) {
-          openclawProblems.push("No clawmetry processes detected");
-        }
-        result.problems = [...alfredResult.problems || [], ...openclawProblems];
         this.processHealthCache = { result, ts: now };
         res.json(result);
       } catch (_error) {
         res.status(500).json({ error: "Failed to audit processes" });
       }
     });
+    this.app.get("/api/directories", (_req, res) => {
+      try {
+        const home = process.env.HOME ?? "/home/trader";
+        const configPath = path3.join(home, ".agentflow/dashboard-config.json");
+        let extraDirs = [];
+        try {
+          if (fs3.existsSync(configPath)) {
+            const cfg = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+            extraDirs = cfg.extraDirs ?? [];
+          }
+        } catch {
+        }
+        const watched = [
+          this.config.tracesDir,
+          ...this.config.dataDirs || [],
+          ...extraDirs
+        ];
+        const discovered = [];
+        try {
+          const { execSync } = require("child_process");
+          const raw = execSync(
+            "systemctl --user show --property=ExecStart --no-pager alfred.service openclaw-gateway.service 2>/dev/null",
+            { encoding: "utf8", timeout: 5e3 }
+          );
+          for (const line of raw.split("\n")) {
+            const match = line.match(/path=([^\s;]+)/);
+            if (match == null ? void 0 : match[1]) {
+              const dir = path3.dirname(match[1]);
+              if (fs3.existsSync(dir)) discovered.push(dir);
+            }
+          }
+        } catch {
+        }
+        const commonPaths = [
+          path3.join(home, ".alfred/traces"),
+          path3.join(home, ".alfred/data"),
+          path3.join(home, ".openclaw/workspace/traces"),
+          path3.join(home, ".openclaw/subagents"),
+          path3.join(home, ".openclaw/cron/runs"),
+          path3.join(home, ".openclaw/cron"),
+          path3.join(home, ".openclaw/agents/main/sessions"),
+          path3.join(home, ".agentflow/traces")
+        ];
+        for (const p of commonPaths) {
+          if (fs3.existsSync(p) && !discovered.includes(p)) {
+            discovered.push(p);
+          }
+        }
+        const watchedSet = new Set(watched.map((w) => path3.resolve(w)));
+        const suggested = discovered.filter((d) => !watchedSet.has(path3.resolve(d)));
+        res.json({ watched, discovered, suggested });
+      } catch (error) {
+        console.error("Directory discovery error:", error);
+        res.status(500).json({ error: "Failed to discover directories" });
+      }
+    });
+    this.app.post("/api/directories", import_express.default.json(), (req, res) => {
+      try {
+        const { add, remove } = req.body;
+        if (add && !fs3.existsSync(add)) {
+          return res.status(400).json({ error: `Directory does not exist: ${add}` });
+        }
+        const configPath = path3.join(process.env.HOME ?? "/home/trader", ".agentflow/dashboard-config.json");
+        let config = {};
+        try {
+          if (fs3.existsSync(configPath)) {
+            config = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+          }
+        } catch {
+        }
+        if (!config.extraDirs) config.extraDirs = [];
+        if (add && !config.extraDirs.includes(add)) {
+          config.extraDirs.push(add);
+        }
+        if (remove) {
+          config.extraDirs = config.extraDirs.filter((d) => d !== remove);
+        }
+        fs3.mkdirSync(path3.dirname(configPath), { recursive: true });
+        fs3.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        res.json({ ok: true, extraDirs: config.extraDirs });
+      } catch (error) {
+        console.error("Directory config error:", error);
+        res.status(500).json({ error: "Failed to update directory config" });
+      }
+    });
+    this.app.post("/v1/traces", import_express.default.json({ limit: "10mb" }), (req, res) => {
+      try {
+        const traces = parseOtlpPayload(req.body);
+        let ingested = 0;
+        for (const trace of traces) {
+          const nodes = /* @__PURE__ */ new Map();
+          for (const [id, node] of Object.entries(trace.nodes)) {
+            nodes.set(id, { ...node, state: {} });
+          }
+          const watched = {
+            id: trace.id,
+            rootNodeId: Object.keys(trace.nodes)[0] ?? "",
+            agentId: trace.agentId,
+            name: trace.name,
+            trigger: trace.trigger,
+            startTime: trace.startTime,
+            endTime: trace.endTime,
+            status: trace.status,
+            nodes,
+            edges: [],
+            events: [],
+            metadata: { ...trace.metadata, adapterSource: "otel" },
+            sessionEvents: [],
+            sourceType: "session",
+            filename: `otel-${trace.id}`,
+            lastModified: Date.now(),
+            sourceDir: "http-collector"
+          };
+          this.watcher.traces.set(`otel:${trace.id}`, watched);
+          ingested++;
+        }
+        if (ingested > 0) {
+          this.broadcast({ type: "traces-updated", count: ingested });
+        }
+        res.json({ ok: true, tracesIngested: ingested });
+      } catch (error) {
+        console.error("OTLP collector error:", error);
+        res.status(400).json({ error: "Failed to parse OTLP payload" });
+      }
+    });
     this.app.get("/health", (_req, res) => {
       res.json({
         status: "ok",
@@ -1983,10 +2760,18 @@ var DashboardServer = class {
     this.app.get("/ready", (_req, res) => {
       res.json({ status: "ready" });
     });
+    this.app.get("/v1/*", (_req, res) => {
+      const legacyIndex = path3.join(__dirname, "../public/index.html");
+      if (fs3.existsSync(legacyIndex)) {
+        res.sendFile(legacyIndex);
+      } else {
+        res.status(404).send("Legacy dashboard not found");
+      }
+    });
     this.app.get("*", (_req, res) => {
-      const indexPath = path3.join(__dirname, "../public/index.html");
-      if (fs3.existsSync(indexPath)) {
-        res.sendFile(indexPath);
+      const clientIndex = path3.join(__dirname, "../dist/client/index.html");
+      if (fs3.existsSync(clientIndex)) {
+        res.sendFile(clientIndex);
       } else {
         res.status(404).send("Dashboard not found - public files may not be built");
       }
@@ -2233,21 +3018,21 @@ var DashboardServer = class {
     });
   }
   async start() {
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       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();
+        resolve4();
       });
     });
   }
   async stop() {
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       this.watcher.stop();
       this.server.close(() => {
         console.log("Dashboard server stopped");
-        resolve3();
+        resolve4();
       });
     });
   }