@usagefleet/cli 1.2.164 → 1.2.165

package/dist/claude-account.js

@@ -33,6 +33,19 @@ export function detectClaudeAccount(path = claudeStatePath()) {
     }
 }
 const OAUTH_PROFILE_URL = 'https://api.anthropic.com/api/oauth/profile';
+/** The OAuth access token of the login jcode (or pj) has active in its `auth.json`,
+ *  falling back to the first saved login the way jcode does. Null when unreadable. */
+export function activeJcodeToken(authPath) {
+    try {
+        const auth = JSON.parse(readFileSync(authPath, 'utf-8'));
+        const accounts = auth.anthropic_accounts ?? [];
+        const active = accounts.find(a => a.label === auth.active_anthropic_account) ?? accounts[0];
+        return typeof active?.access === 'string' && active.access !== '' ? active.access : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** 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. */

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, tokenOwner } from './claude-account.js';
+import { dirname, join, sep } from 'node:path';
+import { activeJcodeToken, detectClaudeAccount, tokenOwner } from './claude-account.js';
 import { detectClaudeCreds, macKeychainDenied } from './claude-creds.js';
 import { fetchLimits } from './claude-limits.js';
 import { ENDPOINT } from './config.js';
@@ -29,7 +29,7 @@ const LIMITS_CACHE_REFRESH_MS = 10 * 60_000;
  */
 export async function runOnce(cfg, log = () => {
     /* empty */
-}, dirCache = new Map()) {
+}, dirCache = new Map(), tokenOwners = new Map()) {
     const { state } = readStore(cfg.storePath);
     // Each scan root is tagged with the app that owns it. Claude Code's projects
     // dir is scanned whole; the Claude Desktop sessions root is filtered to its
@@ -52,16 +52,15 @@ export async function runOnce(cfg, log = () => {
             files.push({ fp, source: root.source });
         }
     }
-    const jcodeRoots = [
-        { dir: cfg.jcodeDir, source: 'jcode' },
-        { dir: cfg.pjDir, source: 'pj' },
-    ];
-    const jcodeSessions = jcodeRoots.flatMap(({ dir, source }) => dir ? listJcodeSessions(dir).map(fp => ({ fp, source })) : []);
+    const jcodeSessions = await listJcodeSessionsWithAccount(cfg, tokenOwners);
     // Each source yields its new records and how to commit having sent them, so both
     // share one upload path: offsets for appended JSONL, a watermark for jcode and pj.
     const reads = [
         ...files.map(({ fp, source }) => ({ fp, read: () => tailPending(fp, source, state.files) })),
-        ...jcodeSessions.map(({ fp, source }) => ({ fp, read: () => jcodePending(fp, source, state.jcode) })),
+        ...jcodeSessions.map(({ accountExtId, fp, source }) => ({
+            fp,
+            read: () => jcodePending(fp, source, accountExtId, state.jcode),
+        })),
     ];
     const result = {
         accepted: 0,
@@ -228,7 +227,7 @@ function tailPending(fp, source, files) {
         segments: tail.segments,
     };
 }
-function jcodePending(fp, source, sessions) {
+function jcodePending(fp, source, accountExtId, sessions) {
     const session = readJcodeSession(fp, source, sessions[fp]);
     if (!session) {
         return null;
@@ -237,11 +236,50 @@ function jcodePending(fp, source, sessions) {
         commit: () => {
             sessions[fp] = session.nextState;
         },
-        // shortcut: jcode keeps its own Anthropic logins and stamps none on a session, so its
-        // turns book on the device's Claude Code account; read jcode's active login if they differ.
-        segments: session.records.length > 0 ? [{ accountExtId: undefined, records: session.records }] : [],
+        segments: session.records.length > 0 ? [{ accountExtId, records: session.records }] : [],
     };
 }
+async function listJcodeSessionsWithAccount(cfg, tokenOwners) {
+    const roots = [
+        { dir: cfg.jcodeDir, source: 'jcode' },
+        { dir: cfg.pjDir, source: 'pj' },
+    ];
+    const out = [];
+    for (const { dir, source } of roots) {
+        const sessions = dir ? listJcodeSessions(dir) : [];
+        if (!dir || sessions.length === 0) {
+            continue;
+        }
+        const accountExtId = await jcodeAccount(dir, tokenOwners);
+        for (const fp of sessions) {
+            out.push({ accountExtId, fp, source });
+        }
+    }
+    return out;
+}
+/** The Anthropic account jcode (or pj) is signed into: the owner of the active login in
+ *  the `auth.json` beside its sessions dir. Undefined (the batch then books on the
+ *  Claude Code account) when that file or the profile lookup fails. Owners are cached per
+ *  access token, so the profile call repeats only when jcode refreshes or switches logins.
+ *  shortcut: books a turn on the login active at upload time, so a switch between a turn
+ *  and its upload (or a backfill) books it on the new login; stamp the login per turn in
+ *  jcode if that matters. */
+async function jcodeAccount(sessionsDir, owners) {
+    const token = activeJcodeToken(join(dirname(sessionsDir), 'auth.json'));
+    if (!token) {
+        return undefined;
+    }
+    const cached = owners.get(token);
+    if (cached) {
+        return cached;
+    }
+    const owner = await tokenOwner(token);
+    if (!owner) {
+        return undefined;
+    }
+    owners.set(token, owner);
+    return owner;
+}
 /** Drop the progress of jcode sessions no longer on disk; returns whether anything went. */
 function pruneGoneSessions(sessions, listed) {
     const kept = new Set(listed);

package/dist/index.js

@@ -97,13 +97,14 @@ async function cmdWatch() {
     let timer = null;
     let running = false;
     const dirCache = new Map();
+    const tokenOwners = new Map();
     const tick = async () => {
         if (stopping) {
             return;
         }
         running = true;
         try {
-            const r = await runOnce(cfg, stream, dirCache);
+            const r = await runOnce(cfg, stream, dirCache, tokenOwners);
             // Dropped records are real data loss, so they must show up even in a
             // cycle that uploaded nothing.
             if (r.sent > 0 || r.dropped > 0) {

package/dist/release.js

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

package/package.json

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