ai-lens 0.7.5 → 0.8.2

package/.commithash

@@ -1 +1 @@
-7c3d9b5
+1dfdd25

package/cli/hooks.js

@@ -60,7 +60,7 @@ export function shellEscape(str) {
 
 function captureCommand() {
   const escaped = shellEscape(CAPTURE_PATH);
-  return `${shellEscape(process.execPath)} ${escaped} || node ${escaped}`;
+  return `${shellEscape(process.execPath)} ${escaped}`;
 }
 
 // ---------------------------------------------------------------------------

package/cli/init.js

@@ -371,7 +371,7 @@ export default async function init() {
   if (projects) {
     const home = homedir();
     projects = projects.split(',').map(p => p.trim()).filter(Boolean)
-      .map(p => p.startsWith('~/') ? join(home, p.slice(2)) : resolve(p))
+      .map(p => p === '~' ? home : p.startsWith('~/') ? join(home, p.slice(2)) : resolve(p))
       .join(',');
   }
   if (projects) {
@@ -402,7 +402,9 @@ export default async function init() {
     if (tokenStatus === 'valid') {
       success('  Already authenticated (token verified)');
     } else if (tokenStatus === 'unknown') {
-      warn('  Token format not recognized — keeping existing token');
+      warn('  Token format not recognized — re-authenticating...');
+      currentConfig.authToken = null;
+      newConfig.authToken = null;
     } else if (tokenStatus === 'invalid') {
       warn('  Existing token is invalid or revoked — re-authenticating...');
       currentConfig.authToken = null;

package/cli/status.js

@@ -84,15 +84,22 @@ function checkCaptureRun(installedTools) {
   }
 
   try {
-    execSync(`echo '{}' | ${command}`, {
+    const testEvent = JSON.stringify({
+      hook_event_name: 'Stop',
+      session_id: 'status-check-' + Date.now(),
+      stop_reason: 'test',
+    });
+    const testCmd = `echo '${testEvent.replace(/'/g, "'\\''")}' | ${command}`;
+    execSync(testCmd, {
       encoding: 'utf-8',
       timeout: 10_000,
       stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, AI_LENS_PROJECTS: '/ai-lens-status-check-nonexistent' },
     });
     return {
       ok: true,
       summary: 'capture runs OK',
-      detail: `Ran: echo '{}' | ${command}\nResult: exit 0`,
+      detail: `Ran: ${testCmd}\nResult: exit 0`,
     };
   } catch (err) {
     const stderr = err.stderr?.trim() || err.message;
@@ -264,8 +271,8 @@ function checkSenderLog() {
   for (const line of last20) {
     try {
       const entry = JSON.parse(line);
-      if (entry.msg === 'batch_sent' || entry.msg === 'send_ok') lastSend = entry.ts;
-      if (entry.msg === 'send_error' || entry.msg === 'send_fail' || entry.level === 'error') hasErrors = true;
+      if (entry.msg === 'sent') lastSend = entry.ts;
+      if (entry.msg === 'failed' || entry.msg === 'error' || entry.msg === 'auth-failed') hasErrors = true;
     } catch { /* non-JSON line */ }
   }
 

package/client/capture.js

@@ -7,7 +7,7 @@
  * normalizes to unified event format, appends to queue, spawns sender if needed.
  */
 
-import { readFileSync, writeFileSync, appendFileSync, existsSync, renameSync } from 'node:fs';
+import { readFileSync, writeFileSync, appendFileSync, existsSync, renameSync, realpathSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -26,15 +26,16 @@ import {
   getMonitoredProjects,
 } from './config.js';
 // Soft import — redact.js may not exist on older client installs
-let redactSecrets = (s) => s;
+let redactObject = (o) => o;
 try {
   const mod = await import('./redact.js');
-  redactSecrets = mod.redactSecrets;
+  redactObject = mod.redactObject;
 } catch { /* redact.js not installed yet — skip redaction, server will handle it */ }
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 function logDrop(reason, meta = {}) {
+  if (process.env.AI_LENS_DRY_RUN) return;
   try {
     const entry = { ts: new Date().toISOString(), reason, ...meta };
     appendFileSync(CAPTURE_LOG_PATH, JSON.stringify(entry) + '\n');
@@ -73,13 +74,24 @@ function truncate(text, maxLen) {
   return text.slice(0, end) + ` [...truncated, ${text.length} chars total]`;
 }
 
-function truncateToolInput(input, toolName) {
+function truncateToolInput(input, toolName, depth = 0) {
   if (!input || typeof input !== 'object') return input;
+  if (depth > 5) return input;
+  if (Array.isArray(input)) {
+    return input.map(item => {
+      if (typeof item === 'string') return truncate(item, TRUNCATION_LIMITS.toolInput.default);
+      if (item && typeof item === 'object') return truncateToolInput(item, toolName, depth + 1);
+      return item;
+    });
+  }
   const result = { ...input };
   for (const [key, value] of Object.entries(result)) {
-    if (typeof value !== 'string') continue;
-    const limit = TRUNCATION_LIMITS.toolInput[key] || TRUNCATION_LIMITS.toolInput.default;
-    result[key] = truncate(value, limit);
+    if (typeof value === 'string') {
+      const limit = TRUNCATION_LIMITS.toolInput[key] || TRUNCATION_LIMITS.toolInput.default;
+      result[key] = truncate(value, limit);
+    } else if (value && typeof value === 'object') {
+      result[key] = truncateToolInput(value, toolName, depth + 1);
+    }
   }
   return result;
 }
@@ -280,7 +292,7 @@ function normalizeClaudeCode(event) {
       data = {
         tool: failedTool,
         input: truncateToolInput(event.tool_input || event.input, failedTool),
-        error: truncate(event.error || '', TRUNCATION_LIMITS.toolResult),
+        error: truncate(event.error || '', TRUNCATION_LIMITS.toolResult[failedTool] || TRUNCATION_LIMITS.toolResult.default),
       };
       const failMcp = event.mcp_server || (failedTool.startsWith('mcp__') ? failedTool.split('__')[1] : null);
       if (failMcp) data.mcp_server = failMcp;
@@ -356,9 +368,11 @@ function pickWorkspaceRoot(roots) {
   if (valid.length === 1) return valid[0];
   const monitored = getMonitoredProjects();
   if (monitored) {
-    const match = valid.find(root =>
-      monitored.some(p => root === p || root.startsWith(p + '/'))
-    );
+    const match = valid.find(root => {
+      let resolved = root;
+      try { resolved = realpathSync(root); } catch {}
+      return monitored.some(p => resolved === p || resolved.startsWith(p + '/'));
+    });
     if (match) return match;
   }
   return valid[0];
@@ -495,13 +509,10 @@ export function normalizeEvent(event) {
 // =============================================================================
 
 function appendToQueue(unified) {
-  // Redact secrets from data and raw before writing to queue
-  if (unified.data) {
-    unified.data = JSON.parse(redactSecrets(JSON.stringify(unified.data)));
-  }
-  if (unified.raw) {
-    unified.raw = JSON.parse(redactSecrets(JSON.stringify(unified.raw)));
-  }
+  // Redact secrets from individual string values (not serialized JSON)
+  // to prevent regex patterns from matching across JSON structural boundaries
+  if (unified.data) unified.data = redactObject(unified.data);
+  if (unified.raw) unified.raw = redactObject(unified.raw);
   appendFileSync(QUEUE_PATH, JSON.stringify(unified) + '\n');
 }
 
@@ -557,10 +568,13 @@ async function main() {
 
   // Filter by monitored projects (if configured)
   const monitored = getMonitoredProjects();
-  if (monitored && unified.project_path && !monitored.some(p => unified.project_path === p || unified.project_path.startsWith(p + '/'))) {
+  let projectPath = unified.project_path;
+  try { projectPath = realpathSync(projectPath); } catch {}
+  if (monitored && projectPath && !monitored.some(p => projectPath === p || projectPath.startsWith(p + '/'))) {
     // Fallback: for Cursor multi-root workspaces, check if any raw workspace_roots entry matches
     const roots = Array.isArray(event.workspace_roots) ? event.workspace_roots : [];
-    if (!roots.some(root => monitored.some(p => root === p || root.startsWith(p + '/')))) {
+    const resolvedRoots = roots.map(r => { try { return realpathSync(r); } catch { return r; } });
+    if (!resolvedRoots.some(root => monitored.some(p => root === p || root.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);
     }
@@ -568,7 +582,7 @@ async function main() {
 
   // Resolve identity: git first, then fall back to event payload (e.g. Cursor's user_email)
   // When auth token is present, server resolves developer from token — email is optional
-  const identity = getGitIdentity();
+  const identity = getGitIdentity(unified.project_path);
   const hasAuthToken = !!getAuthToken();
   const resolved = resolveIdentity(identity, event, hasAuthToken);
   if (!resolved.proceed) {

package/client/config.js

@@ -1,4 +1,4 @@
-import { mkdirSync, appendFileSync, readFileSync, writeFileSync, existsSync, renameSync } from 'node:fs';
+import { mkdirSync, appendFileSync, readFileSync, writeFileSync, existsSync, renameSync, realpathSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
@@ -19,6 +19,7 @@ export function log(fields) {
 }
 
 export function captureLog(fields) {
+  if (process.env.AI_LENS_DRY_RUN) return;
   const entry = { ts: new Date().toISOString(), ...fields };
   try {
     appendFileSync(CAPTURE_LOG_PATH, JSON.stringify(entry) + '\n');
@@ -64,8 +65,9 @@ export function getMonitoredProjects() {
   if (paths.length === 0) return null;
   const home = homedir();
   return paths
-    .map(p => p.startsWith('~/') ? join(home, p.slice(2)) : p)
+    .map(p => p === '~' ? home : p.startsWith('~/') ? join(home, p.slice(2)) : p)
     .map(p => resolve(p))
+    .map(p => { try { return realpathSync(p); } catch { return p; } })
     .map(p => p.endsWith('/') ? p.slice(0, -1) : p);
 }
 
@@ -73,18 +75,20 @@ export function getAuthToken() {
   return process.env.AI_LENS_AUTH_TOKEN || loadConfig().authToken || null;
 }
 
-export function getGitIdentity() {
+export function getGitIdentity(cwd) {
   let email = null;
   let name = null;
+  const opts = { encoding: 'utf-8', timeout: 3000 };
+  if (cwd) opts.cwd = cwd;
 
   try {
-    email = execSync('git config user.email', { encoding: 'utf-8', timeout: 3000 }).trim();
+    email = execSync('git config user.email', opts).trim();
   } catch (err) {
     captureLog({ msg: 'git-email-failed', error: err.message?.split('\n')[0] });
   }
 
   try {
-    name = execSync('git config user.name', { encoding: 'utf-8', timeout: 3000 }).trim();
+    name = execSync('git config user.name', opts).trim();
   } catch {
     // git name missing is non-critical — email or token is sufficient
   }

package/client/redact.js

@@ -75,3 +75,20 @@ export function redactSecrets(str) {
   }
   return result;
 }
+
+/**
+ * Recursively redact secrets from individual string leaf values in an object.
+ * Prevents regex patterns from matching across JSON structural boundaries.
+ */
+export function redactObject(obj) {
+  if (typeof obj === 'string') return redactSecrets(obj);
+  if (Array.isArray(obj)) return obj.map(redactObject);
+  if (obj && typeof obj === 'object') {
+    const result = {};
+    for (const [k, v] of Object.entries(obj)) {
+      result[k] = redactObject(v);
+    }
+    return result;
+  }
+  return obj;
+}

package/client/sender.js

@@ -25,6 +25,15 @@ import {
 
 export const MAX_QUEUE_SIZE = 10_000;
 export const MAX_CHUNK_BYTES = 4 * 1024 * 1024; // 4 MB per POST (Express limit is 50 MB)
+export const LOCK_MAX_AGE_MS = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Refresh lock timestamp to prevent false staleness during long sends.
+ * Called after each chunk POST to keep the lock fresh.
+ */
+export function refreshLock(lockPath) {
+  try { writeFileSync(lockPath, `${process.pid}\n${Date.now()}`); } catch {}
+}
 
 /**
  * Parse queue file content into events array.
@@ -93,14 +102,20 @@ export function buildRollbackContent(unsentContent, existingContent) {
 }
 
 /**
- * Check if a sender lock file is stale (owner process no longer running).
- * Returns true if lock is missing or process is dead.
+ * Check if a sender lock file is stale (owner process no longer running or lock too old).
+ * Lock format: "<pid>\n<timestamp>" (backward-compat: old "<pid>" treated as stale).
+ * Returns true if lock is missing, process is dead, or lock exceeds LOCK_MAX_AGE_MS.
  */
 export function isLockStale(lockPath) {
   try {
-    const pid = parseInt(readFileSync(lockPath, 'utf-8').trim(), 10);
+    const content = readFileSync(lockPath, 'utf-8').trim();
+    const lines = content.split('\n');
+    const pid = parseInt(lines[0], 10);
+    const lockTime = parseInt(lines[1], 10);
+    // Old format (no timestamp) or expired → stale regardless of PID liveness
+    if (!lockTime || Date.now() - lockTime > LOCK_MAX_AGE_MS) return true;
     process.kill(pid, 0); // throws if process doesn't exist
-    return false; // process alive — lock is active
+    return false; // process alive and lock fresh — active
   } catch (err) {
     if (err.code === 'ESRCH') return true; // process dead — stale
     if (err.code === 'ENOENT') return true; // no lock file
@@ -124,6 +139,19 @@ export function mergeToQueue(unsentContent, queuePath) {
     if (err.code !== 'ENOENT') throw err;
     // No queue existed — nothing to drain
   }
+  // Retry-drain: capture.js may have created a new queue.jsonl between the
+  // initial drain and this rename. Loop to absorb any newly appeared file,
+  // narrowing the race window to a single renameSync syscall.
+  for (let i = 0; i < 3; i++) {
+    try {
+      renameSync(queuePath, drainPath);
+      appendFileSync(tmpPath, readFileSync(drainPath, 'utf-8'));
+      unlinkSync(drainPath);
+    } catch (err) {
+      if (err.code === 'ENOENT') break;
+      throw err;
+    }
+  }
   renameSync(tmpPath, queuePath);
 }
 
@@ -165,8 +193,8 @@ export function acquireQueue(queuePath = QUEUE_PATH, sendingPath = SENDING_PATH)
     throw err;
   }
 
-  // Write PID lock so other senders know we're active
-  writeFileSync(lockPath, String(process.pid));
+  // Write PID + timestamp lock so other senders know we're active
+  writeFileSync(lockPath, `${process.pid}\n${Date.now()}`);
 
   const content = readFileSync(sendingPath, 'utf-8');
   const { events, dropped, overflow } = parseQueueContent(content);
@@ -258,6 +286,31 @@ export function chunkEvents(events, maxBytes = MAX_CHUNK_BYTES) {
   return chunks;
 }
 
+/**
+ * Filter out oversized events, salvaging those with a `raw` field by stripping it.
+ * Returns { sendable, droppedIds } where droppedIds contains event_ids of permanently dropped events.
+ */
+export function filterOversized(batch, maxBytes = MAX_CHUNK_BYTES) {
+  const sendable = [];
+  const droppedIds = new Set();
+  for (const evt of batch) {
+    let evtBytes = Buffer.byteLength(JSON.stringify(evt));
+    if (evtBytes > maxBytes && evt.raw !== undefined) {
+      const originalBytes = evtBytes;
+      delete evt.raw;
+      evtBytes = Buffer.byteLength(JSON.stringify(evt));
+      log({ msg: 'stripped-raw-oversized', event_id: evt.event_id, type: evt.type, original_bytes: originalBytes, stripped_bytes: evtBytes });
+    }
+    if (evtBytes > maxBytes) {
+      log({ msg: 'skip-oversized', event_id: evt.event_id, type: evt.type, bytes: evtBytes, limit: maxBytes });
+      if (evt.event_id) droppedIds.add(evt.event_id);
+    } else {
+      sendable.push(evt);
+    }
+  }
+  return { sendable, droppedIds };
+}
+
 /**
  * POST events to server using Node.js stdlib.
  */
@@ -276,12 +329,8 @@ function postEvents(serverUrl, events, identity) {
     if (identity.name) headers['X-Developer-Name'] = encodeURIComponent(identity.name);
 
     const authToken = getAuthToken();
-    if (authToken) {
-      if (authToken.startsWith('ailens_dev_')) {
-        headers['X-Auth-Token'] = authToken;
-      } else {
-        headers['Authorization'] = 'Basic ' + Buffer.from(authToken).toString('base64');
-      }
+    if (authToken && authToken.startsWith('ailens_dev_')) {
+      headers['X-Auth-Token'] = authToken;
     }
 
     const options = {
@@ -340,21 +389,14 @@ async function main() {
 
   try {
     for (const { identity, events: batch } of byDeveloper.values()) {
-      // Filter out individual oversized events before chunking
-      const sendable = [];
-      for (const evt of batch) {
-        const evtBytes = Buffer.byteLength(JSON.stringify(evt));
-        if (evtBytes > MAX_CHUNK_BYTES) {
-          log({ msg: 'skip-oversized', event_id: evt.event_id, type: evt.type, bytes: evtBytes, limit: MAX_CHUNK_BYTES });
-          if (evt.event_id) sentEventIds.add(evt.event_id);
-        } else {
-          sendable.push(evt);
-        }
-      }
+      // Filter out individual oversized events before chunking (strip raw to salvage)
+      const { sendable, droppedIds } = filterOversized(batch);
+      for (const id of droppedIds) sentEventIds.add(id);
       const chunks = chunkEvents(sendable);
       let totalReceived = 0;
       for (const chunk of chunks) {
         const result = await postEvents(serverUrl, chunk, identity);
+        refreshLock(sendingPath + '.lock');
         totalReceived += result.received;
         if (result.skipped > 0) {
           log({ msg: 'server-skipped', skipped: result.skipped, chunk_size: chunk.length, developer: identity.email });

package/package.json

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