npm - tokentracker-cli - Versions diffs - 0.14.5 → 0.15.0 - Mend

tokentracker-cli 0.14.5 → 0.15.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/README.md +6 -4
package/dashboard/dist/assets/{main-BZ54G0n1.js → main-DAAixEqh.js} +169 -169
package/dashboard/dist/index.html +1 -1
package/dashboard/dist/share.html +1 -1
package/package.json +2 -2
package/src/commands/init.js +25 -0
package/src/commands/status.js +12 -0
package/src/commands/sync.js +68 -0
package/src/commands/uninstall.js +5 -0
package/src/lib/diagnostics.js +13 -0
package/src/lib/grok-hook.js +272 -0
package/src/lib/pricing/curated-overrides.json +8 -0
package/src/lib/pricing/seed-snapshot.json +1 -1
package/src/lib/rollout.js +250 -0

package/dashboard/dist/index.html CHANGED Viewed

@@ -210,7 +210,7 @@
         ]
       }
     </script>
-    <script type="module" crossorigin src="/assets/main-BZ54G0n1.js"></script>
+    <script type="module" crossorigin src="/assets/main-DAAixEqh.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/main-B-qohcBn.css">
   </head>
   <body>

package/dashboard/dist/share.html CHANGED Viewed

@@ -51,7 +51,7 @@
         "description": "Shareable Token Tracker dashboard snapshot."
       }
     </script>
-    <script type="module" crossorigin src="/assets/main-BZ54G0n1.js"></script>
+    <script type="module" crossorigin src="/assets/main-DAAixEqh.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/main-B-qohcBn.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "tokentracker-cli",
-  "version": "0.14.5",
-  "description": "Token usage tracker for AI agent CLIs (Claude Code, Codex, Cursor, Gemini, Kiro, OpenCode, OpenClaw, Every Code, Hermes, GitHub Copilot, Kimi Code, CodeBuddy, oh-my-pi, pi, Craft Agents, Kilo CLI, Kilo Code)",
+  "version": "0.15.0",
+  "description": "Token usage tracker for AI agent CLIs (Claude Code, Codex, Cursor, Gemini, Kiro, OpenCode, OpenClaw, Every Code, Hermes, GitHub Copilot, Kimi Code, CodeBuddy, Grok Build, oh-my-pi, pi, Craft Agents, Kilo CLI, Kilo Code)",
   "main": "src/cli.js",
   "bin": {
     "tokentracker-cli": "bin/tracker.js",

package/src/commands/init.js CHANGED Viewed

@@ -43,6 +43,14 @@ const {
   installOpenclawSessionPlugin,
   probeOpenclawSessionPluginState,
 } = require("../lib/openclaw-session-plugin");
+const {
+  resolveGrokHome,
+  resolveGrokHooksDir,
+  upsertGrokHook,
+  probeGrokHookState,
+  removeGrokHook,
+  GROK_HOOK_FILENAME
+} = require("../lib/grok-hook");
 const { resolveTrackerPaths } = require("../lib/tracker-paths");
 const {
   resolveOmpAgentDir,
@@ -506,6 +514,23 @@ async function applyIntegrationSetup({ home, trackerDir, notifyPath, notifyOrigi
     }
   }
+  // Grok Build (xAI): SessionEnd hook in ~/.grok/hooks/ + handler in ~/.tokentracker/bin/
+  {
+    try {
+      const grokState = await probeGrokHookState({ home, trackerDir, env: process.env });
+      if (grokState.hasGrokInstall) {
+        const grokRes = await upsertGrokHook({ home, trackerDir, env: process.env });
+        summary.push({
+          label: "Grok Build",
+          status: grokRes.configured ? "installed" : "detected",
+          detail: grokRes.configured ? "SessionEnd hook installed (99-tokentracker-usage.json)" : "Grok detected"
+        });
+      }
+    } catch (err) {
+      summary.push({ label: "Grok Build", status: "error", detail: String(err?.message || err) });
+    }
+  }
   // Kilo CLI (kilo.ai @kilocode/plugin): passive reader — no hook installation
   // needed. Reuses OpenCode-fork SQLite schema at ~/.local/share/kilo/kilo.db
   // (override via KILO_HOME).

package/src/commands/status.js CHANGED Viewed

@@ -47,7 +47,9 @@ const {
   resolveCraftSessionFiles,
   resolveCraftConfigDir,
   resolveKilocodeTaskFiles,
+  resolveGrokBuildSessions,
 } = require("../lib/rollout");
+const { probeGrokHookState, resolveGrokHome } = require("../lib/grok-hook");
 async function cmdStatus(argv = []) {
   const opts = parseArgs(argv);
@@ -212,6 +214,13 @@ async function cmdStatus(argv = []) {
   const kilocodeTaskFiles = resolveKilocodeTaskFiles(process.env);
   const kilocodeInstalled = kilocodeTaskFiles.length > 0;
+  // Grok Build (xAI TUI)
+  const grokHookState = await probeGrokHookState({ home, trackerDir, env: process.env });
+  const grokSessions = grokHookState.hasGrokInstall || grokHookState.sessionsDir
+    ? resolveGrokBuildSessions(process.env)
+    : [];
+  const grokInstalled = grokHookState.hasGrokInstall || grokSessions.length > 0;
   const copilotToken = readCopilotOauthToken({ home });
   const copilotOtel = describeCopilotOtelStatus({ home, env: process.env });
   const copilotLines = formatCopilotLines({
@@ -265,6 +274,9 @@ async function cmdStatus(argv = []) {
       kilocodeInstalled
         ? `- Kilo Code (VS Code extension): passive reader (${kilocodeTaskFiles.length} task${kilocodeTaskFiles.length !== 1 ? "s" : ""} across ${new Set(kilocodeTaskFiles.map((t) => t.ide)).size} IDE${new Set(kilocodeTaskFiles.map((t) => t.ide)).size !== 1 ? "s" : ""})`
         : null,
+      grokInstalled
+        ? `- Grok Build (xAI): ${grokHookState.configured ? "hook installed" : "detected"} (${grokSessions.length} session${grokSessions.length !== 1 ? "s" : ""} found, hook: ${grokHookState.configured ? "yes" : "no"})`
+        : null,
       ...copilotLines,
       ...subscriptionLines,
       "",

package/src/commands/sync.js CHANGED Viewed

@@ -35,6 +35,8 @@ const {
   piAgentDirCollidesWithOmp,
   resolveCraftSessionFiles,
   parseCraftIncremental,
+  resolveGrokBuildSessions,
+  parseGrokBuildIncremental,
   resolveCodebuddyProjectFiles,
   parseCodebuddyIncremental,
   resolveKiroCliSessionFiles,
@@ -121,11 +123,24 @@ async function cmdSync(argv) {
     const projectQueuePath = path.join(trackerDir, "project.queue.jsonl");
     const projectQueueStatePath = path.join(trackerDir, "project.queue.state.json");
     const uploadThrottlePath = path.join(trackerDir, "upload.throttle.json");
+    const grokSignalPath = path.join(trackerDir, "grok-last-session.json");
+    const legacyGrokSignalPath = path.join(trackerDir, "tracker", "grok-last-session.json");
     const config = await readJson(configPath);
     const cursors = (await readJson(cursorsPath)) || { version: 1, files: {}, updatedAt: null };
     const uploadThrottle = normalizeUploadState(await readJson(uploadThrottlePath));
     let uploadThrottleState = uploadThrottle;
+    let grokHookSignal = null;
+    let grokHookSignalPath = null;
+    for (const candidate of [grokSignalPath, legacyGrokSignalPath]) {
+      const signal = await readJson(candidate);
+      if (signal && typeof signal === "object") {
+        grokHookSignal = signal;
+        grokHookSignalPath = candidate;
+        break;
+      }
+    }
+    let grokHookSignalConsumed = false;
     const codexHome = process.env.CODEX_HOME || path.join(home, ".codex");
     const codeHome = process.env.CODE_HOME || path.join(home, ".code");
@@ -627,6 +642,54 @@ async function cmdSync(argv) {
       });
     }
+    // ── Grok Build (xAI) ──
+    let grokResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    // Full passive scan of all Grok sessions (historical + any not covered by hook)
+    const grokSessions = resolveGrokBuildSessions(process.env);
+    const grokSessionInputs = [...grokSessions];
+    if (grokHookSignal && typeof grokHookSignal === "object") {
+      const hookSessionId =
+        typeof grokHookSignal.sessionId === "string" && grokHookSignal.sessionId.trim()
+          ? grokHookSignal.sessionId.trim()
+          : null;
+      if (hookSessionId) {
+        grokSessionInputs.unshift({
+          sessionId: hookSessionId,
+          signals: {
+            contextTokensUsed: grokHookSignal.totalTokens,
+            assistantMessageCount: grokHookSignal.messageCount,
+            primaryModelId: grokHookSignal.model,
+            lastActiveAt: grokHookSignal.lastActive,
+          },
+          summary: { updated_at: grokHookSignal.lastActive },
+        });
+      }
+      grokHookSignalConsumed = true;
+    }
+    if (grokSessionInputs.length > 0) {
+      if (progress?.enabled) {
+        progress.start(`Parsing Grok Build ${renderBar(0)} | buckets 0`);
+      }
+      const grokScanResult = await parseGrokBuildIncremental({
+        sessions: grokSessionInputs,
+        cursors,
+        queuePath,
+        env: process.env,
+        onProgress: (p) => {
+          if (!progress?.enabled) return;
+          const pct = p.total > 0 ? p.index / p.total : 1;
+          progress.update(
+            `Parsing Grok Build ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} sessions | buckets ${formatNumber(p.bucketsQueued)}`,
+          );
+        },
+      });
+      grokResult = {
+        recordsProcessed: grokResult.recordsProcessed + grokScanResult.recordsProcessed,
+        eventsAggregated: grokResult.eventsAggregated + grokScanResult.eventsAggregated,
+        bucketsQueued: grokResult.bucketsQueued + grokScanResult.bucketsQueued,
+      };
+    }
     // ── GitHub Copilot CLI (OTEL JSONL files) ──
     let copilotResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
     const copilotPaths = resolveCopilotOtelPaths(process.env);
@@ -666,6 +729,9 @@ async function cmdSync(argv) {
     cursors.updatedAt = new Date().toISOString();
     await writeJson(cursorsPath, cursors);
+    if (grokHookSignalConsumed && grokHookSignalPath) {
+      await fs.unlink(grokHookSignalPath).catch(() => {});
+    }
     progress?.stop();
@@ -749,6 +815,7 @@ async function cmdSync(argv) {
         ompResult.recordsProcessed +
         piResult.recordsProcessed +
         craftResult.recordsProcessed +
+        grokResult.recordsProcessed +
         copilotResult.recordsProcessed +
         kiloResult.messagesProcessed +
         kilocodeResult.recordsProcessed;
@@ -767,6 +834,7 @@ async function cmdSync(argv) {
         ompResult.bucketsQueued +
         piResult.bucketsQueued +
         craftResult.bucketsQueued +
+        grokResult.bucketsQueued +
         copilotResult.bucketsQueued +
         kiloResult.bucketsQueued +
         kilocodeResult.bucketsQueued;

package/src/commands/uninstall.js CHANGED Viewed

@@ -13,6 +13,7 @@ const {
 const { resolveOpencodeConfigDir, removeOpencodePlugin } = require("../lib/opencode-config");
 const { removeOpenclawHookConfig } = require("../lib/openclaw-hook");
 const { removeOpenclawSessionPluginConfig } = require("../lib/openclaw-session-plugin");
+const { removeGrokHook } = require("../lib/grok-hook");
 const { resolveTrackerPaths } = require("../lib/tracker-paths");
 async function cmdUninstall(argv) {
@@ -79,6 +80,7 @@ async function cmdUninstall(argv) {
     env: process.env,
   });
   const openclawHookRemove = await removeOpenclawHookConfig({ home, trackerDir, env: process.env });
+  const grokHookRemove = await removeGrokHook({ home, trackerDir, env: process.env });
   // Remove installed notify handler.
   await fs.unlink(notifyPath).catch(() => {});
@@ -147,6 +149,9 @@ async function cmdUninstall(argv) {
         : openclawHookRemove?.skippedReason === "openclaw-config-missing"
           ? "- OpenClaw hook (legacy): skipped (openclaw config not found)"
           : "- OpenClaw hook (legacy): no change",
+      grokHookRemove?.removed
+        ? `- Grok Build hook removed: ${grokHookRemove.hookPath}`
+        : "- Grok Build hook: no change",
       opts.purge ? `- Purged: ${path.join(home, ".tokentracker")}` : "- Purge: skipped (use --purge)",
       "",
     ].join("\n"),

package/src/lib/diagnostics.js CHANGED Viewed

@@ -15,6 +15,7 @@ const { resolveOpencodeConfigDir, isOpencodePluginInstalled } = require("./openc
 const { normalizeState: normalizeUploadState } = require("./upload-throttle");
 const { probeOpenclawHookState } = require("./openclaw-hook");
 const { probeOpenclawSessionPluginState } = require("./openclaw-session-plugin");
+const { probeGrokHookState } = require("./grok-hook");
 const { resolveTrackerPaths } = require("./tracker-paths");
 // TASK-011: Kiro CLI DB path inlined here to avoid pulling the ~4000-line
 // rollout module on every `tokentracker status` / `diagnostics` call.
@@ -52,6 +53,10 @@ async function collectTrackerDiagnostics({
   const geminiConfigDir = resolveGeminiConfigDir({ home, env: process.env });
   const geminiSettingsPath = resolveGeminiSettingsPath({ configDir: geminiConfigDir });
   const opencodeConfigDir = resolveOpencodeConfigDir({ home, env: process.env });
+  const grokHome =
+    process.env.TOKENTRACKER_GROK_HOME ||
+    process.env.GROK_HOME ||
+    path.join(home, ".grok");
   const config = await readJson(configPath);
   const cursors = await readJson(cursorsPath);
@@ -94,6 +99,7 @@ async function collectTrackerDiagnostics({
     env: process.env,
   });
   const openclawHookState = await probeOpenclawHookState({ home, trackerDir, env: process.env });
+  const grokHookState = await probeGrokHookState({ home, trackerDir, env: process.env });
   // Kiro IDE and Kiro CLI sub-path presence — merged under one "kiro" source
   // at token/cost aggregation level; operators need visibility of both
@@ -137,6 +143,9 @@ async function collectTrackerDiagnostics({
       claude_config: redactValue(claudeConfigPath, home),
       gemini_config: redactValue(geminiSettingsPath, home),
       opencode_config: redactValue(opencodeConfigDir, home),
+      grok_home: redactValue(grokHome, home),
+      grok_hooks: redactValue(grokHookState?.grokHooksDir, home),
+      grok_handler: redactValue(grokHookState?.handlerPath, home),
       kiro_ide_dev_data: redactValue(kiroIdeDevDataDir, home),
       kiro_cli_db: redactValue(kiroCliDbPath, home),
     },
@@ -184,6 +193,10 @@ async function collectTrackerDiagnostics({
       openclaw_hook_configured: Boolean(openclawHookState?.configured),
       openclaw_hook_linked: Boolean(openclawHookState?.linked),
       openclaw_hook_enabled: Boolean(openclawHookState?.enabled),
+      grok_hook_configured: Boolean(grokHookState?.configured),
+      grok_hook_exists: Boolean(grokHookState?.hookExists),
+      grok_hook_handler_exists: Boolean(grokHookState?.handlerExists),
+      grok_sessions_dir: redactValue(grokHookState?.sessionsDir, home),
     },
     upload: {
       last_success_at: lastSuccessAt,

package/src/lib/grok-hook.js ADDED Viewed

@@ -0,0 +1,272 @@
+const os = require("node:os");
+const path = require("node:path");
+const fs = require("node:fs/promises");
+const fssync = require("node:fs");
+const GROK_HOOK_FILENAME = "99-tokentracker-usage.json";
+function resolveGrokHome(env = process.env) {
+  if (env.TOKENTRACKER_GROK_HOME && env.TOKENTRACKER_GROK_HOME.length > 0) {
+    return env.TOKENTRACKER_GROK_HOME;
+  }
+  if (env.GROK_HOME && env.GROK_HOME.length > 0) {
+    return env.GROK_HOME;
+  }
+  return path.join(os.homedir(), ".grok");
+}
+function resolveGrokHooksDir(env = process.env) {
+  return path.join(resolveGrokHome(env), "hooks");
+}
+function resolveTrackerBinDir(trackerDir) {
+  if (!trackerDir) throw new Error("trackerDir is required");
+  return path.basename(trackerDir) === "tracker"
+    ? path.join(path.dirname(trackerDir), "bin")
+    : path.join(trackerDir, "bin");
+}
+function resolveLegacyTrackerBinDir(trackerDir) {
+  if (!trackerDir) throw new Error("trackerDir is required");
+  return path.join(trackerDir, "bin");
+}
+function buildGrokSessionEndHookJson({ notifyGrokHandlerPath }) {
+  // The command runs our dedicated handler.
+  // We pass the session id and cwd via environment variables that Grok already sets.
+  const cmd = `/usr/bin/env node ${shellQuote(notifyGrokHandlerPath)}`;
+  return {
+    hooks: {
+      SessionEnd: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: cmd,
+              timeout: 60
+            }
+          ]
+        }
+      ]
+    }
+  };
+}
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+async function ensureGrokHookFiles({
+  grokHooksDir,
+  trackerDir,
+  handlerSource // path to the .cjs template we will write
+} = {}) {
+  if (!grokHooksDir || !trackerDir) {
+    throw new Error("grokHooksDir and trackerDir are required");
+  }
+  await fs.mkdir(grokHooksDir, { recursive: true });
+  const hookPath = path.join(grokHooksDir, GROK_HOOK_FILENAME);
+  const binDir = resolveTrackerBinDir(trackerDir);
+  await fs.mkdir(binDir, { recursive: true });
+  const handlerPath = path.join(binDir, "grok-session-end-hook.cjs");
+  // Write the hook JSON (always overwrite to keep command up-to-date if bin path changes)
+  const hookJson = buildGrokSessionEndHookJson({ notifyGrokHandlerPath: handlerPath });
+  await fs.writeFile(hookPath, JSON.stringify(hookJson, null, 2) + "\n", "utf8");
+  // Write (or update) the handler script
+  const handlerSourceCode = buildGrokSessionEndHandler({ trackerDir });
+  await fs.writeFile(handlerPath, handlerSourceCode, "utf8");
+  // Make executable
+  try {
+    fssync.chmodSync(handlerPath, 0o755);
+  } catch {}
+  return { hookPath, handlerPath };
+}
+function buildGrokSessionEndHandler({ trackerDir }) {
+  // This is the source of the .cjs that will be executed by the Grok hook.
+  // It must be self-contained enough or rely on the copied runtime.
+  // For simplicity and reliability we write a small script that:
+  // 1. Reads GROK_SESSION_ID + GROK_WORKSPACE_ROOT from env
+  // 2. Locates the signals.json
+  // 3. Extracts usage
+  // 4. Writes a signal file under trackerDir that sync.js will pick up on next run
+  return `#!/usr/bin/env node
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const GROK_HOME = process.env.TOKENTRACKER_GROK_HOME || process.env.GROK_HOME || path.join(os.homedir(), '.grok');
+const SESSION_ID = process.env.GROK_SESSION_ID;
+const WORKSPACE_ROOT = process.env.GROK_WORKSPACE_ROOT || process.cwd();
+if (!SESSION_ID) {
+  process.exit(0); // nothing to do
+}
+function encodeGrokCwd(cwd) {
+  // Grok uses encodeURIComponent on the full path, replacing / with %2F etc.
+  return encodeURIComponent(cwd);
+}
+const encodedCwd = encodeGrokCwd(WORKSPACE_ROOT);
+const sessionDir = path.join(GROK_HOME, 'sessions', encodedCwd, SESSION_ID);
+const signalsPath = path.join(sessionDir, 'signals.json');
+const summaryPath = path.join(sessionDir, 'summary.json');
+let signals = null;
+try {
+  const raw = fs.readFileSync(signalsPath, 'utf8');
+  signals = JSON.parse(raw);
+} catch (err) {
+  // Session may still be active or signals not written yet; exit quietly
+  process.exit(0);
+}
+const summary = (() => {
+  try {
+    return JSON.parse(fs.readFileSync(summaryPath, 'utf8'));
+  } catch {
+    return {};
+  }
+})();
+function toNonNegativeFiniteNumber(value) {
+  const number = Number(value || 0);
+  return Number.isFinite(number) && number > 0 ? number : 0;
+}
+const totalTokens = toNonNegativeFiniteNumber(signals.contextTokensUsed);
+const messageCount = toNonNegativeFiniteNumber(signals.assistantMessageCount || signals.num_chat_messages);
+const model = signals.primaryModelId || (Array.isArray(signals.modelsUsed) ? signals.modelsUsed[0] : 'grok-build');
+const lastActive = signals.lastActiveAt || summary.updated_at || new Date().toISOString();
+if (totalTokens <= 0) {
+  process.exit(0);
+}
+// Write a signal that the TokenTracker sync / local API can pick up
+const trackerDir = ${JSON.stringify(trackerDir)};
+const signalDir = trackerDir;
+try { fs.mkdirSync(signalDir, { recursive: true }); } catch {}
+const signal = {
+  source: 'grok',
+  sessionId: SESSION_ID,
+  cwd: WORKSPACE_ROOT,
+  model,
+  totalTokens,
+  messageCount,
+  lastActive,
+  capturedAt: new Date().toISOString()
+};
+const signalPath = path.join(signalDir, 'grok-last-session.json');
+fs.writeFileSync(signalPath, JSON.stringify(signal, null, 2) + '\\n');
+// Also touch a file so any running serve instance can react (optional)
+try {
+  fs.writeFileSync(path.join(signalDir, 'grok-session-end.trigger'), Date.now().toString());
+} catch {}
+process.exit(0);
+`;
+}
+async function probeGrokHookState({ home = os.homedir(), trackerDir, env = process.env } = {}) {
+  const grokHooksDir = resolveGrokHooksDir(env);
+  const hookPath = path.join(grokHooksDir, GROK_HOOK_FILENAME);
+  const binDir = resolveTrackerBinDir(trackerDir);
+  const handlerPath = path.join(binDir, "grok-session-end-hook.cjs");
+  const legacyHandlerPath = path.join(resolveLegacyTrackerBinDir(trackerDir), "grok-session-end-hook.cjs");
+  const hookExists = fssync.existsSync(hookPath);
+  const handlerExists = fssync.existsSync(handlerPath) || fssync.existsSync(legacyHandlerPath);
+  let configured = false;
+  if (hookExists) {
+    try {
+      const content = fssync.readFileSync(hookPath, "utf8");
+      const json = JSON.parse(content);
+      configured = Boolean(json?.hooks?.SessionEnd?.[0]?.hooks?.[0]?.command?.includes("grok-session-end-hook"));
+    } catch {}
+  }
+  const sessionsDir = path.join(resolveGrokHome(env), "sessions");
+  const hasSessions = fssync.existsSync(sessionsDir);
+  return {
+    configured,
+    hookExists,
+    handlerExists,
+    grokHome: resolveGrokHome(env),
+    grokHooksDir,
+    hookPath,
+    handlerPath,
+    legacyHandlerPath,
+    hasGrokInstall: fssync.existsSync(path.join(resolveGrokHome(env), "bin", "grok")) || hasSessions,
+    sessionsDir
+  };
+}
+async function upsertGrokHook({ home = os.homedir(), trackerDir, env = process.env } = {}) {
+  const grokHooksDir = resolveGrokHooksDir(env);
+  const result = await ensureGrokHookFiles({ grokHooksDir, trackerDir });
+  const state = await probeGrokHookState({ home, trackerDir, env });
+  return {
+    ...state,
+    changed: true,
+    ...result
+  };
+}
+async function removeGrokHook({ home = os.homedir(), trackerDir, env = process.env } = {}) {
+  const grokHooksDir = resolveGrokHooksDir(env);
+  const hookPath = path.join(grokHooksDir, GROK_HOOK_FILENAME);
+  const binDir = resolveTrackerBinDir(trackerDir);
+  const handlerPath = path.join(binDir, "grok-session-end-hook.cjs");
+  const legacyHandlerPath = path.join(resolveLegacyTrackerBinDir(trackerDir), "grok-session-end-hook.cjs");
+  let removed = false;
+  try {
+    if (fssync.existsSync(hookPath)) {
+      fssync.unlinkSync(hookPath);
+      removed = true;
+    }
+  } catch {}
+  try {
+    if (fssync.existsSync(handlerPath)) {
+      fssync.unlinkSync(handlerPath);
+      removed = true;
+    }
+  } catch {}
+  if (legacyHandlerPath !== handlerPath) {
+    try {
+      if (fssync.existsSync(legacyHandlerPath)) {
+        fssync.unlinkSync(legacyHandlerPath);
+        removed = true;
+      }
+    } catch {}
+  }
+  return { removed, hookPath, handlerPath, legacyHandlerPath };
+}
+module.exports = {
+  resolveGrokHome,
+  resolveGrokHooksDir,
+  buildGrokSessionEndHookJson,
+  upsertGrokHook,
+  probeGrokHookState,
+  removeGrokHook,
+  GROK_HOOK_FILENAME,
+  buildGrokSessionEndHandler
+};

package/src/lib/pricing/curated-overrides.json CHANGED Viewed

@@ -18,6 +18,14 @@
     "deepseek-v4-flash":{ "input": 0.14, "output": 0.28, "cache_read": 0.0028, "cache_write": 0.14 },
     "deepseek-v4-pro":  { "input": 0.435,"output": 0.87, "cache_read": 0.003625, "cache_write": 0.435 },
     "deepseek-chat":    { "input": 0.14, "output": 0.28, "cache_read": 0.0028, "cache_write": 0.14 },
+    "grok-build":       { "input": 1.25, "output": 2.50, "cache_read": 0.20, "note": "Grok Build TUI estimate. signals.json currently exposes contextTokensUsed snapshots, so TokenTracker estimates input/output split until Grok exposes per-call telemetry." },
+    "grok-4-0709":      { "input": 3.00, "output": 15.00, "cache_read": 0.75 },
+    "grok-4":           { "input": 3.00, "output": 15.00, "cache_read": 0.75 },
+    "grok-4-latest":    { "input": 3.00, "output": 15.00, "cache_read": 0.75 },
+    "grok-4-fast":      { "input": 0.20, "output": 0.50, "cache_read": 0.05 },
+    "grok-4-fast-reasoning": { "input": 0.20, "output": 0.50, "cache_read": 0.05 },
+    "grok-4-fast-non-reasoning": { "input": 0.20, "output": 0.50, "cache_read": 0.05 },
+    "grok-4-1-fast-non-reasoning": { "input": 0.20, "output": 0.50, "cache_read": 0.05 },
     "deepseek-reasoner":{ "input": 0.14, "output": 0.28, "cache_read": 0.0028, "cache_write": 0.14 },
     "kimi-for-coding":  { "input": 0.6,  "output": 2,    "cache_read": 0.15 },
     "kimi-k2.5":        { "input": 0.6,  "output": 2,    "cache_read": 0.15 },