ai-lens 0.8.81 → 0.8.84

package/.commithash

@@ -1 +1 @@
-0533332
+8a405c3

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 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.84 — 2026-06-08
+- fix: `ai-lens init` no longer wipes your saved auth token when a re-authentication is started but not finished — a closed browser, a timeout, or a transient server hiccup that briefly mis-flags a valid token. Previously this left `authToken: null` in your config and silently stopped all event capture until someone noticed; now the existing token is kept until a new one is actually obtained. If a server that requires auth does end up without a token, init now prints a loud "capture is OFF" error instead of a quiet note.
+
+## 0.8.83 — 2026-06-05
+- fix: on Windows, a Claude Code project hook written with the macOS/Linux `$CLAUDE_PROJECT_DIR` syntax silently captures nothing (Windows needs `%CLAUDE_PROJECT_DIR%`). `ai-lens init` now detects this for per-machine (gitignored) hook files and rewrites it to the running OS's form, and `ai-lens status` flags it instead of showing it as fine. Committed shared hook files are left untouched.
+
+## 0.8.82 — 2026-06-05
+- feat: `ai-lens init` now offers to import your local Claude Code history right away, so a fresh dashboard isn't empty — `npx -y ai-lens init --server <url>` sets up and (on confirm) imports in one step. Use `--no-import` to skip or `--import` to force.
+- fix: `ai-lens import claude-code` works on a self-host instance without login (personal mode) — it ships via your git identity, the same way live capture does, instead of requiring a token.
+
 ## 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.

package/cli/hooks.js

@@ -2,6 +2,7 @@ import { existsSync, lstatSync, readFileSync, writeFileSync, copyFileSync, renam
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
+import { execFileSync } from 'node:child_process';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PKG_ROOT = join(__dirname, '..');
@@ -934,20 +935,59 @@ function isAcceptableHookCommand(cmd) {
   return isGuiSafeHookCommand(cmd) || isClaudeProjectDirCommand(cmd);
 }
 
-function isCurrentAiLensHook(entry, expected) {
+// True when an ai-lens $CLAUDE_PROJECT_DIR / %CLAUDE_PROJECT_DIR% hook is written
+// with the OTHER platform's variable syntax — `$VAR` on Windows (cmd.exe wants
+// `%VAR%`) or `%VAR%` on POSIX (sh wants `$VAR`). Claude Code hands the command to
+// the native OS shell, so a wrong-syntax var never expands and the hook silently
+// fails (Anthropic claude-code#24710). Used to flag such a PER-MACHINE hook as
+// outdated so init rewrites it to the running OS's form. Committed hooks are
+// protected separately — see analyzeToolHooks / allowPlatformRewrite.
+export function isWrongPlatformProjectDirCommand(cmd, platform = process.platform) {
+  if (!isClaudeProjectDirCommand(cmd)) return false;
+  const n = (cmd || '').replace(/\\/g, '/');
+  const correctVar = platform === 'win32' ? '%CLAUDE_PROJECT_DIR%' : '$CLAUDE_PROJECT_DIR';
+  return !n.includes(correctVar);
+}
+
+// Whether a hook-config file is committed (tracked) in git. The anti-churn rule
+// (treat both $ and % CLAUDE_PROJECT_DIR forms as current) exists ONLY to keep a
+// COMMITTED cross-platform hook file from being flipped to one OS's syntax and
+// re-committed, breaking teammates on the other OS. For per-machine files
+// (untracked / gitignored — the supported model), there's nothing to protect, so
+// init may rewrite a wrong-OS form to the running platform. Returns false on any
+// error (git missing, not a repo, untracked) → treat as per-machine, free to rewrite.
+function isGitTracked(filePath) {
+  try {
+    execFileSync('git', ['-C', dirname(filePath), 'ls-files', '--error-unmatch', '--', filePath], {
+      stdio: 'ignore',
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isCurrentAiLensHook(entry, expected, opts = {}) {
   // "Current" = a GUI-safe install (launcher OR absolute-node capture.js) OR a
   // committed Claude Code $CLAUDE_PROJECT_DIR project hook. We do NOT require an exact
   // match against the expected command form — every valid install method captures
   // reliably, so none should be reported outdated. Only PATH-dependent forms
   // (bare `node`, `/usr/bin/env node`) WITHOUT $CLAUDE_PROJECT_DIR are outdated.
+  //
+  // Exception (allowPlatformRewrite, set for untracked/per-machine files): a
+  // $CLAUDE_PROJECT_DIR/%CLAUDE_PROJECT_DIR% hook written for the OTHER OS won't
+  // expand on this platform, so flag it outdated to let init rewrite it.
+  const { platform = process.platform, allowPlatformRewrite = false } = opts;
+  const ok = (cmd) => isAcceptableHookCommand(cmd)
+    && !(allowPlatformRewrite && isWrongPlatformProjectDirCommand(cmd, platform));
   // Flat format (Cursor): single command per entry.
   if (entry?.command != null) {
-    return isAcceptableHookCommand(entry.command);
+    return ok(entry.command);
   }
   // Nested format (Claude Code / Codex): { matcher, hooks: [{ command }] }
   if (Array.isArray(entry?.hooks)) {
     if (expected?.matcher !== undefined && entry.matcher !== expected.matcher) return false;
-    return entry.hooks.some(h => isAcceptableHookCommand(h?.command || ''));
+    return entry.hooks.some(h => ok(h?.command || ''));
   }
   return false;
 }
@@ -970,7 +1010,7 @@ export function detectInstalledTools(ctx = null) {
  * Returns { status, config?, error? }
  *   status: 'fresh' | 'current' | 'outdated' | 'absent' | 'malformed'
  */
-export function analyzeToolHooks(tool) {
+export function analyzeToolHooks(tool, opts = {}) {
   if (!existsSync(tool.configPath)) {
     return { status: 'fresh', disableAllHooks: false };
   }
@@ -1002,6 +1042,12 @@ export function analyzeToolHooks(tool) {
     return { status: 'absent', config, disableAllHooks };
   }
 
+  // Per-machine (untracked/gitignored) hook files may be rewritten to the running
+  // OS's CLAUDE_PROJECT_DIR syntax; committed (tracked) files are protected from
+  // churn. Caller may override both (tests, or callers with known context).
+  const platform = opts.platform ?? process.platform;
+  const allowPlatformRewrite = opts.allowPlatformRewrite ?? !isGitTracked(tool.configPath);
+
   // Check if any AI Lens hooks exist
   let hasAiLens = false;
   let allCurrent = true;
@@ -1013,7 +1059,7 @@ export function analyzeToolHooks(tool) {
     for (const entry of entries) {
       if (isAiLensHook(entry)) {
         hasAiLens = true;
-        if (!isCurrentAiLensHook(entry, expected)) {
+        if (!isCurrentAiLensHook(entry, expected, { platform, allowPlatformRewrite })) {
           allCurrent = false;
         }
       }

package/cli/import/claude-code.js

@@ -94,13 +94,19 @@ export async function fetchCoverage(sessionIds, { fetchImpl = globalThis.fetch }
   if (!sessionIds.length || !fetchImpl) return out;
   const base = getServerUrl();
   const token = getAuthToken();
+  // Auth: token preferred, else git-identity headers so coverage also works in
+  // self-host personal mode (no token) — same fallback the ingest path uses.
+  const ident = token ? null : getGitIdentity(process.cwd());
+  const authHeaders = token
+    ? { 'X-Auth-Token': token }
+    : (ident?.email ? { 'X-Developer-Git-Email': ident.email, ...(ident.name ? { 'X-Developer-Name': ident.name } : {}) } : {});
   const CHUNK = 400;
   for (let i = 0; i < sessionIds.length; i += CHUNK) {
     const batch = sessionIds.slice(i, i + CHUNK);
     try {
       const res = await fetchImpl(new URL('/api/events/coverage', base), {
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', ...(token ? { 'X-Auth-Token': token } : {}) },
+        headers: { 'Content-Type': 'application/json', ...authHeaders },
         body: JSON.stringify({ session_ids: batch }),
       });
       if (res.ok) Object.assign(out, await res.json());
@@ -109,6 +115,15 @@ export async function fetchCoverage(sessionIds, { fetchImpl = globalThis.fetch }
   return out;
 }
 
+/**
+ * Can the importer actually deliver events? A personal auth token OR a resolvable
+ * git email (the ingest path accepts either). Pure-ish; takes the two resolvers so
+ * it's testable without touching real git/env.
+ */
+export function hasDeliverableIdentity(token, gitEmail) {
+  return !!token || !!gitEmail;
+}
+
 /**
  * Drop events at/after the live-coverage boundary for their session, so import
  * only adds the pre-live backlog. No boundary ⇒ keep all. (Pure, for tests.)
@@ -209,8 +224,10 @@ export default async function importClaudeCode(flags) {
     warn(`No Claude Code history found at ${PROJECTS_DIR}`);
     return;
   }
-  if (!dryRun && !getAuthToken()) {
-    error('No auth token. Run `npx ai-lens init` first (or set AI_LENS_AUTH_TOKEN).');
+  // Need a way to attribute events: a token, OR a git email (self-host personal
+  // mode ships via the git-identity fallback, just like live capture).
+  if (!dryRun && !hasDeliverableIdentity(getAuthToken(), getGitIdentity(process.cwd())?.email)) {
+    error('No identity to attribute events. Run `npx ai-lens init` first, or set a git user.email (or AI_LENS_AUTH_TOKEN).');
     return;
   }
   if (noRedact) warn('⚠ --no-redact: secrets in raw transcripts are NOT redacted client-side and persist locally in the spool if a send fails. Use only for debugging.');

package/cli/init.js

@@ -361,6 +361,12 @@ function getInitArgs() {
       case '--install-launcher':
         flags.installLauncher = true;
         break;
+      case '--import':
+        flags.importHistory = true;
+        break;
+      case '--no-import':
+        flags.noImport = true;
+        break;
       case '--mcp-scope':
         if (i + 1 < args.length) flags.mcpScope = args[++i];
         else process.stderr.write('Warning: --mcp-scope requires a value\n');
@@ -628,29 +634,35 @@ export default async function init() {
 
   // Authentication
   heading('Authentication');
+  // Never null an existing token up front. An abandoned device-code login — or a
+  // transient server hiccup that mis-flags a good token (e.g. during a deploy) —
+  // must not leave the user with authToken:null, which silently breaks capture
+  // until someone notices. newConfig already inherits the prior token via the
+  // spread above; we only OVERWRITE it once we hold a confirmed new token.
+  let needsAuth = !currentConfig.authToken;
+  let authConfigured = true; // flipped false only if the server reports no Auth0
   if (currentConfig.authToken) {
     const tokenStatus = await validateExistingToken(serverUrl, currentConfig.authToken);
     if (tokenStatus === 'valid') {
       success('  Already authenticated (token verified)');
     } else if (tokenStatus === 'unknown') {
       warn('  Token format not recognized — re-authenticating...');
-      currentConfig.authToken = null;
-      newConfig.authToken = null;
+      needsAuth = true;
     } else if (tokenStatus === 'invalid') {
       warn('  Existing token is invalid or revoked — re-authenticating...');
-      currentConfig.authToken = null;
-      newConfig.authToken = null;
+      needsAuth = true;
     } else {
       warn('  Could not reach server to verify token — keeping existing token');
     }
   }
-  if (!currentConfig.authToken) {
+  if (needsAuth) {
     let authResult = null;
     try {
       authResult = await deviceCodeAuth(serverUrl);
     } catch (err) {
       const msg = (err && err.message) ? err.message : String(err);
       if (msg.includes('not configured')) {
+        authConfigured = false;
         warn(`  Auth not configured on server — personal mode (events sent via git identity)`);
       } else {
         warn(`  Authentication failed: ${msg}`);
@@ -663,17 +675,29 @@ export default async function init() {
         saveLensConfig(newConfig);
         success(`  Authenticated as ${authResult.name} (${authResult.email})`);
       } catch (err) {
+        // Keep whatever token newConfig already holds — do NOT null it.
         warn(`  Authenticated but failed to save token: ${err.message}`);
         warn(`  Run "npx -y ai-lens init" again later to persist authentication`);
-        newConfig.authToken = null;
       }
+    } else if (currentConfig.authToken) {
+      // Re-auth didn't complete. Preserve the prior token rather than stranding
+      // the user tokenless: a transient false-negative keeps capture working, and
+      // a genuinely revoked token simply re-prompts on the next init.
+      warn('  Re-authentication not completed — keeping the existing token for now.');
     }
   }
 
-  // Validate identity: no token + no git email = events will be dropped
+  // Loud failure when capture is actually broken: a server with Auth0 drops every
+  // event without a token (the git-email header path is personal-mode only), so a
+  // missing token here is not a soft warning — it's a silent data outage.
   if (!newConfig.authToken) {
     const { email } = getGitIdentity();
-    if (!email) {
+    if (authConfigured) {
+      blank();
+      error('  No auth token — this server requires one, so EVERY event will be dropped.');
+      error('  Capture is OFF until you authenticate.');
+      info('  Fix: run "npx -y ai-lens init" and finish the browser login.');
+    } else if (!email) {
       blank();
       error('  No auth token and no git email configured.');
       error('  Events will be silently dropped until one is available.');
@@ -1194,5 +1218,42 @@ export default async function init() {
   }
   blank();
 
+  // Primary warm-start trigger: offer to import local Claude Code history right now,
+  // so the dashboard isn't empty on first open.
+  await maybeOfferImportHistory(flags);
+
   detail(`Log: ${getLogPath()}`);
 }
+
+/**
+ * After a successful init, offer to import the developer's local Claude Code
+ * history. `--no-import` skips; `--import` or `--yes` runs it without prompting;
+ * otherwise asks interactively. No-op if there's no `~/.claude/projects`.
+ */
+async function maybeOfferImportHistory(flags) {
+  if (flags.noImport) return;
+  if (!existsSync(join(homedir(), '.claude', 'projects'))) return;
+
+  let run = flags.importHistory || flags.yes;
+  if (!run) {
+    try {
+      const answer = (await ask('Import your local Claude Code history now? (Y/n) ')).toLowerCase();
+      run = answer === '' || answer === 'y' || answer === 'yes';
+    } catch { run = false; }
+  }
+  if (!run) {
+    blank();
+    info('  Skipped import. Run `npx -y ai-lens import claude-code` anytime to bring it in.');
+    return;
+  }
+
+  blank();
+  heading('Importing local history');
+  try {
+    const { default: importClaudeCode } = await import('./import/claude-code.js');
+    await importClaudeCode({ days: 30 }); // server URL + git identity were just configured
+  } catch (err) {
+    error(`  Import failed: ${err.message}`);
+    info('  You can retry later: `npx -y ai-lens import claude-code`');
+  }
+}

package/package.json

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