ai-lens 0.7.2 → 0.7.3

package/.commithash

@@ -1 +1 @@
-13ac046
+75f2d5f

package/README.md

@@ -11,7 +11,7 @@ Hook fires → capture.js → normalize → queue.jsonl → sender.js → POST /
 Run the init command on each developer machine:
 
 ```bash
-npx ai-lens init
+npx -y ai-lens init
 ```
 
 This will:

package/cli/init.js

@@ -9,6 +9,7 @@ import {
   initLogger, info, success, warn, error,
   heading, detail, blank, getLogPath,
 } from './logger.js';
+import { getGitIdentity } from '../client/config.js';
 import {
   CAPTURE_PATH, detectInstalledTools,
   analyzeToolHooks, buildMergedConfig, writeHooksConfig, describePlan,
@@ -226,6 +227,38 @@ async function deviceCodeAuth(serverUrl) {
   throw new Error('Device code expired. Please try again.');
 }
 
+/**
+ * Validate an existing auth token against the server.
+ * Returns true if token is valid, false if invalid/revoked/unreachable.
+ */
+async function validateExistingToken(serverUrl, token) {
+  if (!token || !token.startsWith('ailens_dev_')) return false;
+  try {
+    const parsed = new URL(`${serverUrl}/api/auth/verify`);
+    const isHttps = parsed.protocol === 'https:';
+    const requestFn = isHttps ? httpsRequest : httpRequest;
+    const status = await new Promise((resolve, reject) => {
+      const req = requestFn({
+        hostname: parsed.hostname,
+        port: parsed.port || (isHttps ? 443 : 80),
+        path: parsed.pathname,
+        method: 'GET',
+        headers: { 'X-Auth-Token': token },
+        timeout: 10_000,
+      }, (res) => {
+        res.resume();
+        resolve(res.statusCode);
+      });
+      req.on('error', reject);
+      req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+      req.end();
+    });
+    return status === 200;
+  } catch {
+    return false;
+  }
+}
+
 // =============================================================================
 // CLI flags for non-interactive mode
 // =============================================================================
@@ -277,7 +310,7 @@ export default async function init() {
   if (tools.length === 0) {
     warn('No supported AI tools detected.');
     info('Looked for ~/.claude/ and ~/.cursor/ directories.');
-    info('Install Claude Code or Cursor, then re-run: npx ai-lens init');
+    info('Install Claude Code or Cursor, then re-run: npx -y ai-lens init');
     return;
   }
 
@@ -334,6 +367,16 @@ export default async function init() {
 
   // Authentication
   heading('Authentication');
+  if (currentConfig.authToken) {
+    const valid = await validateExistingToken(serverUrl, currentConfig.authToken);
+    if (valid) {
+      success('  Already authenticated (token verified)');
+    } else {
+      warn('  Existing token is invalid or revoked — re-authenticating...');
+      currentConfig.authToken = null;
+      newConfig.authToken = null;
+    }
+  }
   if (!currentConfig.authToken) {
     try {
       const result = await deviceCodeAuth(serverUrl);
@@ -348,8 +391,6 @@ export default async function init() {
         return;
       }
     }
-  } else {
-    success('  Already authenticated (token present)');
   }
   blank();
 
@@ -594,6 +635,64 @@ export default async function init() {
       } catch (err) {
         warn(`  Token: could not verify — ${err.message}`);
       }
+
+      // 3. E2E: POST a test event
+      try {
+        const { name: gitName, email: gitEmail } = getGitIdentity();
+        const testEvent = [{
+          source: 'cli',
+          session_id: `e2e-test-${Date.now()}`,
+          type: 'E2eTest',
+          timestamp: new Date().toISOString(),
+          project_path: process.cwd(),
+          data: { trigger: 'init' },
+        }];
+        const headers = {
+          'Content-Type': 'application/json',
+          'X-Auth-Token': finalConfig.authToken,
+        };
+        if (gitEmail) headers['X-Developer-Git-Email'] = gitEmail;
+        if (gitName) headers['X-Developer-Name'] = gitName;
+
+        const parsed = new URL(`${verifyUrl}/api/events`);
+        const isHttps = parsed.protocol === 'https:';
+        const requestFn = isHttps ? httpsRequest : httpRequest;
+        const data = JSON.stringify(testEvent);
+        headers['Content-Length'] = String(Buffer.byteLength(data));
+
+        const e2eBody = await new Promise((resolve, reject) => {
+          const req = requestFn({
+            hostname: parsed.hostname,
+            port: parsed.port || (isHttps ? 443 : 80),
+            path: parsed.pathname,
+            method: 'POST',
+            headers,
+            timeout: 10_000,
+          }, (res) => {
+            let buf = '';
+            res.on('data', (chunk) => { buf += chunk; });
+            res.on('end', () => {
+              try {
+                resolve({ status: res.statusCode, data: JSON.parse(buf) });
+              } catch {
+                reject(new Error(`Server responded ${res.statusCode}: ${buf}`));
+              }
+            });
+          });
+          req.on('error', reject);
+          req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+          req.write(data);
+          req.end();
+        });
+
+        if (e2eBody.status === 200 && e2eBody.data.received >= 1) {
+          success('  E2E: event accepted by server');
+        } else {
+          error(`  E2E: unexpected response (HTTP ${e2eBody.status})`);
+        }
+      } catch (err) {
+        error(`  E2E: ${err.message}`);
+      }
     }
   } else {
     warn('  No server URL configured — skipping verification');

package/cli/status.js

@@ -4,7 +4,7 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 
 import { getVersionInfo, readLensConfig, detectInstalledTools, analyzeToolHooks, CAPTURE_PATH, TOOL_CONFIGS } from './hooks.js';
-import { DATA_DIR, QUEUE_PATH, LOG_PATH, getGitIdentity } from '../client/config.js';
+import { DATA_DIR, QUEUE_PATH, LOG_PATH, CAPTURE_LOG_PATH, getGitIdentity } from '../client/config.js';
 import { initLogger, info, success, warn, error, heading, blank } from './logger.js';
 
 // ANSI helpers
@@ -286,6 +286,48 @@ function checkSenderLog() {
   };
 }
 
+function checkCaptureLog() {
+  if (!existsSync(CAPTURE_LOG_PATH)) {
+    return { ok: true, summary: 'no drops logged', detail: 'Capture log does not exist (no events dropped)' };
+  }
+
+  let lines;
+  try {
+    lines = readFileSync(CAPTURE_LOG_PATH, 'utf-8').split('\n').filter(Boolean);
+  } catch (err) {
+    return { ok: false, summary: `error reading log: ${err.message}`, detail: `Error: ${err.message}` };
+  }
+
+  // Count entries by category (reason for drops, msg for errors)
+  const counts = {};
+  let lastTs = null;
+  let hasErrors = false;
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      const category = entry.reason || entry.msg || 'unknown';
+      counts[category] = (counts[category] || 0) + 1;
+      lastTs = entry.ts;
+      if (entry.msg) hasErrors = true;
+    } catch { /* non-JSON line */ }
+  }
+
+  const total = lines.length;
+  const breakdown = Object.entries(counts).map(([r, n]) => `${r}: ${n}`).join(', ');
+
+  let summary = `${total} entries`;
+  if (breakdown) summary += ` (${breakdown})`;
+  if (lastTs) summary += `, last ${relativeTime(lastTs)}`;
+
+  const last10 = lines.slice(-10);
+
+  return {
+    ok: !hasErrors,
+    summary,
+    detail: `Log: ${CAPTURE_LOG_PATH}\nTotal: ${total}\n\nLast 10 entries:\n${last10.join('\n')}`,
+  };
+}
+
 async function checkServer(serverUrl) {
   if (!serverUrl) {
     return { ok: false, summary: 'no server URL configured', detail: 'Cannot check server: no serverUrl in config' };
@@ -340,6 +382,44 @@ async function checkToken(serverUrl, authToken) {
   }
 }
 
+async function checkE2e(serverUrl, authToken) {
+  if (!serverUrl || !authToken) {
+    const missing = !serverUrl ? 'server URL' : 'auth token';
+    return { ok: false, summary: `no ${missing} configured`, detail: `Cannot run E2E test: missing ${missing}` };
+  }
+
+  const { name, email } = getGitIdentity();
+  const testEvent = [{
+    source: 'cli',
+    session_id: `e2e-test-${Date.now()}`,
+    type: 'E2eTest',
+    timestamp: new Date().toISOString(),
+    project_path: process.cwd(),
+    data: { trigger: 'status' },
+  }];
+
+  const url = `${serverUrl}/api/events`;
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Auth-Token': authToken,
+        ...(email && { 'X-Developer-Git-Email': email }),
+        ...(name && { 'X-Developer-Name': name }),
+      },
+      body: JSON.stringify(testEvent),
+    });
+    const body = await res.json();
+    if (res.ok && body.received >= 1) {
+      return { ok: true, summary: 'event accepted', detail: `POST ${url} → ${res.status}, received: ${body.received}` };
+    }
+    return { ok: false, summary: `unexpected response (${res.status})`, detail: `POST ${url} → ${res.status}\nBody: ${JSON.stringify(body)}` };
+  } catch (err) {
+    return { ok: false, summary: `failed (${err.message})`, detail: `POST ${url}\nError: ${err.message}` };
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Report file generation
 // ---------------------------------------------------------------------------
@@ -423,6 +503,20 @@ function buildReport(results, timestamp) {
   }
   lines.push('');
 
+  // Capture drops log (last 100 lines)
+  lines.push(`${'='.repeat(60)}`);
+  lines.push(`Capture drops (${CAPTURE_LOG_PATH}):`);
+  try {
+    const capLines = readFileSync(CAPTURE_LOG_PATH, 'utf-8').split('\n').filter(Boolean);
+    lines.push(`Total: ${capLines.length} drops`);
+    for (const cl of capLines.slice(-100)) {
+      lines.push(cl);
+    }
+  } catch {
+    lines.push('(not found)');
+  }
+  lines.push('');
+
   return lines.join('\n');
 }
 
@@ -498,6 +592,9 @@ export default async function status() {
   // 8. Sender log
   printLine('Sender log', checkSenderLog());
 
+  // 8b. Capture drops
+  printLine('Capture drops', checkCaptureLog());
+
   // 9. Server connectivity
   const serverUrl = configResult.serverUrl || readLensConfig().serverUrl;
   const serverResult = await checkServer(serverUrl);
@@ -508,6 +605,10 @@ export default async function status() {
   const tokenResult = await checkToken(serverUrl, authToken);
   printLine('Token', tokenResult);
 
+  // 11. E2E connectivity test
+  const e2eResult = await checkE2e(serverUrl, authToken);
+  printLine('E2E test', e2eResult);
+
   // Write report file
   const timestamp = new Date().toISOString();
   const report = buildReport(results, timestamp);

package/client/capture.js

@@ -17,6 +17,8 @@ import {
   QUEUE_PATH,
   SESSION_PATHS_PATH,
   LAST_EVENTS_PATH,
+  CAPTURE_LOG_PATH,
+  captureLog,
   getServerUrl,
   getGitIdentity,
   getGitMetadata,
@@ -31,6 +33,13 @@ try {
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
+function logDrop(reason, meta = {}) {
+  try {
+    const entry = { ts: new Date().toISOString(), reason, ...meta };
+    appendFileSync(CAPTURE_LOG_PATH, JSON.stringify(entry) + '\n');
+  } catch { /* best-effort */ }
+}
+
 // =============================================================================
 // Truncation (reused from ai-session-lens prompts.js approach)
 // =============================================================================
@@ -117,7 +126,9 @@ function cacheSessionPath(sessionId, projectPath) {
   const paths = loadSessionPaths();
   if (paths[sessionId] !== projectPath) {
     paths[sessionId] = projectPath;
-    saveSessionPaths(paths);
+    try {
+      saveSessionPaths(paths);
+    } catch { /* cache write failed — event proceeds without cached path */ }
   }
 }
 
@@ -159,7 +170,9 @@ export function isDuplicateEvent(sessionId, type) {
   const dominated = DEDUP_TYPES.has(type) && prev === type;
   if (prev !== type) {
     cache[sessionId] = type;
-    saveLastEvents(cache);
+    try {
+      saveLastEvents(cache);
+    } catch { /* dedup cache write failed — proceed with stale state */ }
   }
   return dominated;
 }
@@ -322,7 +335,12 @@ function normalizeCursor(event) {
   const hookName = event.hook_event_name;
   const type = CURSOR_TYPE_MAP[hookName] || hookName;
   const timestamp = new Date().toISOString();
-  const projectPath = Array.isArray(event.workspace_roots) ? event.workspace_roots[0] : null;
+  let projectPath = Array.isArray(event.workspace_roots) ? event.workspace_roots[0] : null;
+  if (projectPath) {
+    cacheSessionPath(sessionId, projectPath);
+  } else {
+    projectPath = getCachedSessionPath(sessionId);
+  }
 
   let data = {};
   switch (hookName) {
@@ -494,18 +512,20 @@ async function main() {
 
   const unified = normalizeEvent(event);
   if (!unified || !unified.session_id) {
-    // Unknown source or no session_id — drop
+    logDrop('normalize_failed', { hook: event.hook_event_name });
     process.exit(0);
   }
 
   // Deduplicate consecutive identical event types (e.g. repeated Stop from idle sessions)
   if (isDuplicateEvent(unified.session_id, unified.type)) {
+    logDrop('duplicate', { type: unified.type, session_id: unified.session_id });
     process.exit(0);
   }
 
   // Filter by monitored projects (if configured)
   const monitored = getMonitoredProjects();
   if (monitored && !monitored.some(p => unified.project_path === p || unified.project_path?.startsWith(p + '/'))) {
+    logDrop('project_filter', { type: unified.type, source: unified.source, session_id: unified.session_id, project_path: unified.project_path, monitored });
     process.exit(0);
   }
 
@@ -513,6 +533,7 @@ async function main() {
   const identity = getGitIdentity();
   const email = identity.email || event.user_email || null;
   if (!email) {
+    logDrop('no_email', { type: unified.type, session_id: unified.session_id });
     process.exit(0);
   }
   unified.developer_email = email;
@@ -525,14 +546,27 @@ async function main() {
   unified.git_commit = gitMeta.git_commit;
 
   // Append to queue
-  appendToQueue(unified);
+  try {
+    appendToQueue(unified);
+  } catch (err) {
+    captureLog({ msg: 'queue-write-failed', error: err.message, type: unified.type, session_id: unified.session_id });
+    process.exit(1);
+  }
 
   // Always try to spawn sender — atomic rename in sender handles dedup
-  trySpawnSender();
+  try {
+    trySpawnSender();
+  } catch (err) {
+    captureLog({ msg: 'sender-spawn-failed', error: err.message });
+    // event is queued — sender will be spawned on next capture
+  }
 }
 
 // Only run main when executed directly (not when imported for testing)
 const isDirectRun = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
 if (isDirectRun) {
-  main().catch(() => process.exit(0));
+  main().catch((err) => {
+    try { captureLog({ msg: 'capture-error', error: err.message }); } catch {}
+    process.exit(1);
+  });
 }

package/client/config.js

@@ -11,12 +11,20 @@ export const SESSION_PATHS_PATH = join(DATA_DIR, 'session-paths.json');
 export const GIT_REMOTES_PATH = join(DATA_DIR, 'git-remotes.json');
 export const LAST_EVENTS_PATH = join(DATA_DIR, 'last-events.json');
 export const LOG_PATH = join(DATA_DIR, 'sender.log');
+export const CAPTURE_LOG_PATH = join(DATA_DIR, 'capture.log');
 
 export function log(fields) {
   const entry = { ts: new Date().toISOString(), ...fields };
   appendFileSync(LOG_PATH, JSON.stringify(entry) + '\n');
 }
 
+export function captureLog(fields) {
+  const entry = { ts: new Date().toISOString(), ...fields };
+  try {
+    appendFileSync(CAPTURE_LOG_PATH, JSON.stringify(entry) + '\n');
+  } catch { /* last resort — disk may be full */ }
+}
+
 let _configCache;
 function loadConfig() {
   if (_configCache !== undefined) return _configCache;
@@ -52,10 +60,8 @@ export function getMonitoredProjects() {
     .map(p => p.endsWith('/') ? p.slice(0, -1) : p);
 }
 
-const DEFAULT_AUTH_TOKEN = 'collector:secret-collector-token-2026-ai-lens';
-
 export function getAuthToken() {
-  return process.env.AI_LENS_AUTH_TOKEN || loadConfig().authToken || DEFAULT_AUTH_TOKEN;
+  return process.env.AI_LENS_AUTH_TOKEN || loadConfig().authToken || null;
 }
 
 export function getGitIdentity() {

package/client/sender.js

@@ -84,24 +84,43 @@ export function buildRollbackContent(unsentContent, existingContent) {
  * renameSync is atomic on POSIX — acts as a mutex.
  * Returns { events, sendingPath } or null if nothing to send.
  */
-function acquireQueue() {
+/**
+ * @param {string} [queuePath] - Override queue path (for testing); defaults to QUEUE_PATH
+ * @param {string} [sendingPath] - Override sending path (for testing); defaults to SENDING_PATH
+ */
+export function acquireQueue(queuePath = QUEUE_PATH, sendingPath = SENDING_PATH) {
+  // Recover orphaned sending file from a previously crashed sender
   try {
-    renameSync(QUEUE_PATH, SENDING_PATH);
+    const orphaned = readFileSync(sendingPath, 'utf-8');
+    if (orphaned.trim()) {
+      let existing = '';
+      try { existing = readFileSync(queuePath, 'utf-8'); } catch { /* no queue yet */ }
+      writeFileSync(queuePath, orphaned + existing);
+      log({ msg: 'orphan-recovered', bytes: Buffer.byteLength(orphaned) });
+    }
+    unlinkSync(sendingPath);
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+    // No orphan — normal path
+  }
+
+  try {
+    renameSync(queuePath, sendingPath);
   } catch (err) {
     if (err.code === 'ENOENT') return null; // no queue or another sender got it
     throw err;
   }
 
-  const content = readFileSync(SENDING_PATH, 'utf-8');
+  const content = readFileSync(sendingPath, 'utf-8');
   const { events, dropped, overflow } = parseQueueContent(content);
   if (dropped > 0) log({ msg: 'queue-corruption', dropped });
   if (overflow > 0) log({ msg: 'queue-overflow', dropped: overflow, kept: MAX_QUEUE_SIZE });
   if (events.length === 0) {
-    unlinkSync(SENDING_PATH);
+    unlinkSync(sendingPath);
     return null;
   }
 
-  return { events, sendingPath: SENDING_PATH };
+  return { events, sendingPath };
 }
 
 /**
@@ -289,6 +308,9 @@ async function main() {
     const unsentEvents = events.filter(e => !sentEventIds.has(e.event_id));
     partialRollback(sendingPath, unsentEvents, events.length);
     log({ msg: 'failed', error: err.message, sent: events.length - unsentEvents.length, unsent: unsentEvents.length, server: serverUrl });
+    if (err.message.includes('401')) {
+      log({ msg: 'auth-failed', error: 'Token invalid or revoked. Run: npx -y ai-lens init' });
+    }
   }
 }
 

package/package.json

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