@vibescore/tracker 0.1.1 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibescore/tracker",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Codex CLI token usage tracker (macOS-first, notify-driven).",
   "license": "MIT",
   "publishConfig": {

package/src/cli.js

@@ -48,6 +48,7 @@ function printHelp() {
       '',
       'Notes:',
       '  - init installs a Codex notify hook and issues a device token (default: browser sign in/up).',
+      '  - optional: pass --link-code <code> to skip browser login when provided by Dashboard.',
       '  - when ~/.code/config.toml exists, init also installs an Every Code notify hook.',
       '  - optional: set VIBESCORE_DASHBOARD_URL (or --dashboard-url) to use a hosted landing page.',
       '  - sync parses ~/.codex/sessions/**/rollout-*.jsonl and ~/.code/sessions/**/rollout-*.jsonl (Every Code), then uploads token_count deltas.',

package/src/commands/init.js

@@ -3,6 +3,7 @@ const path = require('node:path');
 const fs = require('node:fs/promises');
 const fssync = require('node:fs');
 const cp = require('node:child_process');
+const crypto = require('node:crypto');
 
 const { ensureDir, writeFileAtomic, readJson, writeJson, chmod600IfPossible } = require('../lib/fs');
 const { prompt, promptHidden } = require('../lib/prompt');
@@ -14,7 +15,11 @@ const {
 } = require('../lib/codex-config');
 const { upsertClaudeHook, buildClaudeHookCommand } = require('../lib/claude-config');
 const { beginBrowserAuth } = require('../lib/browser-auth');
-const { issueDeviceTokenWithPassword, issueDeviceTokenWithAccessToken } = require('../lib/insforge');
+const {
+  issueDeviceTokenWithPassword,
+  issueDeviceTokenWithAccessToken,
+  issueDeviceTokenWithLinkCode
+} = require('../lib/insforge');
 
 async function cmdInit(argv) {
   const opts = parseArgs(argv);
@@ -29,6 +34,7 @@ async function cmdInit(argv) {
 
   const configPath = path.join(trackerDir, 'config.json');
   const notifyOriginalPath = path.join(trackerDir, 'codex_notify_original.json');
+  const linkCodeStatePath = path.join(trackerDir, 'link_code_state.json');
 
   const baseUrl = opts.baseUrl || process.env.VIBESCORE_INSFORGE_BASE_URL || 'https://5tmappuk.us-east.insforge.app';
   let dashboardUrl = opts.dashboardUrl || process.env.VIBESCORE_DASHBOARD_URL || null;
@@ -44,7 +50,36 @@ async function cmdInit(argv) {
 
   await installLocalTrackerApp({ appDir });
 
-  if (!deviceToken && !opts.noAuth) {
+  if (!deviceToken && opts.linkCode) {
+    const deviceName = opts.deviceName || os.hostname();
+    const platform = normalizePlatform(process.platform);
+    const linkCode = String(opts.linkCode);
+    const linkCodeHash = crypto.createHash('sha256').update(linkCode).digest('hex');
+    const existingLinkState = await readJson(linkCodeStatePath);
+    let requestId =
+      existingLinkState?.linkCodeHash === linkCodeHash && existingLinkState?.requestId
+        ? existingLinkState.requestId
+        : null;
+    if (!requestId) {
+      requestId = crypto.randomUUID();
+      await writeJson(linkCodeStatePath, {
+        linkCodeHash,
+        requestId,
+        createdAt: new Date().toISOString()
+      });
+      await chmod600IfPossible(linkCodeStatePath);
+    }
+    const issued = await issueDeviceTokenWithLinkCode({
+      baseUrl,
+      linkCode,
+      requestId,
+      deviceName,
+      platform
+    });
+    deviceToken = issued.token;
+    deviceId = issued.deviceId;
+    await fs.rm(linkCodeStatePath, { force: true });
+  } else if (!deviceToken && !opts.noAuth) {
     const deviceName = opts.deviceName || os.hostname();
 
     if (opts.email || opts.password) {
@@ -171,6 +206,7 @@ function parseArgs(argv) {
     email: null,
     password: null,
     deviceName: null,
+    linkCode: null,
     noAuth: false,
     noOpen: false
   };
@@ -182,6 +218,7 @@ function parseArgs(argv) {
     else if (a === '--email') out.email = argv[++i] || null;
     else if (a === '--password') out.password = argv[++i] || null;
     else if (a === '--device-name') out.deviceName = argv[++i] || null;
+    else if (a === '--link-code') out.linkCode = argv[++i] || null;
     else if (a === '--no-auth') out.noAuth = true;
     else if (a === '--no-open') out.noOpen = true;
     else throw new Error(`Unknown option: ${a}`);
@@ -194,6 +231,13 @@ function maskSecret(s) {
   return `${s.slice(0, 4)}…${s.slice(-4)}`;
 }
 
+function normalizePlatform(value) {
+  if (value === 'darwin') return 'macos';
+  if (value === 'win32') return 'windows';
+  if (value === 'linux') return 'linux';
+  return 'unknown';
+}
+
 function buildNotifyHandler({ trackerDir, packageName }) {
   // Keep this file dependency-free: Node built-ins only.
   // It must never block Codex; it spawns sync in the background and exits 0.

package/src/lib/insforge.js

@@ -1,4 +1,4 @@
-const { issueDeviceToken, signInWithPassword } = require('./vibescore-api');
+const { exchangeLinkCode, issueDeviceToken, signInWithPassword } = require('./vibescore-api');
 
 async function issueDeviceTokenWithPassword({ baseUrl, email, password, deviceName }) {
   const accessToken = await signInWithPassword({ baseUrl, email, password });
@@ -11,7 +11,13 @@ async function issueDeviceTokenWithAccessToken({ baseUrl, accessToken, deviceNam
   return issued;
 }
 
+async function issueDeviceTokenWithLinkCode({ baseUrl, linkCode, requestId, deviceName, platform }) {
+  const issued = await exchangeLinkCode({ baseUrl, linkCode, requestId, deviceName, platform });
+  return { token: issued.token, deviceId: issued.deviceId };
+}
+
 module.exports = {
   issueDeviceTokenWithPassword,
-  issueDeviceTokenWithAccessToken
+  issueDeviceTokenWithAccessToken,
+  issueDeviceTokenWithLinkCode
 };

package/src/lib/rollout.js

@@ -470,44 +470,207 @@ async function enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets })
   if (touchedGroups.size === 0) return 0;
 
   const groupQueued = hourlyState.groupQueued && typeof hourlyState.groupQueued === 'object' ? hourlyState.groupQueued : {};
+  let codexTouched = false;
   const legacyGroups = new Set();
   for (const groupKey of touchedGroups) {
     if (Object.prototype.hasOwnProperty.call(groupQueued, groupKey)) {
       legacyGroups.add(groupKey);
     }
+    if (!codexTouched && groupKey.startsWith(`${DEFAULT_SOURCE}${BUCKET_SEPARATOR}`)) {
+      codexTouched = true;
+    }
   }
 
-  const toAppend = [];
-  for (const bucketStart of touchedBuckets) {
-    const parsed = parseBucketKey(bucketStart);
+  const groupedBuckets = new Map();
+  for (const [key, bucket] of Object.entries(hourlyState.buckets || {})) {
+    if (!bucket || !bucket.totals) continue;
+    const parsed = parseBucketKey(key);
     const hourStart = parsed.hourStart;
     if (!hourStart) continue;
     const groupKey = groupBucketKey(parsed.source, hourStart);
-    if (legacyGroups.has(groupKey)) continue;
+    if (!touchedGroups.has(groupKey) || legacyGroups.has(groupKey)) continue;
+
+    const source = normalizeSourceInput(parsed.source) || DEFAULT_SOURCE;
+    const model = normalizeModelInput(parsed.model) || DEFAULT_MODEL;
+    let group = groupedBuckets.get(groupKey);
+    if (!group) {
+      group = { source, hourStart, buckets: new Map() };
+      groupedBuckets.set(groupKey, group);
+    }
 
-    const normalizedKey = bucketKey(parsed.source, parsed.model, hourStart);
-    const bucket = hourlyState.buckets ? hourlyState.buckets[normalizedKey] : null;
-    if (!bucket || !bucket.totals) continue;
     if (bucket.queuedKey != null && typeof bucket.queuedKey !== 'string') {
       bucket.queuedKey = null;
     }
-    const key = totalsKey(bucket.totals);
-    if (bucket.queuedKey === key) continue;
-    const source = normalizeSourceInput(parsed.source) || DEFAULT_SOURCE;
-    const model = normalizeModelInput(parsed.model) || DEFAULT_MODEL;
+    group.buckets.set(model, bucket);
+  }
+
+  if (codexTouched) {
+    const recomputeGroups = new Set();
+    for (const [key, bucket] of Object.entries(hourlyState.buckets || {})) {
+      if (!bucket || !bucket.totals) continue;
+      const parsed = parseBucketKey(key);
+      const hourStart = parsed.hourStart;
+      if (!hourStart) continue;
+      const source = normalizeSourceInput(parsed.source) || DEFAULT_SOURCE;
+      if (source !== 'every-code') continue;
+      const groupKey = groupBucketKey(source, hourStart);
+      if (legacyGroups.has(groupKey) || groupedBuckets.has(groupKey)) continue;
+      const model = normalizeModelInput(parsed.model) || DEFAULT_MODEL;
+      if (model !== DEFAULT_MODEL) continue;
+      recomputeGroups.add(groupKey);
+    }
+
+    if (recomputeGroups.size > 0) {
+      for (const [key, bucket] of Object.entries(hourlyState.buckets || {})) {
+        if (!bucket || !bucket.totals) continue;
+        const parsed = parseBucketKey(key);
+        const hourStart = parsed.hourStart;
+        if (!hourStart) continue;
+        const source = normalizeSourceInput(parsed.source) || DEFAULT_SOURCE;
+        const groupKey = groupBucketKey(source, hourStart);
+        if (!recomputeGroups.has(groupKey)) continue;
+        let group = groupedBuckets.get(groupKey);
+        if (!group) {
+          group = { source, hourStart, buckets: new Map() };
+          groupedBuckets.set(groupKey, group);
+        }
+        if (bucket.queuedKey != null && typeof bucket.queuedKey !== 'string') {
+          bucket.queuedKey = null;
+        }
+        const model = normalizeModelInput(parsed.model) || DEFAULT_MODEL;
+        group.buckets.set(model, bucket);
+      }
+    }
+  }
+
+  const codexDominants = collectCodexDominantModels(hourlyState);
+
+  const toAppend = [];
+  for (const group of groupedBuckets.values()) {
+    const unknownBucket = group.buckets.get(DEFAULT_MODEL) || null;
+    const dominantModel = pickDominantModel(group.buckets);
+    let alignedModel = null;
+    if (unknownBucket?.alignedModel) {
+      const normalized = normalizeModelInput(unknownBucket.alignedModel);
+      alignedModel = normalized && normalized !== DEFAULT_MODEL ? normalized : null;
+    }
+    const zeroTotals = initTotals();
+    const zeroKey = totalsKey(zeroTotals);
+
+    if (dominantModel) {
+      if (alignedModel && !group.buckets.has(alignedModel)) {
+        toAppend.push(
+          JSON.stringify({
+            source: group.source,
+            model: alignedModel,
+            hour_start: group.hourStart,
+            input_tokens: zeroTotals.input_tokens,
+            cached_input_tokens: zeroTotals.cached_input_tokens,
+            output_tokens: zeroTotals.output_tokens,
+            reasoning_output_tokens: zeroTotals.reasoning_output_tokens,
+            total_tokens: zeroTotals.total_tokens
+          })
+        );
+      }
+      if (unknownBucket && !alignedModel && unknownBucket.queuedKey && unknownBucket.queuedKey !== zeroKey) {
+        if (unknownBucket.retractedUnknownKey !== zeroKey) {
+          toAppend.push(
+            JSON.stringify({
+              source: group.source,
+              model: DEFAULT_MODEL,
+              hour_start: group.hourStart,
+              input_tokens: zeroTotals.input_tokens,
+              cached_input_tokens: zeroTotals.cached_input_tokens,
+              output_tokens: zeroTotals.output_tokens,
+              reasoning_output_tokens: zeroTotals.reasoning_output_tokens,
+              total_tokens: zeroTotals.total_tokens
+            })
+          );
+          unknownBucket.retractedUnknownKey = zeroKey;
+        }
+      }
+      if (unknownBucket) unknownBucket.alignedModel = null;
+      for (const [model, bucket] of group.buckets.entries()) {
+        if (model === DEFAULT_MODEL) continue;
+        let totals = bucket.totals;
+        if (model === dominantModel && unknownBucket?.totals) {
+          totals = cloneTotals(bucket.totals);
+          addTotals(totals, unknownBucket.totals);
+        }
+        const key = totalsKey(totals);
+        if (bucket.queuedKey === key) continue;
+        toAppend.push(
+          JSON.stringify({
+            source: group.source,
+            model,
+            hour_start: group.hourStart,
+            input_tokens: totals.input_tokens,
+            cached_input_tokens: totals.cached_input_tokens,
+            output_tokens: totals.output_tokens,
+            reasoning_output_tokens: totals.reasoning_output_tokens,
+            total_tokens: totals.total_tokens
+          })
+        );
+        bucket.queuedKey = key;
+      }
+      continue;
+    }
+
+    if (!unknownBucket?.totals) continue;
+    let outputModel = DEFAULT_MODEL;
+    if (group.source === 'every-code') {
+      const aligned = findNearestCodexModel(group.hourStart, codexDominants);
+      if (aligned) outputModel = aligned;
+    }
+    const nextAligned = outputModel !== DEFAULT_MODEL ? outputModel : null;
+    if (alignedModel && alignedModel !== nextAligned) {
+      toAppend.push(
+        JSON.stringify({
+          source: group.source,
+          model: alignedModel,
+          hour_start: group.hourStart,
+          input_tokens: zeroTotals.input_tokens,
+          cached_input_tokens: zeroTotals.cached_input_tokens,
+          output_tokens: zeroTotals.output_tokens,
+          reasoning_output_tokens: zeroTotals.reasoning_output_tokens,
+          total_tokens: zeroTotals.total_tokens
+        })
+      );
+    }
+    if (!alignedModel && nextAligned && unknownBucket.queuedKey && unknownBucket.queuedKey !== zeroKey) {
+      if (unknownBucket.retractedUnknownKey !== zeroKey) {
+        toAppend.push(
+          JSON.stringify({
+            source: group.source,
+            model: DEFAULT_MODEL,
+            hour_start: group.hourStart,
+            input_tokens: zeroTotals.input_tokens,
+            cached_input_tokens: zeroTotals.cached_input_tokens,
+            output_tokens: zeroTotals.output_tokens,
+            reasoning_output_tokens: zeroTotals.reasoning_output_tokens,
+            total_tokens: zeroTotals.total_tokens
+          })
+        );
+        unknownBucket.retractedUnknownKey = zeroKey;
+      }
+    }
+    if (unknownBucket) unknownBucket.alignedModel = nextAligned;
+    const key = totalsKey(unknownBucket.totals);
+    const outputKey = outputModel === DEFAULT_MODEL ? key : `${key}|${outputModel}`;
+    if (unknownBucket.queuedKey === outputKey) continue;
     toAppend.push(
       JSON.stringify({
-        source,
-        model,
-        hour_start: hourStart,
-        input_tokens: bucket.totals.input_tokens,
-        cached_input_tokens: bucket.totals.cached_input_tokens,
-        output_tokens: bucket.totals.output_tokens,
-        reasoning_output_tokens: bucket.totals.reasoning_output_tokens,
-        total_tokens: bucket.totals.total_tokens
+        source: group.source,
+        model: outputModel,
+        hour_start: group.hourStart,
+        input_tokens: unknownBucket.totals.input_tokens,
+        cached_input_tokens: unknownBucket.totals.cached_input_tokens,
+        output_tokens: unknownBucket.totals.output_tokens,
+        reasoning_output_tokens: unknownBucket.totals.reasoning_output_tokens,
+        total_tokens: unknownBucket.totals.total_tokens
       })
     );
-    bucket.queuedKey = key;
+    unknownBucket.queuedKey = outputKey;
   }
 
   if (legacyGroups.size > 0) {
@@ -564,6 +727,91 @@ async function enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets })
   return toAppend.length;
 }
 
+function pickDominantModel(buckets) {
+  let dominantModel = null;
+  let dominantTotal = -1;
+  for (const [model, bucket] of buckets.entries()) {
+    if (model === DEFAULT_MODEL) continue;
+    const total = Number(bucket?.totals?.total_tokens || 0);
+    if (
+      dominantModel == null ||
+      total > dominantTotal ||
+      (total === dominantTotal && model < dominantModel)
+    ) {
+      dominantModel = model;
+      dominantTotal = total;
+    }
+  }
+  return dominantModel;
+}
+
+function cloneTotals(totals) {
+  const cloned = initTotals();
+  addTotals(cloned, totals || {});
+  return cloned;
+}
+
+function collectCodexDominantModels(hourlyState) {
+  const grouped = new Map();
+  for (const [key, bucket] of Object.entries(hourlyState.buckets || {})) {
+    if (!bucket || !bucket.totals) continue;
+    const parsed = parseBucketKey(key);
+    const hourStart = parsed.hourStart;
+    if (!hourStart) continue;
+    const source = normalizeSourceInput(parsed.source) || DEFAULT_SOURCE;
+    if (source !== DEFAULT_SOURCE) continue;
+    const model = normalizeModelInput(parsed.model) || DEFAULT_MODEL;
+    if (model === DEFAULT_MODEL) continue;
+
+    let models = grouped.get(hourStart);
+    if (!models) {
+      models = new Map();
+      grouped.set(hourStart, models);
+    }
+    const total = Number(bucket.totals.total_tokens || 0);
+    models.set(model, (models.get(model) || 0) + total);
+  }
+
+  const dominants = [];
+  for (const [hourStart, models] of grouped.entries()) {
+    let dominantModel = null;
+    let dominantTotal = -1;
+    for (const [model, total] of models.entries()) {
+      if (
+        dominantModel == null ||
+        total > dominantTotal ||
+        (total === dominantTotal && model < dominantModel)
+      ) {
+        dominantModel = model;
+        dominantTotal = total;
+      }
+    }
+    if (dominantModel) {
+      dominants.push({ hourStart, model: dominantModel });
+    }
+  }
+
+  return dominants;
+}
+
+function findNearestCodexModel(hourStart, dominants) {
+  if (!hourStart || !dominants || dominants.length === 0) return null;
+  const target = Date.parse(hourStart);
+  if (!Number.isFinite(target)) return null;
+
+  let best = null;
+  for (const entry of dominants) {
+    const candidate = Date.parse(entry.hourStart);
+    if (!Number.isFinite(candidate)) continue;
+    const diff = Math.abs(candidate - target);
+    if (!best || diff < best.diff || (diff === best.diff && candidate < best.time)) {
+      best = { diff, time: candidate, model: entry.model };
+    }
+  }
+
+  return best ? best.model : null;
+}
+
 function normalizeHourlyState(raw) {
   const state = raw && typeof raw === 'object' ? raw : {};
   const version = Number(state.version || 1);

package/src/lib/vibescore-api.js

@@ -35,6 +35,33 @@ async function issueDeviceToken({ baseUrl, accessToken, deviceName, platform = '
   return { token, deviceId };
 }
 
+async function exchangeLinkCode({ baseUrl, linkCode, requestId, deviceName, platform = 'macos' }) {
+  const data = await invokeFunction({
+    baseUrl,
+    accessToken: null,
+    slug: 'vibescore-link-code-exchange',
+    method: 'POST',
+    body: {
+      link_code: linkCode,
+      request_id: requestId,
+      device_name: deviceName,
+      platform
+    },
+    errorPrefix: 'Link code exchange failed'
+  });
+
+  const token = data?.token;
+  const deviceId = data?.device_id;
+  if (typeof token !== 'string' || token.length === 0) {
+    throw new Error('Link code exchange failed: missing token');
+  }
+  if (typeof deviceId !== 'string' || deviceId.length === 0) {
+    throw new Error('Link code exchange failed: missing device_id');
+  }
+
+  return { token, deviceId, userId: data?.user_id || null };
+}
+
 async function ingestHourly({ baseUrl, deviceToken, hourly }) {
   const data = await invokeFunctionWithRetry({
     baseUrl,
@@ -72,6 +99,7 @@ async function syncHeartbeat({ baseUrl, deviceToken }) {
 module.exports = {
   signInWithPassword,
   issueDeviceToken,
+  exchangeLinkCode,
   ingestHourly,
   syncHeartbeat
 };