ai-lens 0.8.105 → 0.8.107

package/.commithash

@@ -1 +1 @@
-0a107d0
+af32330

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 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.107 — 2026-06-19
+- fix: Cyrillic / non-ASCII in Windows hook payloads is no longer corrupted (it was being dropped as malformed JSON). The windowless launcher now reads the payload as raw bytes straight off the process's stdin and never references PowerShell's `$input` — merely touching `$input` both pre-drains stdin and decodes it through the console's OEM codepage, mangling the UTF-8 BOM and every Cyrillic byte before forwarding. Byte-exact passthrough now; the 0.8.105 read still went through `$input` first. Cursor and Claude Code.
+- fix: the Windows hidden-sender launch now runs detached, so it isn't killed together with the hook's process tree before it finishes starting the sender — closing a rare window where an event could be dropped. The launcher is GUI-subsystem, so detached still adds no console window (no flash).
+
+## 0.8.106 — 2026-06-19
+- fix: no more console-window flash on every hook event on Windows (Cursor and Claude Code). The flash was the background sender that `capture.js` launches after each event — a detached console spawn pops a window even when hidden. It's now started through a tiny GUI-subsystem launcher (`run-hidden.vbs`), which has no console at all, so capture stays invisible and still ships reliably. If a corporate policy/AV blocks the Windows Script Host, it automatically falls back to the previous behaviour so events never stop shipping. macOS/Linux unchanged.
+
 ## 0.8.105 — 2026-06-18
 - fix: Cyrillic (and other non-ASCII) in Claude Code hook payloads is no longer mangled on Windows. The windowless hook launcher read stdin through PowerShell's console codepage (OEM, e.g. CP866 on Russian Windows), corrupting prompts/paths on the way in; it now reads the raw stdin bytes and decodes UTF-8 directly. The earlier 0.8.102 fix only covered the write side, so machines that adopted the windowless launcher saw the corruption reappear.
 

package/cli/hooks.js

@@ -420,7 +420,11 @@ export function listClientFiles(sourceDir = join(__dirname, '..', 'client')) {
   // .js — all client modules (sibling imports must all be present).
   // .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();
+  // .vbs — run-hidden.vbs, the Windows hidden+detached sender launcher capture.js uses
+  // to start the sender without a console flash; missing it would reintroduce the flash.
+  return readdirSync(sourceDir)
+    .filter(f => f.endsWith('.js') || f.endsWith('.ps1') || f.endsWith('.vbs'))
+    .sort();
 }
 
 /**

package/client/ai-lens-hook.ps1

@@ -11,18 +11,14 @@
 # no flash. It is fail-open: on ANY error it exits 0 and writes NOTHING to stdout (Cursor
 # parses a hook's stdout as JSON — leaking an error there would break the hook).
 #
-# 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 → read it as raw bytes.
-# Read $input first; if empty (Claude Code invocation), read the OS stdin stream.
-#
-# Why raw bytes (not [Console]::In.ReadToEnd()): [Console]::In decodes stdin via
-# [Console]::InputEncoding, which on Windows PowerShell 5.1 defaults to the OEM
-# codepage (e.g. CP866 on Russian Windows) — so Cyrillic/non-ASCII in the JSON
-# payload is mangled at READ time, before we ever re-encode to UTF-8 on the way
-# to node. Reading OpenStandardInput() as bytes and decoding UTF-8 ourselves
-# bypasses the console codepage entirely. (The 0.8.102 fix only covered the WRITE
-# side; the read side still mangled — observed live as mojibake'd prompts.)
+# Payload: read it as RAW BYTES straight off the process's stdin handle and forward
+# them to node unchanged. Do NOT read it as a string ($input / [Console]::In):
+# Windows PowerShell 5.1 decodes stdin with the console's OEM codepage (e.g. cp866 on
+# RU Windows), which corrupts the UTF-8 BOM and every non-ASCII byte (Cyrillic prompts,
+# accented paths) BEFORE we can forward it — capture.js then sees mangled bytes (the BOM
+# arrives as "´╗┐", Cyrillic as garbage) and drops the event as malformed JSON. Reading
+# OpenStandardInput is byte-exact regardless of codepage. (Both Cursor and Claude Code
+# pipe the payload to this process's OS stdin, so one raw read covers both.)
 #
 # Args: $args[0] = node path, $args[1] = capture.js path.
 
@@ -31,13 +27,15 @@ try {
   $node = $args[0]
   $capture = $args[1]
 
-  $payload = @($input) -join "`n"
-  if ([string]::IsNullOrEmpty($payload)) {
-    $stdin = [Console]::OpenStandardInput()
-    $ms = New-Object System.IO.MemoryStream
-    $stdin.CopyTo($ms)
-    $payload = [System.Text.Encoding]::UTF8.GetString($ms.ToArray())
-  }
+  # Read ONLY via OpenStandardInput — and never reference the automatic $input
+  # variable anywhere in this script: merely mentioning $input makes PowerShell
+  # pre-drain the pipeline's stdin into it, which starves this byte-exact read (it
+  # then gets 0 bytes and the payload is lost). Verified live: with no $input
+  # reference, this reads the caller's UTF-8 stdin byte-for-byte (BOM + Cyrillic
+  # intact); with one, the bytes arrive OEM-mangled.
+  $ms = New-Object System.IO.MemoryStream
+  [Console]::OpenStandardInput().CopyTo($ms)
+  $bytes = $ms.ToArray()
 
   $psi = New-Object System.Diagnostics.ProcessStartInfo
   $psi.FileName = $node
@@ -47,10 +45,8 @@ try {
   $psi.RedirectStandardInput = $true
 
   $proc = [System.Diagnostics.Process]::Start($psi)
-  # Write the payload as raw UTF-8 bytes to node's stdin (capture.js reads UTF-8). Going
-  # through BaseStream avoids the StreamWriter's default codepage on Windows PowerShell
-  # 5.1 mangling non-ASCII content (e.g. Cyrillic prompts, accented paths).
-  $bytes = [System.Text.Encoding]::UTF8.GetBytes($payload)
+  # Write the raw payload bytes straight to node's stdin via BaseStream — no re-encoding,
+  # so the UTF-8 the caller sent reaches capture.js byte-for-byte.
   $proc.StandardInput.BaseStream.Write($bytes, 0, $bytes.Length)
   $proc.StandardInput.BaseStream.Flush()
   $proc.StandardInput.Close()

package/client/capture.js

@@ -1317,9 +1317,37 @@ export function shouldSpawnSender(lockPath = join(SENDING_DIR, '.sender.lock'),
   return true;
 }
 
-export function trySpawnSender() {
-  if (!shouldSpawnSender()) return;
-  const senderPath = join(__dirname, 'sender.js');
+// Decide HOW to launch the background sender — pure, so it's unit-testable.
+//   - Windows + run-hidden.vbs present → wscript.exe run-hidden.vbs <node> <sender>.
+//     wscript is GUI-subsystem (no console) and its Shell.Run(...,0,False) starts the
+//     sender hidden AND independent of the hook's process tree → windowless (no flash)
+//     AND surviving (still ships). `fallback` lets the caller retry detached if wscript
+//     is blocked (corporate AV/policy), trading the flash for not losing data.
+//   - Everywhere else (and the Windows no-vbs fallback) → a direct detached node spawn.
+//     `detached` is load-bearing: it breaks the sender out of the hook's process tree so
+//     it survives the teardown — but on Windows it pops a console window (the flash).
+export function senderSpawnPlan({ platform, execPath, senderPath, vbsPath, vbsExists }) {
+  if (platform === 'win32' && vbsExists) {
+    return {
+      command: 'wscript.exe',
+      args: [vbsPath, execPath, senderPath],
+      // detached: break wscript out of the hook's process group so it isn't killed
+      // when the hook's process tree is torn down before Shell.Run finishes launching
+      // the sender (which would silently drop the event). wscript is GUI-subsystem, so
+      // detached adds no console window — still no flash.
+      options: { detached: true, windowsHide: true, stdio: 'ignore' },
+      fallback: true,
+    };
+  }
+  return {
+    command: execPath,
+    args: [senderPath],
+    options: { detached: true, stdio: 'ignore', windowsHide: true },
+    fallback: false,
+  };
+}
+
+function spawnSenderDetached(senderPath) {
   const child = spawn(process.execPath, [senderPath], {
     detached: true,
     stdio: 'ignore',
@@ -1329,6 +1357,27 @@ export function trySpawnSender() {
   child.unref();
 }
 
+export function trySpawnSender() {
+  if (!shouldSpawnSender()) return;
+  const senderPath = join(__dirname, 'sender.js');
+  const vbsPath = join(__dirname, 'run-hidden.vbs');
+  const plan = senderSpawnPlan({
+    platform: process.platform,
+    execPath: process.execPath,
+    senderPath,
+    vbsPath,
+    vbsExists: existsSync(vbsPath),
+  });
+  try {
+    const child = spawn(plan.command, plan.args, plan.options);
+    // wscript blocked (AV/policy) → fall back to the detached spawn so we keep shipping.
+    child.on('error', () => { if (plan.fallback) spawnSenderDetached(senderPath); });
+    child.unref();
+  } catch {
+    if (plan.fallback) spawnSenderDetached(senderPath);
+  }
+}
+
 
 // =============================================================================
 // Main

package/client/run-hidden.vbs

@@ -0,0 +1,24 @@
+' AI Lens — hidden + detached process launcher (Windows only).
+'
+' Why this exists: capture.js must start the background sender after every event,
+' but Node's spawn can't do both things at once on Windows:
+'   - spawn({ detached: true })  -> survives the hook's process-tree teardown, BUT
+'     pops a console window even with windowsHide (a flash on every event);
+'   - spawn({ detached: false }) -> no window, BUT the sender is killed together with
+'     the hook's process tree before it can ship.
+' wscript.exe is GUI-subsystem (it never allocates a console), and WshShell.Run with
+' window style 0 (hidden) + bWaitOnReturn=False launches the target via ShellExecute
+' as an INDEPENDENT process — so the sender is both windowless AND survives. No flash,
+' capture still ships.
+'
+' Args: arg(0) = executable (node), arg(1..n) = its arguments. Each is re-quoted so
+' paths with spaces (e.g. C:\Program Files\nodejs\node.exe) survive.
+Option Explicit
+Dim args, cmd, i
+Set args = WScript.Arguments
+If args.Count = 0 Then WScript.Quit 0
+cmd = ""
+For i = 0 To args.Count - 1
+  cmd = cmd & """" & args(i) & """ "
+Next
+CreateObject("WScript.Shell").Run cmd, 0, False

package/package.json

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