@usagefleet/cli 1.2.163 → 1.2.165

package/README.md

@@ -78,8 +78,8 @@ shell once. `uninstall` removes both again, and self-update keeps them current.
   Desktop agent-mode (Cowork) sessions, and the
   [pi](https://github.com/badlogic/pi-mono) agent (`~/.pi/agent/sessions`,
   `anthropic` and `claude-bridge` provider records only; other providers don't
-  touch Claude limits), and the jcode agent (`~/.jcode/sessions`, Claude
-  subscription turns only).
+  touch Claude limits), and the jcode agent (`~/.jcode/sessions`) and its pj fork
+  (`~/.pj/sessions`), Claude subscription turns only.
   A per-file byte offset in the config file means each line is sent once;
   rotation and truncation are handled and partial lines are never sent. Delivery
   is at-least-once — the server dedups on `uuid`.
@@ -159,6 +159,7 @@ it (`usagefleet config` prints this same table):
 | `desktopDir` | `USAGEFLEET_DESKTOP` | override the Claude Desktop sessions dir; `off` to skip it |
 | `piDir` | `USAGEFLEET_PI` | pi sessions dirs — string or array in the file, comma-separated in env; `off` to skip |
 | `jcodeDir` | `USAGEFLEET_JCODE` | override the jcode sessions dir (`~/.jcode/sessions`); `off` to skip it |
+| `pjDir` | `USAGEFLEET_PJ` | override the pj sessions dir (`~/.pj/sessions`); `off` to skip it |
 | `interval` | `USAGEFLEET_INTERVAL` | watch poll seconds (default 15) |
 | `limitsInterval` | `USAGEFLEET_LIMITS_INTERVAL` | seconds between limit reports (default 60; 300 on API keys, where each report costs a 1-token ping) |
 | `notifications` | `USAGEFLEET_NOTIFY` | desktop notifications, on by default (`false`/`0` disables) |

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,12 +52,15 @@ export async function runOnce(cfg, log = () => {
             files.push({ fp, source: root.source });
         }
     }
-    const jcodeSessions = cfg.jcodeDir ? listJcodeSessions(cfg.jcodeDir) : [];
+    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.
+    // 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 => ({ fp, read: () => jcodePending(fp, state.jcode) })),
+        ...jcodeSessions.map(({ accountExtId, fp, source }) => ({
+            fp,
+            read: () => jcodePending(fp, source, accountExtId, state.jcode),
+        })),
     ];
     const result = {
         accepted: 0,
@@ -140,7 +143,7 @@ export async function runOnce(cfg, log = () => {
     // dedups. Only our own section is replaced, so a token written by a
     // concurrent `usagefleet login` survives.
     const pruned = pruneMissingFiles(state, files);
-    const prunedJcode = pruneGoneSessions(state.jcode, jcodeSessions);
+    const prunedJcode = pruneGoneSessions(state.jcode, jcodeSessions.map(s => s.fp));
     if (pruned || prunedJcode || advanced) {
         updateStore(cfg.storePath, store => {
             store.state.files = state.files;
@@ -224,8 +227,8 @@ function tailPending(fp, source, files) {
         segments: tail.segments,
     };
 }
-function jcodePending(fp, sessions) {
-    const session = readJcodeSession(fp, sessions[fp]);
+function jcodePending(fp, source, accountExtId, sessions) {
+    const session = readJcodeSession(fp, source, sessions[fp]);
     if (!session) {
         return null;
     }
@@ -233,11 +236,50 @@ function jcodePending(fp, 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/config.js

@@ -1,4 +1,4 @@
-import { defaultDesktopSessionsDir, defaultJcodeSessionsDir, defaultPiSessionsDirs, defaultProjectsDir, } from './paths.js';
+import { defaultDesktopSessionsDir, defaultJcodeSessionsDir, defaultPiSessionsDirs, defaultPjSessionsDir, defaultProjectsDir, } from './paths.js';
 import { readStore, storePath } from './store.js';
 /** Matches the server's BatchSchema `.max(1000)`. */
 const MAX_BATCH = 1000;
@@ -28,6 +28,7 @@ export function loadConfig() {
         desktopDir: resolveOptionalDir(process.env.USAGEFLEET_DESKTOP, file.desktopDir, defaultDesktopSessionsDir()),
         jcodeDir: resolveOptionalDir(process.env.USAGEFLEET_JCODE, file.jcodeDir, defaultJcodeSessionsDir()),
         piDirs: resolvePiDirs(process.env.USAGEFLEET_PI, file.piDir),
+        pjDir: resolveOptionalDir(process.env.USAGEFLEET_PJ, file.pjDir, defaultPjSessionsDir()),
         projectsDir: process.env.USAGEFLEET_PROJECTS || file.projectsDir || defaultProjectsDir(),
         storePath: storePath(),
         token,

package/dist/index.js

@@ -89,7 +89,7 @@ async function cmdWatch() {
     const rawUpdate = positiveNumber(process.env.USAGEFLEET_UPDATE_INTERVAL, settings.updateInterval) ?? 6 * 60 * 60;
     const updateInterval = Math.max(60, rawUpdate) * 1000;
     let lastUpdateAt = 0;
-    const watching = [cfg.projectsDir, cfg.desktopDir, ...cfg.piDirs, cfg.jcodeDir].filter((d) => !!d);
+    const watching = [cfg.projectsDir, cfg.desktopDir, ...cfg.piDirs, cfg.jcodeDir, cfg.pjDir].filter((d) => !!d);
     console.log(header(`watching every ${interval / 1000}s`));
     console.log(hint(`${watching.map(tilde).join(' · ')} → ${host(ENDPOINT)}`));
     console.log('');
@@ -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) {
@@ -192,7 +193,7 @@ async function cmdStatus() {
     console.log('');
     console.log(row('endpoint', host(ENDPOINT)));
     console.log(row('device', `${state.deviceId} · token ${tokenFor(cfg, detectClaudeAccount()?.extId).slice(0, 8)}…`));
-    const watching = [cfg.projectsDir, cfg.desktopDir, ...cfg.piDirs, cfg.jcodeDir].filter((d) => !!d);
+    const watching = [cfg.projectsDir, cfg.desktopDir, ...cfg.piDirs, cfg.jcodeDir, cfg.pjDir].filter((d) => !!d);
     for (const [i, dir] of watching.entries()) {
         console.log(row(i === 0 ? 'watching' : '', tilde(dir)));
     }
@@ -283,6 +284,7 @@ function cmdConfig() {
         ['desktopDir', 'USAGEFLEET_DESKTOP', 'override the Claude Desktop dir ("off" disables)'],
         ['piDir', 'USAGEFLEET_PI', 'pi session dirs · string or array; env comma-separated'],
         ['jcodeDir', 'USAGEFLEET_JCODE', 'override ~/.jcode/sessions ("off" disables)'],
+        ['pjDir', 'USAGEFLEET_PJ', 'override ~/.pj/sessions ("off" disables)'],
         ['interval', 'USAGEFLEET_INTERVAL', 'watch interval seconds (default 15)'],
         [
             'limitsInterval',

package/dist/jcode.js

@@ -20,7 +20,7 @@ export function listJcodeSessions(dir) {
  * (an interrupted one leaves a turn in both). So both are read and turns key on their
  * id, and anything at or before `prev.uploadedThrough` was already sent.
  */
-export function readJcodeSession(snapshotPath, prev) {
+export function readJcodeSession(snapshotPath, source, prev) {
     const journalPath = snapshotPath.replace(/\.json$/, '.journal.jsonl');
     const mtimeMs = Math.max(statSync(snapshotPath).mtimeMs, existsSync(journalPath) ? statSync(journalPath).mtimeMs : 0);
     if (prev?.mtimeMs === mtimeMs) {
@@ -40,7 +40,7 @@ export function readJcodeSession(snapshotPath, prev) {
     const seen = new Set();
     const records = [];
     for (const [message, meta] of turns) {
-        const record = toRecord(message, meta, str(snapshot.id));
+        const record = toRecord(message, meta, str(snapshot.id), source);
         if (!record || seen.has(record.uuid) || Date.parse(record.timestamp) <= uploadedThrough) {
             continue;
         }
@@ -69,7 +69,7 @@ function readJournal(path) {
     return lines;
 }
 /** jcode's `token_usage` is Anthropic's usage block (`prompt_tokens` is their sum, left out). */
-function toRecord(m, meta, sessionId) {
+function toRecord(m, meta, sessionId, source) {
     const u = m.token_usage;
     const id = str(m.id);
     const timestamp = str(m.timestamp);
@@ -96,9 +96,9 @@ function toRecord(m, meta, sessionId) {
         requestId: null,
         serviceTier: null,
         sessionId,
-        source: 'jcode',
+        source,
         timestamp,
-        uuid: `jcode:${id}`,
+        uuid: `${source}:${id}`,
         version: null,
     };
 }

package/dist/paths.js

@@ -68,6 +68,10 @@ function realDir(dir) {
 export function defaultJcodeSessionsDir() {
     return join(homedir(), '.jcode', 'sessions');
 }
+/** pj is a jcode fork that keeps its sessions in `~/.pj/sessions`; JCODE_HOME moves it too. */
+export function defaultPjSessionsDir() {
+    return join(homedir(), '.pj', 'sessions');
+}
 /** pi's agent dir, the root for its sessions and extensions.
  *  PI_CODING_AGENT_DIR is pi's own relocation knob; unlike the service-side
  *  scan above, the guard installer runs from the user's shell where that env

package/dist/release.js

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

package/dist/store.js

@@ -62,6 +62,7 @@ function normalize(raw) {
         },
         notifyThresholds: raw.notifyThresholds,
         piDir: raw.piDir,
+        pjDir: raw.pjDir,
         projectsDir: raw.projectsDir,
         state: {
             deviceId: raw.state?.deviceId || randomUUID(),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@usagefleet/cli",
-	"version": "1.2.163",
+	"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",