fix: replace polling timer with event-driven vscode.createFileSystemWatcher (v0.8.9)

Zero timers after startup. Uses VS Code's own file watcher API which fires OS-level
notifications (ReadDirectoryChangesW on Windows) — no CPU cost when idle, handles
recursive subdirectories reliably. Startup scan exports only sessions missing from
.codex-history/ (de-duped by shortId). Write events debounced 1s per file.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Myoontyee

package.json

@@ -2,7 +2,7 @@
   "name": "claude-code-exporter",
   "displayName": "Claude Code Exporter — Claude Code, Codex & Cursor Conversation History",
   "description": "Export AI coding agent conversations to Markdown. Supports Claude Code (→ .claude-code-history/), OpenAI Codex (→ .codex-history/), and Cursor Composer (→ .cursor-history/). Features: auto-watch, session inject/import for claude --resume, and repair of thinking-block signature errors when switching API providers.",
-  "version": "0.8.8",
+  "version": "0.8.9",
   "publisher": "myoontyee",
   "engines": {
     "vscode": "^1.85.0"

src/codexWatcher.ts

@@ -1,15 +1,14 @@
 /**
- * codexWatcher.ts — Watch ~/.codex/sessions/ for new Codex CLI/APP sessions
- * and auto-export to .codex-history/
+ * codexWatcher.ts — Track Codex sessions and auto-export to .codex-history/
  *
- * Uses polling (every 30s) instead of fs.watch because fs.watch {recursive}
- * on Windows misses files in newly created date subdirectories (YYYY/MM/DD/).
+ * Design: zero polling timers.
+ *  1. Startup scan  — once, catches sessions created while Cursor was closed.
+ *     Only exports files that don't already have a matching .md in .codex-history/.
+ *  2. VS Code file watcher — event-driven via vscode.workspace.createFileSystemWatcher.
+ *     The VS Code API uses OS-level notifications (ReadDirectoryChangesW on Windows),
+ *     handles recursive subdirectories reliably, and burns zero CPU when idle.
  *
- * CPU-safety guarantees:
- *  1. Seeded at startup: existing files are recorded as "already exported"
- *     so the first poll only picks up files modified AFTER Cursor opened.
- *  2. isPolling guard: if a poll cycle is still running when the next timer
- *     fires, the new tick is skipped entirely — no overlapping runs.
+ * No setInterval / setTimeout involved after startup.
  */
 
 import * as fs from 'fs';
@@ -19,15 +18,12 @@ import * as vscode from 'vscode';
 import { CodexExporter } from './codexExporter';
 import { scanCodexSessions } from './codexParser';
 
-const POLL_INTERVAL_MS = 30_000;
-
 export class CodexWatcher implements vscode.Disposable {
-  private pollTimer?: NodeJS.Timeout;
+  private fsWatcher?: vscode.FileSystemWatcher;
   private disposed = false;
-  private isPolling = false;
   private readonly codexSessionsDir: string;
-  // path → mtime at last export; pre-seeded with current mtimes at startup
-  private readonly exported = new Map<string, number>();
+  // debounce: path → timer, so rapid writes to the same file export only once
+  private readonly debounce = new Map<string, NodeJS.Timeout>();
 
   constructor(
     private readonly workspaceRoot: string,
@@ -42,74 +38,104 @@ export class CodexWatcher implements vscode.Disposable {
       return;
     }
 
-    // Seed: record current mtime of every existing file WITHOUT exporting.
-    // This prevents a flood of exports on the first poll after Cursor opens.
-    try {
-      for (const filePath of scanCodexSessions(this.codexSessionsDir)) {
-        try {
-          this.exported.set(filePath, fs.statSync(filePath).mtimeMs);
-        } catch { /* skip inaccessible */ }
-      }
-    } catch (err) {
-      console.error('[codex-watcher] Seed scan failed:', err);
-    }
+    // ── 1. One-time startup scan ─────────────────────────────────────────────
+    // Export sessions that are missing from .codex-history/ (created while Cursor was closed).
+    // Uses the exporter's own de-dup (shortId matching) so nothing is doubled.
+    setImmediate(() => this.startupScan());
+
+    // ── 2. Event-driven watcher via VS Code API ──────────────────────────────
+    // RelativePattern with a Uri base works outside the workspace root.
+    // VS Code handles recursive subdirectory watching on all platforms.
+    const pattern = new vscode.RelativePattern(
+      vscode.Uri.file(this.codexSessionsDir),
+      '**/*.jsonl'
+    );
+    this.fsWatcher = vscode.workspace.createFileSystemWatcher(pattern);
 
-    // Start polling; first real tick picks up only files changed since seed.
-    this.pollTimer = setInterval(() => this.poll(), POLL_INTERVAL_MS);
+    this.fsWatcher.onDidCreate((uri) => this.scheduleExport(uri.fsPath));
+    this.fsWatcher.onDidChange((uri) => this.scheduleExport(uri.fsPath));
+    // onDidDelete: nothing to do — we leave the .md in place as history
 
     console.log(
-      `[codex-watcher] Seeded ${this.exported.size} existing sessions. ` +
-      `Polling every ${POLL_INTERVAL_MS / 1000}s → ${this.workspaceRoot}/.codex-history/`
+      `[codex-watcher] Watching ${this.codexSessionsDir} (event-driven) → ${this.workspaceRoot}/.codex-history/`
     );
   }
 
-  private poll(): void {
-    if (this.disposed || this.isPolling) return;
+  /** One-time catch-up: export any session not yet in .codex-history/ */
+  private startupScan(): void {
+    if (this.disposed) return;
 
     const cfg = vscode.workspace.getConfiguration('claudeCodeExporter');
     if (!cfg.get<boolean>('autoExport')) return;
 
-    this.isPolling = true;
+    const outDir = path.join(this.workspaceRoot, '.codex-history');
+    const existingMds = new Set<string>();
+    if (fs.existsSync(outDir)) {
+      for (const f of fs.readdirSync(outDir)) {
+        existingMds.add(f);
+      }
+    }
+
+    let files: string[];
     try {
-      let files: string[];
+      files = scanCodexSessions(this.codexSessionsDir);
+    } catch (err) {
+      console.error('[codex-watcher] Startup scan failed:', err);
+      return;
+    }
+
+    let exported = 0;
+    for (const filePath of files) {
+      if (this.disposed) break;
+      // Skip if a markdown with this session's shortId already exists
+      const basename = path.basename(filePath, '.jsonl');
+      // shortId: last UUID segment from rollout-DATE-UUID → first 8 hex chars of UUID
+      const uuidMatch = basename.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i);
+      if (uuidMatch) {
+        const shortId = uuidMatch[1].replace(/-/g, '').slice(0, 8);
+        if ([...existingMds].some((md) => md.includes(shortId))) continue;
+      }
+
+      try {
+        this.exporter.exportSessionToWorkspace(filePath, this.workspaceRoot);
+        exported++;
+      } catch { /* skip unreadable */ }
+    }
+
+    if (exported > 0) {
+      console.log(`[codex-watcher] Startup scan exported ${exported} missing session(s).`);
+    }
+  }
+
+  /** Debounced export: wait 1s after last write before exporting */
+  private scheduleExport(filePath: string): void {
+    if (this.disposed) return;
+
+    const existing = this.debounce.get(filePath);
+    if (existing) clearTimeout(existing);
+
+    const timer = setTimeout(() => {
+      this.debounce.delete(filePath);
+      if (this.disposed) return;
+
+      const cfg = vscode.workspace.getConfiguration('claudeCodeExporter');
+      if (!cfg.get<boolean>('autoExport')) return;
+
       try {
-        files = scanCodexSessions(this.codexSessionsDir);
+        const outPath = this.exporter.exportSessionToWorkspace(filePath, this.workspaceRoot);
+        console.log(`[codex-watcher] Exported → ${outPath}`);
       } catch (err) {
-        console.error('[codex-watcher] Scan failed:', err);
-        return;
+        console.error(`[codex-watcher] Export failed: ${filePath}`, err);
       }
+    }, 1000);
 
-      for (const filePath of files) {
-        if (this.disposed) break;
-
-        let mtime: number;
-        try {
-          mtime = fs.statSync(filePath).mtimeMs;
-        } catch {
-          continue;
-        }
-
-        const lastExported = this.exported.get(filePath) ?? 0;
-        if (mtime <= lastExported) continue;
-
-        try {
-          const outPath = this.exporter.exportSessionToWorkspace(filePath, this.workspaceRoot);
-          this.exported.set(filePath, mtime);
-          console.log(`[codex-watcher] Auto-exported → ${outPath}`);
-        } catch (err) {
-          console.error(`[codex-watcher] Export failed: ${filePath}`, err);
-        }
-      }
-    } finally {
-      this.isPolling = false;
-    }
+    this.debounce.set(filePath, timer);
   }
 
   dispose(): void {
     this.disposed = true;
-    if (this.pollTimer) {
-      clearInterval(this.pollTimer);
-      this.pollTimer = undefined;
-    }
+    this.fsWatcher?.dispose();
+    for (const t of this.debounce.values()) clearTimeout(t);
+    this.debounce.clear();
   }
 }