@aria-cli/tools 1.0.18 → 1.0.31

package/dist/executors/search.js

@@ -0,0 +1,67 @@
+/**
+ * Executor for the native indexed regex search tool.
+ *
+ * Freshness architecture (frg parity):
+ * 1. ARIA tool writes → recordSearchMutation → session overlay (0ms visibility)
+ * 2. External edits → reconcileSearchGitDirty → session overlay (0ms visibility)
+ * 3. Commit/version change → syncIndex or buildIndex (incremental/full)
+ * 4. Session overlay passed to napi search() — no index rebuild needed
+ */
+import * as nodePath from "node:path";
+import { buildIndex, syncIndex, indexStatus, search } from "@aria-cli/search";
+import { success, fail } from "./utils.js";
+import { reconcileSearchGitDirty, getSearchSessionOverlay, clearSearchMutations, } from "./search-freshness.js";
+export async function executeSearch(input, ctx) {
+    const opts = input;
+    const dir = nodePath.resolve(ctx.workingDir, opts.directory || ".");
+    try {
+        // Step 1: Index management — build or sync base index if needed.
+        const status = indexStatus(dir);
+        if (status.state === "none") {
+            buildIndex(dir);
+            clearSearchMutations(dir); // fresh index includes everything
+        }
+        else if (status.state === "stale") {
+            // Commit or binary version changed — incremental sync is sufficient
+            // (syncIndex rebuilds hot.log from git diff, much cheaper than full build).
+            // Only fall back to full build if sync fails.
+            try {
+                syncIndex(dir);
+            }
+            catch {
+                buildIndex(dir);
+            }
+            clearSearchMutations(dir);
+        }
+        // "ready" — base index is fresh, session overlay handles uncommitted changes
+        // Step 2: Reconcile git-dirty files into pending mutations.
+        // Detects files modified/created/deleted by external agents or the user.
+        // Throttled to avoid hammering git on rapid sequential searches.
+        reconcileSearchGitDirty(dir);
+        // Step 3: Generate session overlay from pending mutations.
+        // This gives 0ms visibility for ARIA tool writes and external edits —
+        // no index rebuild needed. The overlay is applied in-memory by the
+        // Rust search engine on top of the base index + hot.log.
+        const overlay = getSearchSessionOverlay(dir);
+        // Step 4: Search with overlay.
+        const results = search({
+            pattern: opts.pattern,
+            directory: dir,
+            maxResults: opts.maxResults ?? 1000,
+            fileGlob: opts.fileGlob,
+            fileType: opts.fileType,
+            caseSensitive: opts.caseSensitive ?? true,
+            literal: opts.literal ?? false,
+            context: opts.context ?? 0,
+            sessionWrites: overlay.sessionWrites,
+            sessionDeletes: overlay.sessionDeletes,
+        });
+        const truncated = results.length >= (opts.maxResults ?? 1000);
+        return success(`Found ${results.length} matches for "${opts.pattern}"${truncated ? " (truncated)" : ""}`, { matches: results, truncated });
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        return fail(`Search failed: ${reason}`);
+    }
+}
+//# sourceMappingURL=search.js.map

package/dist/executors/self-diagnose.js

@@ -0,0 +1,399 @@
+/**
+ * @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 { success, fail } from "./utils.js";
+// ============================================================================
+// Constants
+// ============================================================================
+const ALL_SECTIONS = ["runtime", "errors", "crashes", "databases", "daemon", "network"];
+const ARIA_HOME = path.join(os.homedir(), ".aria");
+// ============================================================================
+// Helpers
+// ============================================================================
+async function safeStat(p) {
+    try {
+        const s = await fs.stat(p);
+        return { size: s.size, mtime: s.mtime };
+    }
+    catch {
+        return null;
+    }
+}
+function truncate(s, max) {
+    if (!s)
+        return "";
+    return s.length <= max ? s : s.slice(0, max - 3) + "...";
+}
+async function dirCount(dir) {
+    try {
+        const entries = await fs.readdir(dir);
+        return entries.length;
+    }
+    catch {
+        return 0;
+    }
+}
+async function tailJsonl(filePath, maxLines) {
+    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) {
+    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, focus, limit) {
+    // 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),
+    ]);
+    const all = [
+        ...rotatedEntries.map((e) => ({ ...e, _src: "rotated" })),
+        ...activeEntries.map((e) => ({ ...e, _src: "active" })),
+    ];
+    const filtered = all.filter((entry) => {
+        const ts = entry.timestamp;
+        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) {
+    const results = [];
+    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() {
+    const results = [];
+    // Key database paths (only real ones, not empty legacy ghosts)
+    const dbPaths = [
+        {
+            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;
+        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 = {
+            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) {
+    const results = [];
+    // 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) {
+    // Node identity from network/config.json
+    let nodeId = null;
+    let displayName = null;
+    let listenPort = null;
+    let externalEndpoint = 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 = [];
+    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, ctx) {
+    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 = {
+        runtime: () => getRuntime(ctx),
+        errors: () => getErrors(since, focus, limit),
+        crashes: () => getCrashes(limit),
+        databases: () => getDatabases(),
+        daemon: () => getDaemon(limit),
+        network: () => getNetwork(limit),
+    };
+    const results = {};
+    const errors = [];
+    const returned = [];
+    const withTimeout = (fn, name) => 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);
+}
+//# sourceMappingURL=self-diagnose.js.map