tokentracker-cli 1.4.7 → 1.4.10

package/src/cli.js

@@ -10,6 +10,16 @@ const { cmdWrapped } = require("./commands/wrapped");
 const { cmdSessions } = require("./commands/sessions");
 
 async function run(argv) {
+  // Best-effort Sentry init (no-op without DSN / when telemetry opted out).
+  try {
+    const { initSentry } = require("./lib/sentry");
+    const { resolveTrackerPaths } = require("./lib/tracker-paths");
+    const { trackerDir } = await resolveTrackerPaths().catch(() => ({ trackerDir: null }));
+    await initSentry({ trackerDir });
+  } catch {
+    /* never block CLI startup on telemetry */
+  }
+
   const [command, ...rest] = argv;
 
   // No args → launch dashboard

package/src/commands/sync.js

@@ -202,6 +202,18 @@ const {
   scanRootDirState,
 } = require("../lib/scan-roots");
 const { resolveRuntimeConfig, isLegacyInsforgeBaseUrl } = require("../lib/runtime-config");
+const { resolveDeviceTokenPresence } = require("../lib/cloud-device-token");
+
+function formatSyncUploadSummaryLine({ runtimeDeviceToken, uploadResult, tokenPresentOnDisk }) {
+  if (runtimeDeviceToken) {
+    return `- Uploaded: ${uploadResult.inserted} inserted, ${uploadResult.skipped} skipped`;
+  }
+  if (tokenPresentOnDisk) {
+    return "- Uploaded: skipped (handled by local server; device token is set)";
+  }
+  return "- Uploaded: skipped (no device token)";
+}
+
 const { extractTokenCount } = require("../lib/codex-rollout-parser");
 const {
   consumeUsageDelta,
@@ -3763,9 +3775,11 @@ async function cmdSync(argv, context = {}) {
           "Sync finished:",
           `- Parsed files: ${totalParsed}`,
           `- New 30-min buckets queued: ${totalBuckets}`,
-          runtime.deviceToken
-            ? `- Uploaded: ${uploadResult.inserted} inserted, ${uploadResult.skipped} skipped`
-            : "- Uploaded: skipped (no device token)",
+          formatSyncUploadSummaryLine({
+            runtimeDeviceToken: runtime.deviceToken,
+            uploadResult,
+            tokenPresentOnDisk: resolveDeviceTokenPresence({ trackerDir, config, runtime }).set,
+          }),
           runtime.deviceToken && pendingBytes > 0 && !opts.drain
             ? `- Remaining: ${formatBytes(pendingBytes)} pending (run sync again, or use --drain)`
             : null,
@@ -3900,6 +3914,7 @@ function recordCodexColdScanAudit(
 }
 
 module.exports = {
+  formatSyncUploadSummaryLine,
   cmdSync,
   acquireSyncLock,
   readQueueBatch,

package/src/lib/codex-rollout-parser.js

@@ -30,7 +30,7 @@ const {
   currentCodexModel,
   snapshotCodexModelAttributionState,
 } = require("./codex-model-attribution");
-const { readCodexServiceTier, isPriorityServiceTier } = require("./codex-service-tier");
+const { readCodexServiceTier, isPriorityServiceTier, isUltrafastServiceTier } = require("./codex-service-tier");
 const {
   createUsageRecordState,
   extractTokenUsageRecord,
@@ -731,16 +731,27 @@ async function parseCodexRolloutFile(filePath, {
         priority_long_context_cache_creation_input_tokens: 0,
         priority_long_context_output_tokens: 0,
         priority_long_context_reasoning_output_tokens: 0,
+        ultrafast_input_tokens: 0,
+        ultrafast_cached_input_tokens: 0,
+        ultrafast_cache_creation_input_tokens: 0,
+        ultrafast_output_tokens: 0,
+        ultrafast_reasoning_output_tokens: 0,
+        ultrafast_long_context_input_tokens: 0,
+        ultrafast_long_context_cached_input_tokens: 0,
+        ultrafast_long_context_cache_creation_input_tokens: 0,
+        ultrafast_long_context_output_tokens: 0,
+        ultrafast_long_context_reasoning_output_tokens: 0,
         usage_events: 0,
         rerouted_usage_events: 0,
         long_context_usage_events: 0,
         priority_usage_events: 0,
+        ultrafast_usage_events: 0,
         selected_models: new Set(),
         reroute_reasons: new Set(),
       };
       byModel.set(effectiveModel, row);
     }
-    const subsetKeys = Object.keys(row).filter((key) => /^(?:long_context_|priority_)|^(?:usage_events|rerouted_usage_events)$/.test(key));
+    const subsetKeys = Object.keys(row).filter((key) => /^(?:long_context_|priority_|ultrafast_)|^(?:usage_events|rerouted_usage_events)$/.test(key));
     const before = Object.fromEntries(subsetKeys.map((key) => [key, row[key]]));
     addInto(row, delta);
     row.usage_events += 1;
@@ -787,6 +798,22 @@ async function parseCodexRolloutFile(filePath, {
         row.priority_long_context_reasoning_output_tokens += delta.reasoning_output_tokens;
       }
     }
+    if (isUltrafastServiceTier(attribution.serviceTier)) {
+      row.ultrafast_usage_events += 1;
+      row.ultrafast_input_tokens += delta.input_tokens;
+      row.ultrafast_cached_input_tokens += delta.cached_input_tokens;
+      row.ultrafast_cache_creation_input_tokens += delta.cache_creation_input_tokens;
+      row.ultrafast_output_tokens += delta.output_tokens;
+      row.ultrafast_reasoning_output_tokens += delta.reasoning_output_tokens;
+      if (isLongContext) {
+        row.ultrafast_long_context_input_tokens += delta.input_tokens;
+        row.ultrafast_long_context_cached_input_tokens += delta.cached_input_tokens;
+        row.ultrafast_long_context_cache_creation_input_tokens +=
+          delta.cache_creation_input_tokens;
+        row.ultrafast_long_context_output_tokens += delta.output_tokens;
+        row.ultrafast_long_context_reasoning_output_tokens += delta.reasoning_output_tokens;
+      }
+    }
     return { ...delta, ...Object.fromEntries(subsetKeys.map((key) => [key, row[key] - before[key]])),
       selected_models: attribution.selectedModel ? [attribution.selectedModel] : [],
       reroute_reasons: attribution.rerouteReason ? [attribution.rerouteReason] : [],

package/src/lib/codex-service-tier.js

@@ -25,6 +25,13 @@ const CODEX_SERVICE_TIER_MARKER = '"thread_settings_applied"';
 // does not silently fall back to Standard.
 const PRIORITY_SERVICE_TIERS = new Set(["priority", "fast"]);
 
+// Ultrafast is a distinct paid speed tier (service_tier "ultrafast") for
+// gpt-6-astra and gpt-6.1-sol. It is NOT Fast: Fast uses priority_* subsets and
+// priority_multiplier (2x); Ultrafast uses ultrafast_* subsets and
+// ultrafast_multiplier (6x). Mixing them into the priority columns would
+// understate Ultrafast at 2x.
+const ULTRAFAST_SERVICE_TIERS = new Set(["ultrafast"]);
+
 function readCodexServiceTier(obj) {
   if (!obj || obj.type !== "event_msg") return null;
   const payload = obj.payload;
@@ -41,9 +48,15 @@ function isPriorityServiceTier(tier) {
   return typeof tier === "string" && PRIORITY_SERVICE_TIERS.has(tier);
 }
 
+function isUltrafastServiceTier(tier) {
+  return typeof tier === "string" && ULTRAFAST_SERVICE_TIERS.has(tier);
+}
+
 module.exports = {
   CODEX_SERVICE_TIER_MARKER,
   PRIORITY_SERVICE_TIERS,
+  ULTRAFAST_SERVICE_TIERS,
   readCodexServiceTier,
   isPriorityServiceTier,
+  isUltrafastServiceTier,
 };

package/src/lib/commandcode-limits.js

@@ -12,16 +12,20 @@
 // (resetAt is epoch milliseconds) plus a `credits` balance object; the
 // subscription payload carries `{ data: { planId, status, ... } }`.
 //
-// Auth resolution mirrors the CLI: `COMMAND_CODE_API_KEY` wins, otherwise the
-// `apiKey` field of `~/.commandcode/auth.json` (prod; written 0600 by
-// `cmd login`, never edited by hand). No key -> `{ configured: false }` so the
-// Limits panel hides the section instead of erroring.
+// Auth resolution: `COMMAND_CODE_API_KEY` wins, then a key saved from
+// TokenTracker's Limits panel (provider-api-key-store.js), then the `apiKey`
+// field of `~/.commandcode/auth.json` (prod; written 0600 by `cmd login`,
+// never edited by hand). The panel store is preferred over the CLI file
+// because saving a key there is an explicit user action, while the CLI file
+// can be a stale session. No key -> `{ configured: false }` so the Limits
+// panel hides the section instead of erroring.
 //
 // The API exposes 5h + weekly rolling caps; extra pay-as-you-go credits
 // bypass the caps server-side, so the reported used/cap needs no adjustment.
 
 const fs = require("node:fs");
 const path = require("node:path");
+const { readStoredApiKey } = require("./provider-api-key-store");
 
 const COMMANDCODE_API_BASE_URL = "https://api.commandcode.ai";
 const COMMANDCODE_API_KEY_ENV = "COMMAND_CODE_API_KEY";
@@ -57,25 +61,33 @@ function resolveCommandcodeAuthPath({ home, env = process.env } = {}) {
   return path.join(dir, COMMANDCODE_AUTH_DIRNAME, COMMANDCODE_AUTH_FILENAME);
 }
 
-function readCommandcodeApiKey({ home, env = process.env } = {}) {
+function readCommandcodeCredential({ home, trackerDir, env = process.env } = {}) {
   const fromEnv =
     env && typeof env === "object" ? env[COMMANDCODE_API_KEY_ENV] : null;
-  if (isNonEmptyString(fromEnv)) return fromEnv.trim();
+  if (isNonEmptyString(fromEnv)) return { apiKey: fromEnv.trim(), source: "env" };
+  const stored = readStoredApiKey({ provider: "command-code", trackerDir, home });
+  if (stored) return { apiKey: stored, source: "stored" };
   const authPath = resolveCommandcodeAuthPath({ home, env });
-  if (!authPath) return null;
+  if (!authPath) return { apiKey: null, source: "none" };
   let raw;
   try {
     raw = fs.readFileSync(authPath, "utf8");
   } catch {
-    return null;
+    return { apiKey: null, source: "none" };
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch {
-    return null;
+    return { apiKey: null, source: "none" };
   }
-  return isNonEmptyString(parsed?.apiKey) ? parsed.apiKey.trim() : null;
+  return isNonEmptyString(parsed?.apiKey)
+    ? { apiKey: parsed.apiKey.trim(), source: "cli" }
+    : { apiKey: null, source: "none" };
+}
+
+function readCommandcodeApiKey(opts = {}) {
+  return readCommandcodeCredential(opts).apiKey;
 }
 
 function normalizeResetAt(value) {
@@ -246,11 +258,13 @@ function withOrgParam(route, orgId) {
 // usage-limits.js converts both into the panel row.
 async function fetchCommandcodeLimits({
   home,
+  trackerDir,
   env = process.env,
   fetchImpl = fetch,
   baseUrl = COMMANDCODE_API_BASE_URL,
 } = {}) {
-  const apiKey = readCommandcodeApiKey({ home, env });
+  const credential = readCommandcodeCredential({ home, trackerDir, env });
+  const apiKey = credential.apiKey;
   if (!apiKey) return { configured: false };
 
   const origin = resolveCommandcodeOrigin(baseUrl);
@@ -289,6 +303,7 @@ async function fetchCommandcodeLimits({
   return {
     configured: true,
     error: null,
+    credential_source: credential.source,
     plan_label: deriveCommandcodePlanLabel(planId),
     subscription_status: isNonEmptyString(subscription?.status)
       ? subscription.status.trim()
@@ -308,6 +323,7 @@ module.exports = {
   resolveCommandcodeHome,
   resolveCommandcodeAuthPath,
   readCommandcodeApiKey,
+  readCommandcodeCredential,
   deriveCommandcodePlanLabel,
   normalizeResetAt,
   normalizeCommandcodeWindow,

package/src/lib/grok-limits.js

@@ -536,6 +536,7 @@ const GROK_PRODUCT_LABELS = new Map([
   ["GrokBot", "Grok Bot"],
   ["GrokChat", "Chat"],
   ["GrokImagine", "Imagine"],
+  ["GrokVoice", "Voice"],
   ["Cursor", "Cursor"],
 ]);
 

package/src/lib/local-api.js

@@ -19,6 +19,7 @@ const { functionUrlFor, fetchFunctionResponse } = require("./function-url");
 const { createCloudDeviceTokenStore } = require("./cloud-device-token");
 const { parseBearerToken } = require("./bearer-token");
 const { writeJsonAtomicSync } = require("./atomic-json");
+const { createLocalUsageTransfer, MAX_BYTES: LOCAL_USAGE_MAX_BYTES } = require("./local-usage-transfer");
 
 const SYNC_TIMEOUT_MS = 120_000;
 // A failed account-view request should not stall every dashboard refresh
@@ -401,17 +402,6 @@ function getRequestedUsageScope(url) {
   return normalizeUsageScope(url.searchParams.get("scope"));
 }
 
-async function scopedQueueRows(queuePath, url) {
-  const scope = getRequestedUsageScope(url);
-  const allRows = await readQueueData(queuePath);
-  return {
-    scope,
-    allRows,
-    rows: filterRowsByUsageScope(allRows, scope),
-    excludedSources: listExcludedSources(allRows, scope),
-  };
-}
-
 // ── Local achievements ───────────────────────────────────────────────────────
 // Local-only badges (the cloud nine live in scripts/ops/user-badges.sql).
 // Thresholds are ordered bronze → silver → gold → diamond. This module is the
@@ -1007,6 +997,17 @@ function buildProxyHeaders(headers) {
 
 function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir: isolatedTrackerDataDir = null, syncContext = null }) {
   const qp = queuePath || resolveQueuePath();
+  const localUsage = createLocalUsageTransfer({ queuePath: qp, normalizeRow: normalizeQueueRow,
+    identity: () => ({ id: getOrCreateMachineId(qp), name: getSystemDeviceName(), platform: process.platform }) });
+  async function scopedQueueRows(queuePath, url) {
+    const scope = getRequestedUsageScope(url);
+    const ownRows = await readQueueData(queuePath);
+    const selected = url.searchParams.get("device_id") || "";
+    // Only offline IDs select a snapshot; other IDs retain the local fallback.
+    const device = selected.startsWith("local:") ? selected : "";
+    const allRows = url.pathname.startsWith("/functions/tokentracker-usage-") ? await localUsage.view(ownRows, device) : ownRows;
+    return { scope, allRows, rows: filterRowsByUsageScope(allRows, scope), excludedSources: listExcludedSources(allRows, scope) };
+  }
   const normalizedServerVersion = typeof serverVersion === "string" ? serverVersion.trim() : "";
 
   // Server-side cookie relay: captures auth cookies from InsForge cloud responses
@@ -1639,6 +1640,32 @@ function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir
 
   return async function handleLocalApi(req, res, url) {
     const p = url.pathname;
+    if (p === "/api/local-usage") {
+      if (!isAuthorizedLocalMutation(req)) { json(res, { code: "unauthorized" }, 401); return true; }
+      try {
+        if (req.method === "GET") {
+          const from = url.searchParams.get("from") || "";
+          const to = url.searchParams.get("to") || "";
+          const context = getTimeZoneContext(url);
+          const inRange = (row) => { const day = rowDayKey(row, context); return day && (!from || day >= from) && (!to || day <= to); };
+          json(res, await localUsage.devices(await readQueueData(qp), inRange));
+        } else if (req.method === "POST") {
+          const body = JSON.parse((await readBodyLimited(req, LOCAL_USAGE_MAX_BYTES + 4096)).toString("utf8"));
+          if (body.action === "export") json(res, { snapshot: await localUsage.exportSnapshot() });
+          else if (body.action === "preview") json(res, await localUsage.preview(body.snapshot));
+          else if (body.action === "import") json(res, await localUsage.importSnapshot(body.snapshot, body.token));
+          else if (body.action === "remove") { await localUsage.remove(body.machine_id); json(res, { ok: true }); }
+          else json(res, { code: "invalid_snapshot" }, 400);
+        } else json(res, { code: "method_not_allowed" }, 405);
+      } catch (error) {
+        json(res, { code: error.code && error.status ? error.code : "transfer_failed" }, error.status || 400);
+      }
+      return true;
+    }
+    if (p.startsWith("/functions/tokentracker-usage-") && url.searchParams.get("device_id")?.startsWith("local:")) {
+      try { await localUsage.view([], url.searchParams.get("device_id")); }
+      catch (error) { json(res, { code: error.code || "transfer_failed" }, error.status || 500); return true; }
+    }
     // Session recovery and the one-time native callback marker belong to local
     // clients. Reject foreign requests before consuming either, including preflights.
     const nativeMarkerRead = p === "/api/auth-bridge/verifier" && String(req.method).toUpperCase() === "GET";
@@ -2714,6 +2741,11 @@ function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir
       const from = url.searchParams.get("from") || "";
       const to = url.searchParams.get("to") || "";
       const requestedSource = (url.searchParams.get("source") || "claude").trim().toLowerCase();
+      const selected = url.searchParams.get("device_id") || "";
+      if (selected.startsWith("local:") ? selected !== `local:${getOrCreateMachineId(qp)}` : !selected && await localUsage.hasImports()) {
+        json(res, { from, to, ...unsupportedCategoryPayload(requestedSource), reason: "local_history_only" });
+        return true;
+      }
       if (requestedSource === "claude") {
         try {
           const result = await computeClaudeCategoryBreakdown({ from, to, projectDir: process.cwd() });
@@ -2978,6 +3010,84 @@ function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir
       return true;
     }
 
+    // --- provider API keys saved from the Limits panel ---
+    // The key lives in a 0600 file next to the queue, never in the launch
+    // environment: a global `launchctl setenv` reaches every launchd app on
+    // macOS, which is exactly the cross-app leak in #837. GET only reports
+    // whether a key exists and where it came from; it never echoes the secret.
+    if (p === "/functions/tokentracker-provider-key") {
+      const {
+        envNameForProvider,
+        isProviderId,
+        normalizeApiKey,
+        readStoredApiKey,
+        writeStoredApiKey,
+      } = require("./provider-api-key-store");
+      const method = String(req.method || "GET").toUpperCase();
+      if (method === "GET") {
+        const provider = String(url.searchParams.get("provider") || "").trim();
+        if (!isProviderId(provider)) {
+          json(res, { error: "Unknown provider" }, 400);
+          return true;
+        }
+        const envName = envNameForProvider(provider);
+        const envValue = envName ? process.env[envName] : "";
+        const hasEnvKey = typeof envValue === "string" && Boolean(envValue.trim());
+        const hasStoredKey = Boolean(readStoredApiKey({ provider, trackerDir: trackerDataDir }));
+        json(res, {
+          provider,
+          configured: hasEnvKey || hasStoredKey,
+          source: hasEnvKey ? "env" : hasStoredKey ? "stored" : "none",
+        });
+        return true;
+      }
+      if (method === "POST" || method === "PUT") {
+        if (!isAuthorizedLocalMutation(req)) {
+          json(res, { ok: false, error: "Unauthorized" }, 401);
+          return true;
+        }
+        let body;
+        try {
+          body = await readJsonBody(req);
+        } catch {
+          json(res, { ok: false, error: "Invalid JSON body" }, 400);
+          return true;
+        }
+        const provider = typeof body?.provider === "string" ? body.provider.trim() : "";
+        if (!isProviderId(provider)) {
+          json(res, { ok: false, error: "Unknown provider" }, 400);
+          return true;
+        }
+        if (!normalizeApiKey(body?.apiKey)) {
+          json(res, { ok: false, error: "Invalid API key" }, 400);
+          return true;
+        }
+        try {
+          await writeStoredApiKey({ provider, trackerDir: trackerDataDir, apiKey: body.apiKey });
+        } catch {
+          json(res, { ok: false, error: "Could not save the API key" }, 500);
+          return true;
+        }
+        // The in-memory aggregate would otherwise keep serving the previous
+        // credential's row (or "not configured") until its TTL expires.
+        try {
+          const { resetUsageLimitsCache, resolveOpencodeGoLimitsCachePath } = require("./usage-limits");
+          resetUsageLimitsCache({ invalidateInFlight: true });
+          if (provider === "opencode-go") {
+            // The disk snapshot is the stale-bars fallback; it must not
+            // outlive the key that produced it.
+            await fs.promises.unlink(resolveOpencodeGoLimitsCachePath({ trackerDir: trackerDataDir }));
+          }
+        } catch {
+          /* cache invalidation is best effort; the stored key is authoritative */
+        }
+        json(res, { ok: true, configured: true, source: "stored" });
+        return true;
+      }
+      json(res, { error: "Method Not Allowed" }, 405);
+      return true;
+    }
+
     // --- cloud-sync preference mirror ---
     // The dashboard's Settings → Account → Cloud sync toggle (a WebView
     // localStorage flag) is mirrored here so the auth-unaware native popover can
@@ -3547,6 +3657,7 @@ function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir
         }
         const data = await getUsageLimits({
           home: os.homedir(),
+          trackerDir: trackerDataDir,
           env: process.env,
           platform: process.platform,
           // Punches through the Claude disk fresh-cache (but not the 429