getaimeter 0.1.4 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getaimeter",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Track your Claude AI usage across CLI, VS Code, and Desktop App. One command to start.",
   "bin": {
     "aimeter": "cli.js"

package/watcher.js

@@ -137,39 +137,20 @@ async function reportEvents(events) {
 // File watcher
 // ---------------------------------------------------------------------------
 
-const _debounceTimers = new Map();
-const _processing = new Set();
-
-function handleFileChange(filePath) {
-  // Only care about .jsonl files
-  if (!filePath.endsWith('.jsonl')) return;
-
-  // Normalize path for consistent debounce key (Windows fires with mixed separators/casing)
-  const normalizedKey = path.resolve(filePath).toLowerCase();
-
-  // Skip if already being processed
-  if (_processing.has(normalizedKey)) return;
-
-  // Debounce: wait 2000ms after last change before processing
-  const existing = _debounceTimers.get(normalizedKey);
-  if (existing) clearTimeout(existing);
-
-  _debounceTimers.set(normalizedKey, setTimeout(async () => {
-    _debounceTimers.delete(normalizedKey);
-    if (_processing.has(normalizedKey)) return;
-    _processing.add(normalizedKey);
-    try {
-      const events = extractNewUsage(filePath);
-      if (events.length > 0) {
-        await reportEvents(events);
-        saveState();
-      }
-    } catch (err) {
-      logError(`Processing ${filePath}:`, err.message);
-    } finally {
-      _processing.delete(normalizedKey);
+/**
+ * Process a single file: extract new usage and report it.
+ * Called only from the poll loop — single-threaded, no races.
+ */
+async function processFile(filePath) {
+  try {
+    const events = extractNewUsage(filePath);
+    if (events.length > 0) {
+      await reportEvents(events);
+      saveState();
     }
-  }, 2000));
+  } catch (err) {
+    logError(`Processing ${filePath}:`, err.message);
+  }
 }
 
 /**
@@ -248,45 +229,32 @@ function startWatching() {
   }
   saveState();
 
-  // Set up fs.watch on each path (works well on macOS/Linux)
-  const watchers = [];
-  for (const watchPath of watchPaths) {
-    try {
-      const w = fs.watch(watchPath, { recursive: true }, (eventType, filename) => {
-        if (!filename) return;
-        const fullPath = path.join(watchPath, filename);
-        handleFileChange(fullPath);
-      });
-
-      w.on('error', (err) => {
-        logError(`Watcher error on ${watchPath}:`, err.message);
-      });
-
-      watchers.push(w);
-      log('Watching (fs.watch):', watchPath);
-    } catch (err) {
-      logError(`Could not watch ${watchPath}:`, err.message);
-    }
-  }
-
-  // Polling fallback — fs.watch is unreliable on Windows for deeply nested dirs.
-  // Every 5 seconds, scan all known JSONL files for size changes.
+  // Poll every 5 seconds — simple, reliable, no race conditions.
+  // fs.watch is unreliable on Windows for deeply nested dirs and fires duplicates.
   const POLL_INTERVAL = 5_000;
-  const pollInterval = setInterval(() => {
-    for (const watchPath of watchPaths) {
-      const files = findJsonlFiles(watchPath);
-      for (const file of files) {
-        try {
-          const currentSize = fs.statSync(file).size;
-          const lastOffset  = getOffset(file);
-          if (currentSize > lastOffset) {
-            handleFileChange(file);
-          }
-        } catch {}
+  let polling = false;
+
+  const pollInterval = setInterval(async () => {
+    if (polling) return; // skip if previous poll still running
+    polling = true;
+    try {
+      for (const watchPath of watchPaths) {
+        const files = findJsonlFiles(watchPath);
+        for (const file of files) {
+          try {
+            const currentSize = fs.statSync(file).size;
+            const lastOffset  = getOffset(file);
+            if (currentSize > lastOffset) {
+              await processFile(file);
+            }
+          } catch {}
+        }
       }
+    } finally {
+      polling = false;
     }
   }, POLL_INTERVAL);
-  log(`Polling every ${POLL_INTERVAL / 1000}s as fallback`);
+  log(`Polling every ${POLL_INTERVAL / 1000}s`);
 
   // Periodic state save
   const saveInterval = setInterval(() => saveState(), 30_000);
@@ -295,8 +263,6 @@ function startWatching() {
   return () => {
     clearInterval(saveInterval);
     clearInterval(pollInterval);
-    for (const w of watchers) w.close();
-    for (const t of _debounceTimers.values()) clearTimeout(t);
     saveState();
     log('Watcher stopped.');
   };