ai-lens 0.8.80 → 0.8.81

package/.commithash

@@ -1 +1 @@
-a6ad00e
+0533332

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 History of changes to the `ai-lens` CLI package on npm. New entries go on top. Format: `## X.Y.Z — YYYY-MM-DD`, followed by user-facing bullets.
 
+## 0.8.81 — 2026-06-05
+- improve: `ai-lens status` now tells a stale error from an active one — a past send failure no longer shows red once sending has recovered, and the time and code of the last error are shown (e.g. "recovered — last error 1d ago (ECONNRESET)").
+- improve: `ai-lens status` retries the server health check a few times before reporting "unreachable", so a one-off network blip no longer flags the server as down.
+- improve: `ai-lens status --report` now includes your config and hook files (Cursor / Claude Code / Codex, both global and project scope), with the auth token masked, so setup issues can be diagnosed remotely without sending your local status file.
+
 ## 0.8.80 — 2026-06-04
 - fix: `ai-lens import claude-code` now caps long prompts (so a huge pasted prompt is no longer dropped by the server), captures prompts from messages that mix text with images/documents (shown as a safe `[N attachment(s)]` placeholder — never the image data), and avoids a stale session "end" time on transcripts that are still being written.
 

package/cli/status.js

@@ -619,40 +619,69 @@ function checkSenderLog() {
     return { ok: false, summary: `error reading log: ${err.message}`, detail: `Error: ${err.message}` };
   }
 
-  // Aggregate across all log entries for observability
+  // Aggregate across all log entries for observability. Counts are all-time, but
+  // we also track recency (last error ts + a 24h window) so a single old failure
+  // doesn't flag the check red forever — see `recovered` below.
   let sentOk = 0;       // total events successfully delivered to server
   let failedCount = 0;  // total failed send attempts (connection/auth errors)
+  let recentFailed = 0; // failed sends within the last 24h
   let rollbackCount = 0; // total rollbacks (partial + full) — events re-queued for retry
   let lastSend = null;
+  let lastSendMs = 0;
+  let lastError = null;     // ts of the most recent failure/error
+  let lastErrorMs = 0;
+  let lastErrorCode = null; // connection/error code of that last failure
   let hasErrors = false;
+  const DAY_MS = 24 * 60 * 60 * 1000;
+  const now = Date.now();
 
   for (const line of lines) {
     try {
       const entry = JSON.parse(line);
+      const tsMs = entry.ts ? new Date(entry.ts).getTime() : NaN;
       if (entry.msg === 'sent') {
         lastSend = entry.ts;
+        if (!isNaN(tsMs) && tsMs > lastSendMs) lastSendMs = tsMs;
         sentOk += parseInt(entry.events, 10) || 0;
       }
       if (entry.msg === 'failed' || entry.msg === 'error' || entry.msg === 'auth-failed') {
         hasErrors = true;
         if (entry.msg === 'failed') failedCount++;
+        if (!isNaN(tsMs)) {
+          if (tsMs > lastErrorMs) {
+            lastErrorMs = tsMs;
+            lastError = entry.ts;
+            lastErrorCode = entry.cause?.code || entry.code || entry.error || null;
+          }
+          if (entry.msg === 'failed' && now - tsMs <= DAY_MS) recentFailed++;
+        }
       }
       if (entry.msg === 'rollback' || entry.msg === 'partial-rollback') rollbackCount++;
     } catch { /* non-JSON line */ }
   }
 
+  // Recovered = the last successful send is newer than the last error, so the
+  // failures are historical noise rather than an active problem. Only treat
+  // errors as active (red) when nothing has succeeded since the last one.
+  const recovered = lastErrorMs > 0 && lastSendMs > lastErrorMs;
+  const activeErrors = hasErrors && !recovered;
+
   const stats = [];
   if (sentOk > 0) stats.push(`${sentOk} events sent`);
-  if (failedCount > 0) stats.push(`${failedCount} failed`);
+  if (failedCount > 0) stats.push(`${failedCount} failed${recentFailed > 0 ? `, ${recentFailed} in 24h` : ''}`);
   if (rollbackCount > 0) stats.push(`${rollbackCount} rollbacks`);
 
+  const errNote = lastError
+    ? `last error ${relativeTime(lastError)}${lastErrorCode ? ` (${lastErrorCode})` : ''}`
+    : 'has errors';
+
   let summary;
   if (lastSend) {
     summary = `last send ${relativeTime(lastSend)}`;
     if (stats.length > 0) summary += ` (${stats.join(', ')})`;
-    if (hasErrors) summary += ', has errors';
+    if (hasErrors) summary += recovered ? `, recovered — ${errNote}` : `, ${errNote}`;
   } else if (hasErrors) {
-    summary = 'errors in log';
+    summary = `errors in log — ${errNote}`;
     if (stats.length > 0) summary += ` (${stats.join(', ')})`;
   } else {
     summary = `${lines.length} entries`;
@@ -660,10 +689,11 @@ function checkSenderLog() {
   }
 
   const last20 = lines.slice(-20);
+  const state = activeErrors ? 'ACTIVE ERRORS' : recovered ? 'recovered' : 'healthy';
   return {
-    ok: !hasErrors,
+    ok: !activeErrors,
     summary,
-    detail: `Log: ${LOG_PATH}\nTotal entries: ${lines.length}\nCounters: sent_ok=${sentOk}, failed=${failedCount}, rollbacks=${rollbackCount}\nLast 20 entries:\n${last20.join('\n')}`,
+    detail: `Log: ${LOG_PATH}\nTotal entries: ${lines.length}\nCounters: sent_ok=${sentOk}, failed=${failedCount} (${recentFailed} in 24h), rollbacks=${rollbackCount}\nLast send: ${lastSend || '(never)'}\nLast error: ${lastError || '(none)'}${lastErrorCode ? ` (${lastErrorCode})` : ''}\nState: ${state}\nLast 20 entries:\n${last20.join('\n')}`,
   };
 }
 
@@ -816,31 +846,46 @@ async function checkServer(serverUrl) {
   }
 
   const url = `${serverUrl}/api/health`;
-  const start = Date.now();
-  try {
-    const res = await fetch(url, { signal: AbortSignal.timeout(8000) });
-    const latency = Date.now() - start;
-    const body = await res.text();
-    if (res.ok) {
+  // A single probe times out on a transient network blip (VPN reconnect, brief
+  // packet loss) and flags the server red even when it's actually fine. Retry a
+  // few times with a short backoff before the verdict; an HTTP response (even an
+  // error status) short-circuits — the server answered, no point retrying.
+  const ATTEMPTS = 3;
+  const PER_ATTEMPT_TIMEOUT = 5000;
+  const codes = [];
+  const attemptLog = [];
+  for (let attempt = 1; attempt <= ATTEMPTS; attempt++) {
+    const start = Date.now();
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(PER_ATTEMPT_TIMEOUT) });
+      const latency = Date.now() - start;
+      const body = await res.text();
+      if (res.ok) {
+        const note = attempt > 1 ? `, ${attempt}/${ATTEMPTS} attempts` : '';
+        return {
+          ok: true,
+          summary: `reachable (${latency}ms${note})`,
+          detail: `URL: ${url}\nStatus: ${res.status}\nLatency: ${latency}ms\nAttempt: ${attempt}/${ATTEMPTS}\nResponse: ${body}`,
+        };
+      }
       return {
-        ok: true,
-        summary: `reachable (${latency}ms)`,
+        ok: false,
+        summary: `HTTP ${res.status} (${latency}ms)`,
         detail: `URL: ${url}\nStatus: ${res.status}\nLatency: ${latency}ms\nResponse: ${body}`,
       };
+    } catch (err) {
+      const latency = Date.now() - start;
+      const code = err.code || err.cause?.code || err.message;
+      codes.push(code);
+      attemptLog.push(`#${attempt}: ${code} (${latency}ms)`);
+      if (attempt < ATTEMPTS) await new Promise(r => setTimeout(r, 1000));
     }
-    return {
-      ok: false,
-      summary: `HTTP ${res.status} (${latency}ms)`,
-      detail: `URL: ${url}\nStatus: ${res.status}\nLatency: ${latency}ms\nResponse: ${body}`,
-    };
-  } catch (err) {
-    const latency = Date.now() - start;
-    return {
-      ok: false,
-      summary: `unreachable (${err.code || err.cause?.code || err.message})`,
-      detail: `URL: ${url}\nError: ${err.message}\nLatency: ${latency}ms`,
-    };
   }
+  return {
+    ok: false,
+    summary: `unreachable (${codes[codes.length - 1]}, ${ATTEMPTS} attempts)`,
+    detail: `URL: ${url}\nUnreachable after ${ATTEMPTS} attempts:\n${attemptLog.join('\n')}`,
+  };
 }
 
 async function checkToken(serverUrl, authToken) {
@@ -1097,7 +1142,50 @@ function buildReport(results, timestamp, warnings = [], allTools = TOOL_CONFIGS)
 // Report mode: POST structured status to server
 // ---------------------------------------------------------------------------
 
-async function sendStatusReport(results, warnings, clientVersion, clientCommit, serverUrl, authToken) {
+// AI Lens config (~/.ai-lens/config.json) with the auth token masked, or null if
+// absent/unreadable. Mirrors the masked dump buildReport writes to the local file.
+function maskedAiLensConfig() {
+  try {
+    const raw = readFileSync(join(homedir(), '.ai-lens', 'config.json'), 'utf-8');
+    const config = JSON.parse(raw);
+    if (config.authToken) config.authToken = maskToken(config.authToken);
+    return config;
+  } catch {
+    return null;
+  }
+}
+
+// Hook-config file contents for every tool (Cursor/Claude Code/Codex), both
+// global and project scope, so a single remote report is enough to diagnose hook
+// wiring (actual command form, scope, $CLAUDE_PROJECT_DIR vs %VAR%, missing file)
+// without asking the developer for their local ~/ai-lens-status.txt.
+function collectHookConfigs(allTools) {
+  const entries = [];
+  const readHooks = (tool, scope, path) => {
+    let hooks = null, error = null;
+    try {
+      const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+      hooks = parsed.hooks ?? null;
+      if (hooks === null) error = 'no hooks section';
+    } catch (err) {
+      error = err.code === 'ENOENT' ? 'not found' : err.message;
+    }
+    entries.push({ tool: tool.name, scope, path, hooks, error });
+  };
+  for (const tool of allTools) {
+    const scope = TOOL_CONFIGS.includes(tool) ? 'global' : 'project';
+    readHooks(tool, scope, tool.configPath);
+    // Claude Code keeps a separate settings.local.json (personal/project override)
+    // that can carry or disable hooks — capture it when present.
+    if (tool.name.startsWith('Claude Code') && tool.dirPath) {
+      const localPath = join(tool.dirPath, 'settings.local.json');
+      if (existsSync(localPath)) readHooks(tool, `${scope}-local`, localPath);
+    }
+  }
+  return entries;
+}
+
+async function sendStatusReport(results, warnings, clientVersion, clientCommit, serverUrl, authToken, allTools = TOOL_CONFIGS) {
   if (!serverUrl || !authToken) return;
 
   const payload = {
@@ -1108,6 +1196,12 @@ async function sendStatusReport(results, warnings, clientVersion, clientCommit,
     os: `${process.platform} ${osRelease()} ${osArch()}`,
     checks: results.map(({ label, ok, summary, detail }) => ({ label, ok, summary, detail })),
     warnings: warnings.map(({ msg, action }) => ({ msg, action })),
+    // Config + hook dumps (token masked) — the local-file-only sections, now also
+    // sent so remote triage doesn't need the developer's ~/ai-lens-status.txt.
+    configs: {
+      ai_lens: maskedAiLensConfig(),
+      hooks: collectHookConfigs(allTools),
+    },
   };
 
   try {
@@ -1332,16 +1426,18 @@ export default async function status({ report = false } = {}) {
     }
   }
 
+  // Global TOOL_CONFIGS (always listed, even if not installed) + project tools.
+  // Used by both report modes: the server JSON config dump and the local text file.
+  const allToolsForReport = [...TOOL_CONFIGS, ...toolsWithProject.filter(t => !TOOL_CONFIGS.includes(t))];
+
   if (report) {
     // --report mode: same on-screen output as normal status, but POST the
     // structured JSON to the server instead of writing the local text file.
-    await sendStatusReport(results, warnings, version, commit, serverUrl, authToken);
+    await sendStatusReport(results, warnings, version, commit, serverUrl, authToken, allToolsForReport);
     blank();
   } else {
     // Normal mode: write text report file
     const timestamp = new Date().toISOString();
-    // Merge global TOOL_CONFIGS (always listed, even if not installed) with project tools
-    const allToolsForReport = [...TOOL_CONFIGS, ...toolsWithProject.filter(t => !TOOL_CONFIGS.includes(t))];
     const reportText = buildReport(results, timestamp, warnings, allToolsForReport);
     try {
       writeFileSync(REPORT_PATH, reportText);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-lens",
-  "version": "0.8.80",
+  "version": "0.8.81",
   "type": "module",
   "description": "Centralized session analytics for AI coding tools",
   "bin": {