@usagefleet/cli 1.2.150 → 1.2.152

package/dist/claude-account.js

@@ -32,3 +32,28 @@ export function detectClaudeAccount(path = claudeStatePath()) {
         return null;
     }
 }
+const OAUTH_PROFILE_URL = 'https://api.anthropic.com/api/oauth/profile';
+/** The accountUuid Anthropic says owns this OAuth token, or null when it cannot
+ *  say. Null fails open to the file's identity: the endpoint is undocumented, and
+ *  losing it must not stop every collector from reporting limits. */
+export async function tokenOwner(token) {
+    try {
+        const res = await fetch(OAUTH_PROFILE_URL, {
+            headers: {
+                'anthropic-beta': 'oauth-2025-04-20',
+                authorization: `Bearer ${token}`,
+                'user-agent': 'claude-code/2.1.5 (usagefleet)',
+            },
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!res.ok) {
+            return null;
+        }
+        const body = (await res.json());
+        const uuid = body?.account?.uuid;
+        return typeof uuid === 'string' && uuid !== '' ? uuid.slice(0, 100) : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/collector.js

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { hostname } from 'node:os';
 import { sep } from 'node:path';
-import { detectClaudeAccount } from './claude-account.js';
+import { detectClaudeAccount, tokenOwner } from './claude-account.js';
 import { detectClaudeCreds, macKeychainDenied } from './claude-creds.js';
 import { fetchLimits } from './claude-limits.js';
 import { ENDPOINT } from './config.js';
@@ -75,7 +75,7 @@ export async function runOnce(cfg, log = () => {
         if (!tail || tail.consumedBytes === 0) {
             continue;
         }
-        if (tail.records.length === 0) {
+        if (tail.segments.length === 0) {
             // Consumed only non-usage lines — safe to advance immediately.
             state.files[fp] = tail.nextState;
             advanced = true;
@@ -83,8 +83,8 @@ export async function runOnce(cfg, log = () => {
         }
         // sendChunk absorbs "invalid" by bisecting, so only auth/plan/transient escape.
         let outcome = 'ok';
-        for (let i = 0; i < tail.records.length; i += step) {
-            outcome = await sendChunk(tail.records.slice(i, i + step), cfg, result, log);
+        for (const chunk of chunks(tail.segments, step)) {
+            outcome = await sendChunk(chunk.records, chunk.accountExtId, cfg, result, log);
             if (outcome !== 'ok') {
                 break;
             }
@@ -151,9 +151,9 @@ export async function runOnce(cfg, log = () => {
  * anything that survives that many splits is not record-shaped.
  */
 const MAX_DROPPED_PER_CHUNK = 2;
-async function sendChunk(records, cfg, result, log, dropCeiling = result.dropped + MAX_DROPPED_PER_CHUNK) {
+async function sendChunk(records, accountExtId, cfg, result, log, dropCeiling = result.dropped + MAX_DROPPED_PER_CHUNK) {
     const res = await uploadBatch({
-        accountExtId: detectClaudeAccount()?.extId,
+        accountExtId: accountExtId ?? detectClaudeAccount()?.extId,
         collectorVersion: RELEASE_VERSION,
         hostname: hostname(),
         os: detectOs(),
@@ -185,8 +185,18 @@ async function sendChunk(records, cfg, result, log, dropCeiling = result.dropped
         return 'ok';
     }
     const mid = Math.ceil(records.length / 2);
-    const head = await sendChunk(records.slice(0, mid), cfg, result, log, dropCeiling);
-    return head === 'ok' ? sendChunk(records.slice(mid), cfg, result, log, dropCeiling) : head;
+    const head = await sendChunk(records.slice(0, mid), accountExtId, cfg, result, log, dropCeiling);
+    return head === 'ok' ? sendChunk(records.slice(mid), accountExtId, cfg, result, log, dropCeiling) : head;
+}
+/** Upload-sized slices of each segment; a chunk never spans two accounts. */
+function chunks(segments, step) {
+    const out = [];
+    for (const { accountExtId, records } of segments) {
+        for (let i = 0; i < records.length; i += step) {
+            out.push({ accountExtId, records: records.slice(i, i + step) });
+        }
+    }
+    return out;
 }
 /**
  * Drop offsets for logs that no longer exist on disk, so a long-lived install
@@ -251,6 +261,13 @@ export async function reportLimitsOnce(cfg, log = () => {
     // two subscriptions gets two independent budgets instead of one row both
     // machines overwrite. Subscription logins only — an API key has no account.
     const account = report.source === 'sub' ? detectClaudeAccount() : null;
+    // Mid-/login the token and ~/.claude.json name two accounts; see docs/collector.md.
+    // ponytail: one profile call per limits cycle, cache it per token if Anthropic starts 429ing.
+    const owner = account ? await tokenOwner(creds.token) : null;
+    if (account && owner !== null && owner !== account.extId) {
+        log('warn', 'limits skipped · claude login is mid-switch between accounts · retrying next cycle');
+        return null;
+    }
     const outcome = await postLimits({ ...report, account }, cfg);
     if (outcome === 'plan') {
         log('warn', planWall());

package/dist/release.js

@@ -1,2 +1,2 @@
 // Generated by .github/workflows/release.yml.
-export const RELEASE_VERSION = "1.2.150";
+export const RELEASE_VERSION = "1.2.152";

package/dist/tailer.js

@@ -5,6 +5,8 @@ import { dim, line, tilde, yellow } from './ui.js';
 const MAX_READ = 16 * 1024 * 1024;
 // Both parsers need a `usage` object, and about 3/4 of log bytes are lines without one.
 const USAGE_KEY = Buffer.from('"usage"');
+// Unescaped quotes: the same text quoted inside a message is `\"customType\"` and never matches.
+const ACCOUNT_KEY = Buffer.from('"customType":"claude-account"');
 /**
  * The working directory of a pi session, read from the file's first line
  * (`{"type":"session",…,"cwd":"/path"}`). pi's message lines carry no cwd, and
@@ -26,6 +28,18 @@ function piSessionCwd(fd) {
         return null;
     }
 }
+/** The account a pi session pinned itself to, from the dotfiles claude-accounts extension's
+ *  `{"type":"custom","customType":"claude-account","data":{"email","uuid"}}` line. Every
+ *  later line in the file ran on it, until the next such line. */
+function piSessionAccount(line) {
+    try {
+        const uuid = JSON.parse(line)?.data?.uuid;
+        return typeof uuid === 'string' && uuid !== '' ? uuid.slice(0, 100) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Read new, newline-terminated lines from `filePath` starting at the previously
  * stored offset. Handles rotation/truncation (inode change or size < offset →
@@ -41,9 +55,10 @@ export function tailFile(filePath, prev, source = 'cli') {
     }
     const rotated = prev !== undefined && (st.ino !== prev.inode || st.size < prev.offset);
     const start = rotated || prev === undefined ? 0 : prev.offset;
-    const base = { inode: Number(st.ino), offset: start };
+    const startAccount = rotated ? undefined : prev?.accountExtId;
+    const base = { accountExtId: startAccount, inode: Number(st.ino), offset: start };
     if (st.size <= start) {
-        return { consumedBytes: 0, nextState: base, records: [] };
+        return { consumedBytes: 0, nextState: base, segments: [] };
     }
     // Cap the per-cycle read so a huge backlog can't OOM; the next cycle resumes
     // from the committed offset.
@@ -70,29 +85,53 @@ export function tailFile(filePath, prev, source = 'cli') {
             return {
                 consumedBytes: length,
                 nextState: { ...base, offset: start + length },
-                records: [],
+                segments: [],
             };
         }
-        return { consumedBytes: 0, nextState: base, records: [] };
+        return { consumedBytes: 0, nextState: base, segments: [] };
     }
     const consumed = buf.subarray(0, lastNl + 1);
-    // Decode only the lines that can hold usage: decoding and splitting the whole
-    // 16 MB read peaked a first-run backlog at ~490 MB RSS.
-    const records = [];
-    let at = consumed.indexOf(USAGE_KEY);
-    while (at !== -1) {
+    // Decode only the lines that can hold usage or a pi account switch: decoding and
+    // splitting the whole 16 MB read peaked a first-run backlog at ~490 MB RSS.
+    const segments = [];
+    let account = startAccount;
+    let usageAt = consumed.indexOf(USAGE_KEY);
+    let accountAt = source === 'pi' ? consumed.indexOf(ACCOUNT_KEY) : -1;
+    while (usageAt !== -1 || accountAt !== -1) {
+        const isAccountLine = accountAt !== -1 && (usageAt === -1 || accountAt < usageAt);
+        const at = isAccountLine ? accountAt : usageAt;
         const lineStart = consumed.lastIndexOf(0x0a, at) + 1;
         const lineEnd = consumed.indexOf(0x0a, at);
-        const rec = parseLine(consumed.toString('utf-8', lineStart, lineEnd), source, sessionCwd);
-        if (rec) {
-            records.push(rec);
+        const text = consumed.toString('utf-8', lineStart, lineEnd);
+        if (isAccountLine) {
+            account = piSessionAccount(text);
+        }
+        else {
+            const rec = parseLine(text, source, sessionCwd);
+            if (rec) {
+                addRecord(segments, account, rec);
+            }
+        }
+        if (usageAt !== -1 && usageAt < lineEnd) {
+            usageAt = consumed.indexOf(USAGE_KEY, lineEnd);
+        }
+        if (accountAt !== -1 && accountAt < lineEnd) {
+            accountAt = consumed.indexOf(ACCOUNT_KEY, lineEnd);
         }
-        at = consumed.indexOf(USAGE_KEY, lineEnd);
     }
     const consumedBytes = consumed.length;
     return {
         consumedBytes,
-        nextState: { ...base, offset: start + consumedBytes },
-        records,
+        nextState: { accountExtId: account, inode: base.inode, offset: start + consumedBytes },
+        segments,
     };
 }
+function addRecord(segments, accountExtId, record) {
+    const last = segments.at(-1);
+    if (last && last.accountExtId === accountExtId) {
+        last.records.push(record);
+    }
+    else {
+        segments.push({ accountExtId, records: [record] });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@usagefleet/cli",
-	"version": "1.2.150",
+	"version": "1.2.152",
 	"description": "Tails Claude Code, Claude Desktop, and pi agent JSONL logs and reports token usage to a UsageFleet server.",
 	"keywords": [
 		"claude",