@aria-cli/tools 1.0.0

package/src/executors/self-diagnose.ts

@@ -0,0 +1,552 @@
+/**
+ * @aria/tools - Self-diagnose tool executor
+ *
+ * Pure signal diagnostic tool. 5 sections, zero noise:
+ * 1. runtime  — process health + resource leaks
+ * 2. errors   — structured errors from JSONL (active + rotated)
+ * 3. crashes  — crash markers + dumps
+ * 4. databases — sizes, WAL health, schema version
+ * 5. daemon   — daemon audit + delegation journal
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import type { ToolContext, ToolResult } from "../types.js";
+import { success, fail } from "./utils.js";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface SelfDiagnoseInput {
+  focus?: string;
+  sections?: string[];
+  since?: string;
+  limit?: number;
+}
+
+export interface RuntimeInfo {
+  pid: number;
+  uptime_s: number;
+  heap_mb: number;
+  rss_mb: number;
+  node_version: string;
+  platform: string;
+  arch: string;
+  cwd: string;
+  session_id: string | null;
+  socket_dirs: number;
+  owner_files: number;
+  relaunch_pending: boolean;
+}
+
+export interface ErrorEntry {
+  timestamp: string;
+  severity: string;
+  category: string;
+  message: string;
+  stackTrace: string;
+  source: string;
+}
+
+export interface CrashInfo {
+  file: string;
+  size?: number;
+  timestamp?: string;
+  error_message?: string;
+  content?: Record<string, unknown>;
+}
+
+export interface DbInfo {
+  name: string;
+  size_mb: string;
+  wal_mb: string | null;
+  modified: string;
+  schema_version?: number;
+}
+
+export interface DaemonEntry {
+  source: string;
+  entries: unknown[];
+}
+
+export interface NetworkInfo {
+  node_id: string | null;
+  display_name: string | null;
+  listen_port: number | null;
+  external_endpoint: string | null;
+  peer_count: number;
+  peers: Array<{
+    node_id: string;
+    name: string;
+    status: string;
+    last_seen: string | null;
+  }>;
+  tls_certs_present: boolean;
+  trusted_cas: number;
+  recent_tunnel_events: unknown[];
+  recent_diagnostics: unknown[];
+}
+
+export interface SelfDiagnoseOutput {
+  runtime: RuntimeInfo | null;
+  errors: ErrorEntry[] | null;
+  crashes: CrashInfo[] | null;
+  databases: DbInfo[] | null;
+  daemon: DaemonEntry[] | null;
+  network: NetworkInfo | null;
+  _meta: {
+    sections_requested: string[];
+    sections_returned: string[];
+    elapsed_ms: number;
+    errors: string[];
+  };
+}
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+const ALL_SECTIONS = ["runtime", "errors", "crashes", "databases", "daemon", "network"];
+const ARIA_HOME = path.join(os.homedir(), ".aria");
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+async function safeStat(p: string): Promise<{ size: number; mtime: Date } | null> {
+  try {
+    const s = await fs.stat(p);
+    return { size: s.size, mtime: s.mtime };
+  } catch {
+    return null;
+  }
+}
+
+function truncate(s: string | undefined | null, max: number): string {
+  if (!s) return "";
+  return s.length <= max ? s : s.slice(0, max - 3) + "...";
+}
+
+async function dirCount(dir: string): Promise<number> {
+  try {
+    const entries = await fs.readdir(dir);
+    return entries.length;
+  } catch {
+    return 0;
+  }
+}
+
+async function tailJsonl(filePath: string, maxLines: number): Promise<unknown[]> {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    const lines = content.trim().split("\n").slice(-maxLines);
+    return lines
+      .map((l) => {
+        try {
+          return JSON.parse(l);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+// ============================================================================
+// Section: runtime
+// ============================================================================
+
+async function getRuntime(ctx: ToolContext): Promise<RuntimeInfo> {
+  const mem = process.memoryUsage();
+
+  // Resource leak detection
+  const socketDirs = await dirCount(path.join(ARIA_HOME, "sock"));
+  const ownerFiles = await dirCount(path.join(ARIA_HOME, "run/owners"));
+
+  // Stuck restart detection
+  let relaunchPending = false;
+  try {
+    const entries = await fs.readdir(path.join(ARIA_HOME, "relaunch-pending"));
+    relaunchPending = entries.length > 0;
+  } catch {
+    /* dir may not exist */
+  }
+
+  return {
+    pid: process.pid,
+    uptime_s: Math.round(process.uptime()),
+    heap_mb: Math.round(mem.heapUsed / 1e6),
+    rss_mb: Math.round(mem.rss / 1e6),
+    node_version: process.version,
+    platform: process.platform,
+    arch: process.arch,
+    cwd: process.cwd(),
+    session_id: ctx.currentSessionId ?? null,
+    socket_dirs: socketDirs,
+    owner_files: ownerFiles,
+    relaunch_pending: relaunchPending,
+  };
+}
+
+// ============================================================================
+// Section: errors (active + rotated JSONL, merged, filtered)
+// ============================================================================
+
+async function getErrors(
+  since: Date,
+  focus: string | undefined,
+  limit: number,
+): Promise<ErrorEntry[]> {
+  // Read both active and rotated logs
+  const active = path.join(ARIA_HOME, "error-events.jsonl");
+  const rotated = path.join(ARIA_HOME, "error-events.jsonl.1");
+
+  const [activeEntries, rotatedEntries] = await Promise.all([
+    tailJsonl(active, 200),
+    tailJsonl(rotated, 100),
+  ]);
+
+  // Merge: rotated first (older), then active (newer)
+  type RawEntry = Record<string, unknown> & { _src: string };
+  const all: RawEntry[] = [
+    ...rotatedEntries.map((e) => ({ ...(e as Record<string, unknown>), _src: "rotated" })),
+    ...activeEntries.map((e) => ({ ...(e as Record<string, unknown>), _src: "active" })),
+  ];
+
+  const filtered = all.filter((entry) => {
+    const ts = entry.timestamp as string | undefined;
+    if (ts) {
+      const d = new Date(ts);
+      if (d < since) return false;
+    }
+    if (focus) {
+      const haystack = [
+        String(entry.message ?? ""),
+        String(entry.category ?? ""),
+        String(entry.stackTrace ?? ""),
+      ]
+        .join(" ")
+        .toLowerCase();
+      if (!haystack.includes(focus)) return false;
+    }
+    return true;
+  });
+
+  return filtered.slice(-limit).map((entry) => ({
+    timestamp: String(entry.timestamp ?? ""),
+    severity: String(entry.severity ?? "unknown"),
+    category: String(entry.category ?? ""),
+    message: String(entry.message ?? ""),
+    stackTrace: truncate(String(entry.stackTrace ?? ""), 500),
+    source: String(entry._src),
+  }));
+}
+
+// ============================================================================
+// Section: crashes
+// ============================================================================
+
+async function getCrashes(limit: number): Promise<CrashInfo[]> {
+  const results: CrashInfo[] = [];
+
+  for (const subdir of ["crash-markers", "crash-dumps"]) {
+    const dir = path.join(ARIA_HOME, subdir);
+    try {
+      const files = await fs.readdir(dir);
+      const jsonFiles = files.filter((f) => f.endsWith(".json"));
+      const stats = await Promise.all(
+        jsonFiles.map(async (f) => {
+          const p = path.join(dir, f);
+          const s = await safeStat(p);
+          return { file: f, path: p, stat: s };
+        }),
+      );
+      const sorted = stats
+        .filter((f) => f.stat)
+        .sort((a, b) => b.stat!.mtime.getTime() - a.stat!.mtime.getTime());
+
+      for (const { file, path: fp, stat } of sorted.slice(0, limit)) {
+        try {
+          const raw = await fs.readFile(fp, "utf-8");
+          const parsed = JSON.parse(raw);
+          if (subdir === "crash-markers") {
+            results.push({
+              file: `${subdir}/${file}`,
+              timestamp: stat!.mtime.toISOString(),
+              content: parsed,
+            });
+          } else {
+            const msg = parsed.error_message ?? parsed.message ?? parsed.error ?? "";
+            results.push({
+              file: `${subdir}/${file}`,
+              size: stat!.size,
+              timestamp: stat!.mtime.toISOString(),
+              error_message: truncate(String(msg), 200),
+            });
+          }
+        } catch {
+          results.push({
+            file: `${subdir}/${file}`,
+            timestamp: stat!.mtime.toISOString(),
+            error_message: "Failed to parse",
+          });
+        }
+      }
+    } catch {
+      /* dir may not exist */
+    }
+  }
+
+  return results;
+}
+
+// ============================================================================
+// Section: databases (sizes, WAL health, schema version)
+// ============================================================================
+
+async function getDatabases(): Promise<DbInfo[]> {
+  const results: DbInfo[] = [];
+
+  // Key database paths (only real ones, not empty legacy ghosts)
+  const dbPaths: Array<{ name: string; path: string; checkSchema?: boolean }> = [
+    {
+      name: "memory.db (main)",
+      path: path.join(ARIA_HOME, "arions/ARIA/memory.db"),
+      checkSchema: true,
+    },
+    { name: "history.db", path: path.join(ARIA_HOME, "history.db") },
+    { name: "investigation-metrics.db", path: path.join(ARIA_HOME, "investigation-metrics.db") },
+    { name: "network/state.db", path: path.join(ARIA_HOME, "network/state.db") },
+    { name: "node/node-state.db", path: path.join(ARIA_HOME, "node/node-state.db") },
+  ];
+
+  for (const db of dbPaths) {
+    const stat = await safeStat(db.path);
+    if (!stat || stat.size === 0) continue;
+
+    // WAL size — a large WAL means checkpoint isn't running
+    const walStat = await safeStat(db.path + "-wal");
+    const walMb = walStat && walStat.size > 0 ? (walStat.size / 1e6).toFixed(1) : null;
+
+    // Schema version for the main DB (lightweight: only reads one int)
+    let schemaVersion: number | undefined;
+    if (db.checkSchema) {
+      try {
+        // Use a child process to avoid importing better-sqlite3 / locking the DB
+        const { execFileSync } = await import("node:child_process");
+        const out = execFileSync("sqlite3", [db.path, "SELECT MAX(version) FROM schema_version;"], {
+          timeout: 1000,
+          encoding: "utf-8",
+        }).trim();
+        schemaVersion = parseInt(out, 10) || undefined;
+      } catch {
+        // sqlite3 CLI not available or query failed — not critical
+      }
+    }
+
+    const info: DbInfo = {
+      name: db.name,
+      size_mb: (stat.size / 1e6).toFixed(1),
+      wal_mb: walMb,
+      modified: stat.mtime.toISOString(),
+    };
+    if (schemaVersion !== undefined) info.schema_version = schemaVersion;
+    results.push(info);
+  }
+
+  return results;
+}
+
+// ============================================================================
+// Section: daemon (audit + delegation journal)
+// ============================================================================
+
+async function getDaemon(limit: number): Promise<DaemonEntry[]> {
+  const results: DaemonEntry[] = [];
+
+  // Daemon audit log — restart loops, crashes, startup events
+  const auditPath = path.join(ARIA_HOME, "arions/ARIA/daemon/audit.jsonl");
+  const auditEntries = await tailJsonl(auditPath, limit);
+  if (auditEntries.length > 0) {
+    results.push({ source: "daemon/audit", entries: auditEntries });
+  }
+
+  // Delegation journal — worker spawn/complete/fail
+  const delegationPath = path.join(ARIA_HOME, "arions/ARIA/delegation-journal.jsonl");
+  const delegationEntries = await tailJsonl(delegationPath, limit);
+  if (delegationEntries.length > 0) {
+    results.push({ source: "delegation-journal", entries: delegationEntries });
+  }
+
+  return results;
+}
+
+// ============================================================================
+// Section: network (identity, peers, tunnels, TLS, diagnostics)
+// ============================================================================
+
+async function getNetwork(limit: number): Promise<NetworkInfo> {
+  // Node identity from network/config.json
+  let nodeId: string | null = null;
+  let displayName: string | null = null;
+  let listenPort: number | null = null;
+  let externalEndpoint: string | null = null;
+
+  try {
+    const raw = await fs.readFile(path.join(ARIA_HOME, "network/config.json"), "utf-8");
+    const cfg = JSON.parse(raw);
+    nodeId = cfg.nodeId ?? null;
+    displayName = cfg.localDisplayNameSnapshot ?? null;
+    listenPort = cfg.listenPort ?? null;
+    if (cfg.externalEndpoint) {
+      externalEndpoint = `${cfg.externalEndpoint.address}:${cfg.externalEndpoint.port}`;
+    }
+    // Never expose private keys — only the fact we have them
+  } catch {
+    /* config may not exist */
+  }
+
+  // Peers from network/state.db (using sqlite3 CLI to avoid locking)
+  const peers: NetworkInfo["peers"] = [];
+  let peerCount = 0;
+  try {
+    const { execFileSync } = await import("node:child_process");
+    const out = execFileSync(
+      "sqlite3",
+      [
+        path.join(ARIA_HOME, "network/state.db"),
+        "-json",
+        `SELECT nodeId, displayName, status, lastSeen FROM network_peers ORDER BY lastSeen DESC LIMIT ${limit};`,
+      ],
+      { timeout: 1000, encoding: "utf-8" },
+    ).trim();
+    if (out) {
+      const rows = JSON.parse(out);
+      for (const row of rows) {
+        peers.push({
+          node_id: row.nodeId ?? "",
+          name: row.displayName ?? "",
+          status: row.status ?? "unknown",
+          last_seen: row.lastSeen ? new Date(row.lastSeen).toISOString() : null,
+        });
+      }
+    }
+    const countOut = execFileSync(
+      "sqlite3",
+      [path.join(ARIA_HOME, "network/state.db"), "SELECT COUNT(*) FROM network_peers;"],
+      { timeout: 1000, encoding: "utf-8" },
+    ).trim();
+    peerCount = parseInt(countOut, 10) || 0;
+  } catch {
+    /* sqlite3 CLI not available or query failed */
+  }
+
+  // TLS state
+  let tlsCertsPresent = false;
+  let trustedCas = 0;
+  try {
+    await fs.access(path.join(ARIA_HOME, "network/tls/server.pem"));
+    tlsCertsPresent = true;
+  } catch {
+    /* no TLS certs */
+  }
+  try {
+    const cas = await fs.readdir(path.join(ARIA_HOME, "network/trusted-cas"));
+    trustedCas = cas.filter((f) => f.endsWith(".pem")).length;
+  } catch {
+    /* dir may not exist */
+  }
+
+  // Recent tunnel events (connection attempts, handshakes, failures)
+  const tunnelEvents = await tailJsonl(
+    path.join(ARIA_HOME, "audit/wireguard-secure-tunnel.jsonl"),
+    limit,
+  );
+
+  // Recent diagnostics (disconnects, reconnects, errors)
+  const diagnostics = await tailJsonl(
+    path.join(ARIA_HOME, "audit/wireguard-diagnostics.jsonl"),
+    limit,
+  );
+
+  return {
+    node_id: nodeId,
+    display_name: displayName,
+    listen_port: listenPort,
+    external_endpoint: externalEndpoint,
+    peer_count: peerCount,
+    peers,
+    tls_certs_present: tlsCertsPresent,
+    trusted_cas: trustedCas,
+    recent_tunnel_events: tunnelEvents,
+    recent_diagnostics: diagnostics,
+  };
+}
+
+// ============================================================================
+// Main Executor
+// ============================================================================
+
+export async function executeSelfDiagnose(
+  input: SelfDiagnoseInput,
+  ctx: ToolContext,
+): Promise<ToolResult> {
+  if (ctx.abortSignal?.aborted) return fail("Operation cancelled");
+
+  const startMs = Date.now();
+  const limit = input.limit ?? 10;
+  const since = input.since ? new Date(input.since) : new Date(Date.now() - 3600_000);
+  const focus = input.focus?.toLowerCase();
+  const requested = input.sections ?? ALL_SECTIONS;
+  const sectionsToRun = requested.filter((s) => ALL_SECTIONS.includes(s));
+
+  const sectionFns: Record<string, () => Promise<unknown>> = {
+    runtime: () => getRuntime(ctx),
+    errors: () => getErrors(since, focus, limit),
+    crashes: () => getCrashes(limit),
+    databases: () => getDatabases(),
+    daemon: () => getDaemon(limit),
+    network: () => getNetwork(limit),
+  };
+
+  const results: Record<string, unknown> = {};
+  const errors: string[] = [];
+  const returned: string[] = [];
+
+  const withTimeout = (fn: () => Promise<unknown>, name: string) =>
+    Promise.race([
+      fn().then((r) => {
+        returned.push(name);
+        return r;
+      }),
+      new Promise((_, reject) => setTimeout(() => reject(new Error(`${name} timed out`)), 2000)),
+    ]).catch((err) => {
+      errors.push(`${name}: ${err.message}`);
+      return null;
+    });
+
+  await Promise.all(
+    sectionsToRun.map(async (name) => {
+      const fn = sectionFns[name];
+      if (fn) results[name] = await withTimeout(fn, name);
+    }),
+  );
+
+  const elapsed = Date.now() - startMs;
+  results._meta = {
+    sections_requested: sectionsToRun,
+    sections_returned: returned,
+    elapsed_ms: elapsed,
+    errors,
+  };
+
+  const msg =
+    `Diagnostics: ${returned.length}/${sectionsToRun.length} sections in ${elapsed}ms` +
+    (errors.length > 0 ? ` (${errors.length} errors)` : "");
+
+  return success(msg, results as unknown as SelfDiagnoseOutput);
+}