ai-lens 0.8.99 → 0.8.100

package/.commithash

@@ -1 +1 @@
-b23bf01
+3ebf574

package/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 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.100 — 2026-06-17
+- fix: Claude Code hooks on Windows now actually capture. The previous windowless wrapper (`conhost.exe --headless`) hid the console window but silently swallowed the hook's stdin, so the event payload never reached AI Lens and nothing was recorded. Claude Code now uses the same windowless launcher as Cursor (`ai-lens-hook.ps1`), which both suppresses the window and delivers the payload. Existing installs migrate on the next `ai-lens init` / `/setup`. macOS/Linux unchanged. (The launcher was renamed from `cursor-ai-lens-hook.ps1` since it now serves both tools.)
+
 ## 0.8.99 — 2026-06-17
 - fix: Cursor hooks on Windows no longer flash a console window on every event. The flash was `node.exe` (a console app) allocating its own window when Cursor runs the hook; a new windowless launcher (`cursor-ai-lens-hook.ps1`) starts node with no window and forwards the event to it, so capture keeps working with no flash. Existing Cursor installs migrate automatically on the next `ai-lens init` / `/setup`. macOS/Linux and Claude Code are unchanged
 

package/cli/hooks.js

@@ -295,11 +295,14 @@ export function captureCommand(opts = {}) {
   const clientDir = ctx.clientDir ?? CLIENT_INSTALL_DIR;
   const nodeResolution = ctx.nodeResolution;
   const isWin = platform === 'win32';
-  // Windows-only windowless wrapper (see supportsConhostHeadless). Gated by the
-  // `windowless` opt so it's applied to CLAUDE forms only — Cursor/Codex never set it
-  // (no reported flash + unverified conhost+stdin for those tools; ADR 0003 §3.2).
-  // A build < 1809 falls back to the bare form. Never applied off Windows.
-  const conhost = isWin && windowless && (ctx.conhost ?? supportsConhostHeadless());
+  // Windows windowless launcher (ai-lens-hook.ps1). Gated by the `windowless` opt, so
+  // it applies to CLAUDE forms only here — Cursor builds its own launcher form in
+  // cursorCaptureCommand, Codex never sets windowless. We DON'T use conhost.exe
+  // --headless: it hides the window but breaks capture (swallows node's stdin → the
+  // payload never arrives; and for Cursor it corrupts stdout). The launcher uses
+  // ProcessStartInfo + CreateNoWindow + RedirectStandardInput instead — windowless AND
+  // stdin-preserving — and works on all Windows (no ≥1809 requirement). Never off Windows.
+  const winLauncher = isWin && windowless;
   // shell hint distinguishes cmd.exe (Claude Code) from PowerShell (Cursor) on
   // Windows — the two need different escaping for paths with spaces.
   const isPS = shell === 'powershell';
@@ -314,12 +317,14 @@ export function captureCommand(opts = {}) {
   // POSIX shells use $VAR.
   if (projectDirRelPath != null) {
     const rel = projectDirRelPath.replace(/\\/g, '/').replace(/^\.?\/+/, '');
-    if (conhost) {
-      // Windowless form. conhost is the launched image (no cmd.exe shell), so the
-      // path must use $CLAUDE_PROJECT_DIR — Claude Code substitutes that variable
-      // itself before exec on every OS (the %VAR% form would survive unexpanded
-      // since there's no shell to expand it). Verified on Windows 11 / cc 2.1.177.
-      return `conhost.exe --headless node "$CLAUDE_PROJECT_DIR/${rel}"`;
+    if (winLauncher) {
+      // Windowless form via the launcher. Uses $CLAUDE_PROJECT_DIR — Claude Code
+      // substitutes that variable itself before exec on every OS. The launcher ships
+      // next to capture.js, so it resolves under the same $CLAUDE_PROJECT_DIR path.
+      // node stays bare (committed/machine-agnostic form) — the launcher's
+      // ProcessStartInfo resolves it via PATH (Claude Code requires node on PATH).
+      const launcherRel = rel.replace(/[^/]*$/, 'ai-lens-hook.ps1');
+      return `powershell -NoProfile -ExecutionPolicy Bypass -File "$CLAUDE_PROJECT_DIR/${launcherRel}" node "$CLAUDE_PROJECT_DIR/${rel}"`;
     }
     const dir = isWin ? '%CLAUDE_PROJECT_DIR%' : '$CLAUDE_PROJECT_DIR';
     return `node "${dir}/${rel}"`;
@@ -342,12 +347,15 @@ export function captureCommand(opts = {}) {
     : shellEscape(capturePath, platform);
   const nodeNorm = nodeResolution.path.replace(/\\/g, '/');
 
-  // Windowless (Claude + Windows ≥ 1809): conhost.exe is the launched image and runs
-  // node directly, so it needs neither the cmd.exe `call` nor the PowerShell `&`
-  // wrapper. stdin is forwarded (verified). The node path is always double-quoted on
-  // Windows (it can contain spaces, e.g. C:/Program Files/nodejs/node.exe).
-  if (conhost) {
-    return `conhost.exe --headless "${nodeNorm.replace(/"/g, '""')}" ${pathPart}`;
+  // Windowless (Claude on Windows): run node through the ai-lens-hook.ps1 launcher,
+  // which starts node with CreateNoWindow + forwards stdin (conhost would swallow it).
+  // Claude Code spawns powershell to run the launcher; the payload arrives on the
+  // process's OS stdin, which the launcher reads via [Console]::In. The launcher ships
+  // next to capture.js. node + capture + launcher all double-quoted (may contain spaces).
+  if (winLauncher) {
+    const q = (s) => `"${s.replace(/"/g, '""')}"`;
+    const launcherAbs = capturePath.replace(/[^/]*$/, 'ai-lens-hook.ps1');
+    return `powershell -NoProfile -ExecutionPolicy Bypass -File ${q(launcherAbs)} ${q(nodeNorm)} ${q(capturePath)}`;
   }
   if (isWin && rawPath && nodeNorm.includes(' ')) {
     const quotedNode = `"${nodeNorm.replace(/"/g, '""')}"`;
@@ -371,14 +379,14 @@ export function cursorCaptureCommand(opts = {}) {
   const platform = ctx.platform ?? process.platform;
 
   if (platform === 'win32') {
-    // Windows: route node through the windowless launcher cursor-ai-lens-hook.ps1.
+    // Windows: route node through the windowless launcher ai-lens-hook.ps1.
     // Cursor spawns hooks via a hidden powershell and pipes the payload through the
     // PS pipeline ($input); launching node.exe directly there pops a console window
     // on every event (node is console-subsystem, parent powershell has no console).
     // conhost.exe --headless hides the window but corrupts Cursor's JSON-parse of hook
     // stdout with ConPTY VT codes (verified). The launcher starts node with
     // CreateNoWindow=$true and forwards $input → node stdin: no window, clean stdout.
-    // Form: & "<...>/cursor-ai-lens-hook.ps1" "<absNode>" "<capture.js>"
+    // Form: & "<...>/ai-lens-hook.ps1" "<absNode>" "<capture.js>"
     const clientDir = (ctx.clientDir ?? CLIENT_INSTALL_DIR).replace(/\\/g, '/');
     const nodeResolution = ctx.nodeResolution;
     if (!nodeResolution || !nodeResolution.path) {
@@ -388,7 +396,7 @@ export function cursorCaptureCommand(opts = {}) {
     const capturePath = (customPath ?? `${clientDir}/capture.js`).replace(/\\/g, '/');
     // The launcher ships next to capture.js (installed client dir, or the repo client
     // dir for --use-repo-path) — derive its path from capturePath's directory.
-    const launcher = capturePath.replace(/[^/]*$/, 'cursor-ai-lens-hook.ps1');
+    const launcher = capturePath.replace(/[^/]*$/, 'ai-lens-hook.ps1');
     const q = (s) => `"${s.replace(/"/g, '""')}"`;
     return `& ${q(launcher)} ${q(node)} ${q(capturePath)}`;
   }
@@ -413,8 +421,8 @@ export function cursorCaptureCommand(opts = {}) {
  */
 export function listClientFiles(sourceDir = join(__dirname, '..', 'client')) {
   // .js — all client modules (sibling imports must all be present).
-  // .ps1 — the Windows windowless Cursor hook launcher (cursor-ai-lens-hook.ps1);
-  // a missing launcher would break every Cursor hook on Windows, so ship it too.
+  // .ps1 — the Windows windowless hook launcher (ai-lens-hook.ps1), used by Cursor AND
+  // Claude Code; a missing launcher would break every Windows hook, so ship it too.
   return readdirSync(sourceDir).filter(f => f.endsWith('.js') || f.endsWith('.ps1')).sort();
 }
 
@@ -810,16 +818,6 @@ export function _parseHookCommand(cmd) {
     return { kind: 'launcher', path: first, prefix, nodePrefix: null };
   }
 
-  // Windows windowless Cursor launcher: & "<...>/cursor-ai-lens-hook.ps1" "<node>" "<capture.js>".
-  // node is the SECOND token (the launcher's first arg); capture.js is the third.
-  if (first.endsWith('cursor-ai-lens-hook.ps1')) {
-    return {
-      kind: 'cursorWindowless',
-      path: first,
-      prefix,
-      nodePrefix: tokens.length >= 2 ? normalizePath(tokens[1]) : null,
-    };
-  }
 
   if (tokens.length >= 2) {
     const second = normalizePath(tokens[1]);
@@ -878,14 +876,19 @@ function normalizePath(p) {
 // still classifies run.* as ai-lens so `remove`/strip cleans up stale launchers.)
 export function isGuiSafeHookCommand(cmd) {
   if (!isAiLensCommand(cmd).isAiLens) return false;
-  // GUI-safe when an ABSOLUTE node path is baked in — either the direct capture.js form
-  // (`<absNode> capture.js`) or the Windows windowless launcher form
-  // (`& "<...>/cursor-ai-lens-hook.ps1" "<absNode>" "<capture.js>"`), where node is the
-  // launcher's first arg. Bare `node` / `/usr/bin/env node` are NOT GUI-safe (depend on
-  // PATH, which GUI Cursor/Claude often lack). The old run.sh/run.cmd launcher is NOT
-  // recognised here (ADR 0003) — it stays `outdated` so init migrates it.
+  // Our Windows windowless launcher (ai-lens-hook.ps1) is GUI-safe by construction — it
+  // starts node with CreateNoWindow. Matched by substring so it covers BOTH invocations:
+  // Cursor `& "<...>/ai-lens-hook.ps1" <node> <capture>` and Claude
+  // `powershell ... -File "<...>/ai-lens-hook.ps1" <node> <capture>` (also the older
+  // cursor-ai-lens-hook.ps1 name). The node arg's existence is validated in status.js.
+  const n = (cmd || '').replace(/\\/g, '/');
+  if (/ai-lens-hook\.ps1/i.test(n)) return true;
+  // Direct capture.js form: GUI-safe only with an ABSOLUTE node path baked in. Bare
+  // `node` / `/usr/bin/env node` are NOT GUI-safe (depend on PATH, which GUI
+  // Cursor/Claude often lack). The old run.sh/run.cmd launcher is NOT recognised here
+  // (ADR 0003) — it stays `outdated` so init migrates it.
   const p = _parseHookCommand(cmd);
-  if ((p.kind === 'captureJs' || p.kind === 'cursorWindowless') && p.nodePrefix) {
+  if (p.kind === 'captureJs' && p.nodePrefix) {
     const np = p.nodePrefix;
     const isAbsolute = np.startsWith('/') || /^[a-zA-Z]:\//.test(np);
     const isEnvShim = np === '/usr/bin/env' || np.endsWith('/env');
@@ -923,11 +926,12 @@ function isAcceptableHookCommand(cmd) {
 export function isWrongPlatformProjectDirCommand(cmd, platform = process.platform) {
   if (!isClaudeProjectDirCommand(cmd)) return false;
   const n = (cmd || '').replace(/\\/g, '/');
-  // The conhost windowless form is unambiguously a Windows command (conhost.exe is
-  // Windows-only) and deliberately uses $CLAUDE_PROJECT_DIR — Claude Code substitutes
-  // that itself, so it expands on Windows too. It is therefore correct on win32 and
-  // wrong (won't run) anywhere else; the %VAR% rule below doesn't apply to it.
-  if (isConhostHeadlessCommand(n)) return platform !== 'win32';
+  // The Windows windowless launcher form (powershell … -File "$CLAUDE_PROJECT_DIR/…
+  // ai-lens-hook.ps1" …) and the older conhost.exe --headless form are unambiguously
+  // Windows commands. Both deliberately use $CLAUDE_PROJECT_DIR — Claude Code substitutes
+  // that itself before exec, so it expands on Windows. They are correct on win32 and
+  // wrong (won't run) anywhere else; the %VAR%/$VAR rule below doesn't apply to them.
+  if (/ai-lens-hook\.ps1/i.test(n) || isConhostHeadlessCommand(n)) return platform !== 'win32';
   const correctVar = platform === 'win32' ? '%CLAUDE_PROJECT_DIR%' : '$CLAUDE_PROJECT_DIR';
   return !n.includes(correctVar);
 }
@@ -1124,24 +1128,23 @@ function isCurrentAiLensHook(entry, expected, opts = {}) {
   //
   // Windows-wrapper exception (same allowPlatformRewrite gate): flag a hook outdated
   // when its stored windowless wrapper DISAGREES with the freshly regenerated `expected`
-  // command, so init re-syncs it. We compare ONLY the wrapper kind — conhost vs the
-  // Cursor `cursor-ai-lens-hook.ps1` launcher vs plain — never the whole command, so
-  // legitimate path/node/install-mode variation never false-flags. `expected` already
-  // bakes in tool+platform: Claude on conhost-capable Windows → `conhost`; Cursor on
-  // Windows → `cursorPs1` (the windowless launcher; conhost corrupts Cursor's stdout
-  // JSON-parse); Codex, macOS, and old Windows → `plain`. So this self-scopes per tool:
-  //   - Claude: stored plain → outdated (add conhost); stored conhost → current.
-  //   - Cursor: stored plain/conhost → outdated (migrate to the .ps1 launcher); ps1 → current.
-  //   - Codex/macOS: expected plain, stored plain → current (untouched).
-  // Committed (tracked) files are exempt via allowPlatformRewrite — they carry one
-  // OS-agnostic syntax and can't bake a Windows-only wrapper; the per-machine overlay
-  // (or the local .cursor/hooks.json) provides it.
+  // command, so init re-syncs it. We compare ONLY the wrapper kind — `conhost` vs the
+  // `ai-lens-hook.ps1` launcher (keyed on its basename) vs `plain` — never the whole
+  // command, so legitimate path/node/install-mode variation never false-flags.
+  // `expected` bakes in tool+platform: on Windows BOTH Cursor and Claude now use the
+  // launcher (`ps1:ai-lens-hook.ps1`); Codex, macOS → `plain`. So this self-scopes:
+  //   - conhost (old Claude/Cursor) → mismatch → outdated → migrate to the launcher;
+  //   - old `cursor-ai-lens-hook.ps1` → `ps1:cursor-ai-lens-hook.ps1` ≠ `ps1:ai-lens-hook.ps1`
+  //     → outdated → migrate to the renamed launcher;
+  //   - launcher already current → match → current; Codex/macOS plain → current.
+  // Committed (tracked) files are exempt via allowPlatformRewrite.
   const { platform = process.platform, allowPlatformRewrite = false } = opts;
   const expectedCmd = expected?.command ?? expected?.hooks?.[0]?.command ?? '';
   const wrapperKind = (c) => {
     const s = String(c || '');
     if (isConhostHeadlessCommand(s)) return 'conhost';
-    if (/cursor-ai-lens-hook\.ps1/i.test(s)) return 'cursorPs1';
+    const m = s.match(/([\w.-]*ai-lens-hook\.ps1)/i);
+    if (m) return 'ps1:' + m[1].toLowerCase();
     return 'plain';
   };
   const expectedWrapper = wrapperKind(expectedCmd);

package/cli/status.js

@@ -150,24 +150,28 @@ function validateHookCommandPaths(tool) {
 
   const issues = [];
   const launcherMatch = command.match(/["']([^"']*run\.(?:sh|cmd))["']|(\S*run\.(?:sh|cmd))/);
-  const ps1Match = command.match(/["']([^"']*cursor-ai-lens-hook\.ps1)["']|(\S*cursor-ai-lens-hook\.ps1)/);
+  // Matches both ai-lens-hook.ps1 and the older cursor-ai-lens-hook.ps1.
+  const ps1Match = command.match(/["']([^"']*ai-lens-hook\.ps1)["']|(\S*ai-lens-hook\.ps1)/);
+  // Paths containing $CLAUDE_PROJECT_DIR / %CLAUDE_PROJECT_DIR% can't be resolved here
+  // (Claude Code substitutes the var at runtime) — skip existence checks for those.
+  const resolvable = (p) => !/CLAUDE_PROJECT_DIR/.test(p);
 
   if (ps1Match) {
-    // Windows windowless Cursor launcher: & "<...>/cursor-ai-lens-hook.ps1" "<node>" "<capture.js>".
-    // Validate the launcher, the node arg (2nd token), and capture.js (3rd token) all exist.
+    // Windows windowless launcher (Cursor: `& "<...>.ps1" <node> <capture>`; Claude:
+    // `powershell ... -File "<...>.ps1" <node> <capture>`). Validate launcher + node arg
+    // + capture.js exist (when their paths are resolvable, i.e. not $CLAUDE_PROJECT_DIR).
     const ps1Path = expandTilde(ps1Match[1] || ps1Match[2]);
-    if (!existsSync(ps1Path)) issues.push(`Cursor hook launcher not found at: ${ps1Path}`);
+    if (resolvable(ps1Path) && !existsSync(ps1Path)) issues.push(`AI Lens hook launcher not found at: ${ps1Path}`);
     const capMatch = command.match(/["']([^"']*capture\.js)["']|(\S*capture\.js)/);
     if (capMatch) {
       const capturePath = expandTilde(capMatch[1] || capMatch[2]);
-      if (!existsSync(capturePath)) issues.push(`capture.js not found at: ${capturePath}`);
+      if (resolvable(capturePath) && !existsSync(capturePath)) issues.push(`capture.js not found at: ${capturePath}`);
     }
     // node = the launcher's first argument (token right after the .ps1 path)
-    const nodeArg = command.replace(/^& /, '')
-      .match(/cursor-ai-lens-hook\.ps1["']?\s+(?:["']([^"']+)["']|(\S+))/);
+    const nodeArg = command.match(/ai-lens-hook\.ps1["']?\s+(?:["']([^"']+)["']|(\S+))/);
     if (nodeArg) {
       const nodePath = expandTilde(nodeArg[1] || nodeArg[2]);
-      if (nodePath !== 'node' && !existsSync(nodePath)) {
+      if (nodePath !== 'node' && resolvable(nodePath) && !existsSync(nodePath)) {
         issues.push(`node not found at: ${nodePath} — re-run \`ai-lens init\` to re-resolve node`);
       }
     }

package/client/ai-lens-hook.ps1

@@ -0,0 +1,39 @@
+# AI Lens — windowless hook launcher (Windows only). Used by BOTH Cursor and Claude Code.
+#
+# Why this exists: a hook spawns node.exe, a console-subsystem binary; launched from a
+# console-less parent it allocates its own console window → a flash on every event. The
+# obvious windowless wrapper, `conhost.exe --headless`, is unusable for hook capture:
+#   - for Cursor it emits ConPTY VT escape codes onto stdout, which Cursor fails to JSON-parse;
+#   - for Claude Code it replaces node's stdin with the pseudoconsole, so the JSON payload
+#     never reaches capture.js (it reads empty stdin and drops the event).
+# This launcher instead starts node via ProcessStartInfo with CreateNoWindow=$true (no
+# window) and RedirectStandardInput (real stdin forwarded) — so capture works AND there's
+# no flash, and nothing extra is written to stdout.
+#
+# Payload source differs by caller, so read BOTH:
+#   - Cursor pipes it through the PowerShell pipeline → $input.
+#   - Claude Code pipes it to the process's OS stdin → [Console]::In.
+# Read $input first; if empty (Claude Code invocation), fall back to [Console]::In.
+#
+# Args: $args[0] = node path, $args[1] = capture.js path.
+
+$ErrorActionPreference = 'Stop'
+$node = $args[0]
+$capture = $args[1]
+
+$payload = @($input) -join "`n"
+if ([string]::IsNullOrEmpty($payload)) {
+  $payload = [Console]::In.ReadToEnd()
+}
+
+$psi = New-Object System.Diagnostics.ProcessStartInfo
+$psi.FileName = $node
+$psi.Arguments = '"' + $capture + '"'
+$psi.UseShellExecute = $false
+$psi.CreateNoWindow = $true
+$psi.RedirectStandardInput = $true
+
+$proc = [System.Diagnostics.Process]::Start($psi)
+$proc.StandardInput.Write($payload)
+$proc.StandardInput.Close()
+$proc.WaitForExit()

package/package.json

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

package/client/cursor-ai-lens-hook.ps1

@@ -1,32 +0,0 @@
-# AI Lens — Cursor windowless hook launcher (Windows only).
-#
-# Why this exists: Cursor runs a hook by spawning a (hidden) powershell that pipes the
-# event payload through the PowerShell pipeline ($input) — e.g.
-#     Get-Content <tmp>.json -Raw | & { $input | & "<this.ps1>" "<node>" "<capture.js>" }
-# Launching node.exe directly there pops a console window on every event (node is a
-# console-subsystem binary and the parent powershell has no console). conhost.exe
-# --headless hides the window but emits ConPTY VT escape codes onto stdout, which Cursor
-# then fails to JSON-parse. This launcher instead starts node with CreateNoWindow=$true
-# (no window) while forwarding the payload to node's stdin — so capture still works and
-# nothing extra is written to stdout.
-#
-# Args: $args[0] = absolute node path, $args[1] = capture.js path.
-# Payload arrives on the PowerShell pipeline as $input (NOT [Console]::In, which is empty
-# here because the data is an in-process pipeline object, not the process's OS stdin).
-
-$ErrorActionPreference = 'Stop'
-$node = $args[0]
-$capture = $args[1]
-$payload = @($input) -join "`n"
-
-$psi = New-Object System.Diagnostics.ProcessStartInfo
-$psi.FileName = $node
-$psi.Arguments = '"' + $capture + '"'
-$psi.UseShellExecute = $false
-$psi.CreateNoWindow = $true
-$psi.RedirectStandardInput = $true
-
-$proc = [System.Diagnostics.Process]::Start($psi)
-$proc.StandardInput.Write($payload)
-$proc.StandardInput.Close()
-$proc.WaitForExit()