getaimeter 0.7.2 → 0.7.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getaimeter",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Track AI coding costs across Claude, Cursor, Codex, and Gemini. Optimization recommendations that cut costs by 30%.",
   "bin": {
     "aimeter": "cli.js"

package/service.js

@@ -98,37 +98,44 @@ WshShell.Run """${nodePath}"" ""${script}"" watch", 0, False
  * These are proper Windows shortcuts with icon and description.
  */
 function createWindowsShortcuts(nodePath, script) {
-  const iconPath = path.join(__dirname, 'icon.ico').replace(/\\/g, '\\\\');
+  const { execSync } = require('child_process');
+  const iconPath = path.join(__dirname, 'icon.ico');
+
   const locations = [
-    { name: 'Desktop', dir: path.join(os.homedir(), 'Desktop') },
-    { name: 'Start Menu', dir: path.join(os.homedir(), 'AppData', 'Roaming', 'Microsoft', 'Windows', 'Start Menu', 'Programs') },
+    path.join(os.homedir(), 'Desktop', 'AIMeter.lnk'),
+    path.join(os.homedir(), 'AppData', 'Roaming', 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'AIMeter.lnk'),
   ];
 
-  for (const loc of locations) {
-    const lnkPath = path.join(loc.dir, 'AIMeter.lnk');
-    // PowerShell script to create a .lnk shortcut
-    const ps = `
-$ws = New-Object -ComObject WScript.Shell
-$s = $ws.CreateShortcut('${lnkPath.replace(/'/g, "''")}')
-$s.TargetPath = '${nodePath.replace(/\\\\/g, '\\').replace(/'/g, "''")}'
-$s.Arguments = '"${script.replace(/\\\\/g, '\\').replace(/'/g, "''")}" start'
-$s.WorkingDirectory = '${os.homedir().replace(/'/g, "''")}'
-$s.Description = 'AIMeter - AI coding cost optimizer'
-$s.WindowStyle = 7
-$iconFile = '${iconPath.replace(/\\\\/g, '\\').replace(/'/g, "''")}'
-if (Test-Path $iconFile) { $s.IconLocation = $iconFile }
-$s.Save()
-`.trim();
+  // Write a temporary PS1 file to avoid all escaping issues
+  const ps1Path = path.join(os.tmpdir(), 'aimeter-shortcut.ps1');
+
+  for (const lnkPath of locations) {
+    // Use single quotes in PS1 with doubled single-quote escaping
+    const ps1Content = [
+      '$ws = New-Object -ComObject WScript.Shell',
+      `$s = $ws.CreateShortcut('${lnkPath.replace(/'/g, "''")}')`,
+      `$s.TargetPath = '${nodePath.replace(/\\\\/g, '\\').replace(/'/g, "''")}'`,
+      `$s.Arguments = [char]34 + '${script.replace(/\\\\/g, '\\').replace(/'/g, "''")}' + [char]34 + ' start'`,
+      `$s.WorkingDirectory = '${os.homedir().replace(/'/g, "''")}'`,
+      `$s.Description = 'AIMeter - AI coding cost optimizer'`,
+      `$s.WindowStyle = 7`,
+      `$icon = '${iconPath.replace(/'/g, "''")}'`,
+      `if (Test-Path $icon) { $s.IconLocation = $icon }`,
+      `$s.Save()`,
+    ].join('\n');
 
     try {
-      require('child_process').execSync(
-        `powershell -NoProfile -ExecutionPolicy Bypass -Command "${ps.replace(/"/g, '\\"')}"`,
-        { stdio: 'ignore', timeout: 10000 }
-      );
+      fs.writeFileSync(ps1Path, ps1Content, 'utf8');
+      execSync(`powershell -NoProfile -ExecutionPolicy Bypass -File "${ps1Path}"`, {
+        stdio: 'ignore',
+        timeout: 10000,
+      });
     } catch {
       // Non-critical — shortcuts are convenience, not required
     }
   }
+
+  try { fs.unlinkSync(ps1Path); } catch {}
 }
 
 function uninstallWindows() {

package/watcher.js

@@ -159,31 +159,51 @@ function extractNewUsage(filePath) {
     }
 
     if (!msg) {
-      // ── Codex CLI format ──────────────────────────────────────────
-      // Codex events have { type: "event", payload: { type: "token_count", ... } }
-      // with cumulative input_tokens, output_tokens, reasoning_tokens, cached_input_tokens
-      if (obj.type === 'event' && obj.payload?.type === 'token_count') {
-        const p = obj.payload;
+      // ── Codex CLI format (old: type="event", new: type="event_msg") ──
+      // Old format: { type: "event", payload: { type: "token_count", input_tokens, ... } }
+      // New format: { type: "event_msg", payload: { type: "token_count", info: { total_token_usage: { input_tokens, ... } } } }
+      if ((obj.type === 'event' || obj.type === 'event_msg') && obj.payload?.type === 'token_count') {
+        // Extract token counts — handle both old (flat) and new (nested) format
+        let inputTokens, outputTokens, reasoningTokens, cachedTokens;
+
+        if (obj.payload.info?.total_token_usage) {
+          // New format (2026+): cumulative totals in info.total_token_usage
+          const t = obj.payload.info.total_token_usage;
+          inputTokens = t.input_tokens || 0;
+          outputTokens = t.output_tokens || 0;
+          reasoningTokens = t.reasoning_output_tokens || t.reasoning_tokens || 0;
+          cachedTokens = t.cached_input_tokens || 0;
+        } else {
+          // Old format: flat fields on payload
+          inputTokens = obj.payload.input_tokens || 0;
+          outputTokens = obj.payload.output_tokens || 0;
+          reasoningTokens = obj.payload.reasoning_tokens || 0;
+          cachedTokens = obj.payload.cached_input_tokens || 0;
+        }
+
+        // Skip events with no token info (e.g. rate limit only events)
+        if (inputTokens === 0 && outputTokens === 0) continue;
+
         const codexModel = obj.turn_context?.model || 'codex';
+
         // Token counts are cumulative per session; we store deltas
-        // Use a per-file tracker for the previous cumulative values
         const prevKey = filePath;
         const prev = _codexCumulative[prevKey] || { input: 0, output: 0, reasoning: 0, cached: 0 };
-        const deltaInput = (p.input_tokens || 0) - prev.input;
-        const deltaOutput = (p.output_tokens || 0) - prev.output;
-        const deltaReasoning = (p.reasoning_tokens || 0) - prev.reasoning;
+        const deltaInput = inputTokens - prev.input;
+        const deltaOutput = outputTokens - prev.output;
+        const deltaReasoning = reasoningTokens - prev.reasoning;
 
         _codexCumulative[prevKey] = {
-          input: p.input_tokens || 0,
-          output: p.output_tokens || 0,
-          reasoning: p.reasoning_tokens || 0,
-          cached: p.cached_input_tokens || 0,
+          input: inputTokens,
+          output: outputTokens,
+          reasoning: reasoningTokens,
+          cached: cachedTokens,
         };
 
         // Skip if no new tokens (duplicate or first read)
         if (deltaInput <= 0 && deltaOutput <= 0) continue;
 
-        const hashKey = `${filePath}:${lineOffset}:codex:${p.input_tokens}:${p.output_tokens}`;
+        const hashKey = `${filePath}:${lineOffset}:codex:${inputTokens}:${outputTokens}`;
         const hash = crypto.createHash('md5').update(hashKey).digest('hex');
         if (isDuplicate(hash)) continue;
 
@@ -194,7 +214,7 @@ function extractNewUsage(filePath) {
           inputTokens:      deltaInput,
           outputTokens:     deltaOutput,
           thinkingTokens:   deltaReasoning,
-          cacheReadTokens:  0,
+          cacheReadTokens:  cachedTokens,
           cacheWriteTokens: 0,
         });
         continue;