fix: replace fs.watch with 30s polling for Codex sessions (v0.8.8)

fs.watch { recursive:true } on Windows fails to detect new files when Codex
creates a new date subdirectory (YYYY/MM/DD/) mid-session. Polling every 30s
via scanCodexSessions() reliably catches all new/modified .jsonl files
regardless of directory structure changes. Tracks exported mtime per file
to avoid re-exporting unchanged sessions.

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.7",
+  "version": "0.8.8",
   "publisher": "myoontyee",
   "engines": {
     "vscode": "^1.85.0"

src/codexWatcher.ts

@@ -1,19 +1,27 @@
 /**
- * codexWatcher.ts — Watch ~/.codex/sessions/ for new Codex CLI sessions
+ * codexWatcher.ts — Watch ~/.codex/sessions/ for new Codex CLI/APP sessions
  * and auto-export to .codex-history/
+ *
+ * Uses a polling approach (scan every 30s) instead of fs.watch because
+ * fs.watch { recursive:true } on Windows misses files created inside newly
+ * added subdirectories (the YYYY/MM/DD/ structure Codex creates daily).
  */
 
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 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 watcher?: fs.FSWatcher;
-  private debounceTimers = new Map<string, NodeJS.Timeout>();
+  private pollTimer?: NodeJS.Timeout;
   private disposed = false;
-  private codexSessionsDir: string;
+  private readonly codexSessionsDir: string;
+  // Track files we've already exported: path → last mtime we exported at
+  private readonly exported = new Map<string, number>();
 
   constructor(
     private readonly workspaceRoot: string,
@@ -28,56 +36,55 @@ export class CodexWatcher implements vscode.Disposable {
       return;
     }
 
-    // Watch recursively (YYYY/MM/DD/ structure)
-    this.watcher = fs.watch(
-      this.codexSessionsDir,
-      { recursive: true },
-      (_event, filename) => {
-        if (!filename || !filename.endsWith('.jsonl')) return;
-
-        const fullPath = path.join(this.codexSessionsDir, filename);
-        const existing = this.debounceTimers.get(fullPath);
-        if (existing) clearTimeout(existing);
-
-        const timer = setTimeout(() => {
-          this.debounceTimers.delete(fullPath);
-          this.handleChange(fullPath);
-        }, 500);
-
-        this.debounceTimers.set(fullPath, timer);
-      }
-    );
-
-    this.watcher.on('error', (err) => {
-      console.error('[codex-watcher] Watcher error:', err);
-    });
+    // Run once immediately, then on interval
+    this.poll();
+    this.pollTimer = setInterval(() => this.poll(), POLL_INTERVAL_MS);
 
     console.log(
-      `[codex-watcher] Watching ${this.codexSessionsDir} → ${this.workspaceRoot}/.codex-history/`
+      `[codex-watcher] Polling ${this.codexSessionsDir} every ${POLL_INTERVAL_MS / 1000}s → ${this.workspaceRoot}/.codex-history/`
     );
   }
 
-  private handleChange(filePath: string): void {
-    if (this.disposed || !fs.existsSync(filePath)) return;
+  private poll(): void {
+    if (this.disposed) return;
 
     const cfg = vscode.workspace.getConfiguration('claudeCodeExporter');
     if (!cfg.get<boolean>('autoExport')) return;
 
+    let files: string[];
     try {
-      const outPath = this.exporter.exportSessionToWorkspace(
-        filePath,
-        this.workspaceRoot
-      );
-      console.log(`[codex-watcher] Auto-exported → ${outPath}`);
+      files = scanCodexSessions(this.codexSessionsDir);
     } catch (err) {
-      console.error(`[codex-watcher] Export failed: ${filePath}`, err);
+      console.error('[codex-watcher] Scan failed:', err);
+      return;
+    }
+
+    for (const filePath of files) {
+      let mtime: number;
+      try {
+        mtime = fs.statSync(filePath).mtimeMs;
+      } catch {
+        continue;
+      }
+
+      const lastExported = this.exported.get(filePath) ?? 0;
+      if (mtime <= lastExported) continue; // not changed since last export
+
+      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);
+      }
     }
   }
 
   dispose(): void {
     this.disposed = true;
-    this.watcher?.close();
-    for (const t of this.debounceTimers.values()) clearTimeout(t);
-    this.debounceTimers.clear();
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = undefined;
+    }
   }
 }