@usagefleet/cli 1.2.162 → 1.2.164

package/README.md

@@ -78,7 +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).
+  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`.
@@ -157,6 +158,8 @@ it (`usagefleet config` prints this same table):
 | `projectsDir` | `USAGEFLEET_PROJECTS` | override `~/.claude/projects` |
 | `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/collector.js

@@ -5,6 +5,7 @@ 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';
+import { listJcodeSessions, readJcodeSession } from './jcode.js';
 import { maybeNotify } from './notifier.js';
 import { detectOs } from './os.js';
 import { RELEASE_VERSION } from './release.js';
@@ -21,9 +22,10 @@ const PROJECTS_SUBPATH = `${sep}.claude${sep}projects${sep}`;
 /** `status` shows the cached reading's age, so it stays within this of the last check. */
 const LIMITS_CACHE_REFRESH_MS = 10 * 60_000;
 /**
- * One full scan: tail every JSONL file from its stored offset, upload new usage
- * records (chunked to batchSize), and commit each file's offset only after all
- * its chunks are acknowledged (at-least-once; the server dedups on uuid).
+ * One full scan: tail every JSONL file from its stored offset and re-read every
+ * changed jcode session, upload new usage records (chunked to batchSize), and commit
+ * each source's progress only after all its chunks are acknowledged (at-least-once;
+ * the server dedups on uuid).
  */
 export async function runOnce(cfg, log = () => {
     /* empty */
@@ -50,12 +52,23 @@ 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 })) : []);
+    // 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) })),
+    ];
     const result = {
         accepted: 0,
         dropped: 0,
         duplicates: 0,
         failed: false,
-        files: files.length,
+        files: reads.length,
         sent: 0,
     };
     // Defensive: a bad batchSize must never stall the chunk loop.
@@ -64,35 +77,35 @@ export async function runOnce(cfg, log = () => {
     // A server that is down or unreachable fails every file for the same reason,
     // so the cycle reports one count instead of a screenful of identical lines.
     let transientFiles = 0;
-    for (const { fp, source } of files) {
-        let tail;
+    for (const { fp, read } of reads) {
+        let pending;
         try {
-            tail = tailFile(fp, state.files[fp], source);
+            pending = read();
         }
         catch (error) {
             // One unreadable/oversized file must not abort the whole cycle.
             log('warn', `skipped ${tilde(fp)} · ${error.message}`);
             continue;
         }
-        if (!tail || tail.consumedBytes === 0) {
+        if (!pending) {
             continue;
         }
-        if (tail.segments.length === 0) {
+        if (pending.segments.length === 0) {
             // Consumed only non-usage lines — safe to advance immediately.
-            state.files[fp] = tail.nextState;
+            pending.commit();
             advanced = true;
             continue;
         }
         // sendChunk absorbs "invalid" by bisecting, so only auth/plan/transient escape.
         let outcome = 'ok';
-        for (const chunk of chunks(tail.segments, step)) {
+        for (const chunk of chunks(pending.segments, step)) {
             outcome = await sendChunk(chunk.records, chunk.accountExtId, cfg, result, log);
             if (outcome !== 'ok') {
                 break;
             }
         }
         if (outcome === 'ok') {
-            state.files[fp] = tail.nextState;
+            pending.commit();
             advanced = true;
         }
         else if (outcome === 'auth') {
@@ -130,9 +143,12 @@ export async function runOnce(cfg, log = () => {
     // on every save, and a crash mid-cycle only costs a re-upload the server
     // dedups. Only our own section is replaced, so a token written by a
     // concurrent `usagefleet login` survives.
-    if (pruneMissingFiles(state, files) || advanced) {
+    const pruned = pruneMissingFiles(state, files);
+    const prunedJcode = pruneGoneSessions(state.jcode, jcodeSessions.map(s => s.fp));
+    if (pruned || prunedJcode || advanced) {
         updateStore(cfg.storePath, store => {
             store.state.files = state.files;
+            store.state.jcode = state.jcode;
             store.state.updatedAt = new Date().toISOString();
         });
     }
@@ -200,6 +216,45 @@ function chunks(segments, step) {
     }
     return out;
 }
+function tailPending(fp, source, files) {
+    const tail = tailFile(fp, files[fp], source);
+    if (!tail || tail.consumedBytes === 0) {
+        return null;
+    }
+    return {
+        commit: () => {
+            files[fp] = tail.nextState;
+        },
+        segments: tail.segments,
+    };
+}
+function jcodePending(fp, source, sessions) {
+    const session = readJcodeSession(fp, source, sessions[fp]);
+    if (!session) {
+        return null;
+    }
+    return {
+        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 }] : [],
+    };
+}
+/** Drop the progress of jcode sessions no longer on disk; returns whether anything went. */
+function pruneGoneSessions(sessions, listed) {
+    const kept = new Set(listed);
+    let removed = false;
+    for (const fp of Object.keys(sessions)) {
+        if (!kept.has(fp)) {
+            // oxlint-disable-next-line typescript/no-dynamic-delete -- state.jcode is a JSON blob keyed by path
+            delete sessions[fp];
+            removed = true;
+        }
+    }
+    return removed;
+}
 /**
  * Drop offsets for logs that no longer exist on disk, so a long-lived install
  * does not grow its state file by one entry per Claude session forever. Only

package/dist/config.js

@@ -1,4 +1,4 @@
-import { defaultDesktopSessionsDir, 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;
@@ -26,7 +26,9 @@ export function loadConfig() {
         accountTokens: file.accountTokens ?? {},
         batchSize,
         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,
@@ -71,7 +73,7 @@ export function resolvePiDirs(env, fromFile) {
     }
     return [...new Set(raw.map(d => d.trim()).filter(d => d.length > 0))];
 }
-/** Optional scan root (USAGEFLEET_DESKTOP): env "off"/"0" disables, env or
+/** Optional scan root (USAGEFLEET_DESKTOP, USAGEFLEET_JCODE): env "off"/"0" disables, env or
  *  config-file path overrides, else the auto-detected default. */
 function resolveOptionalDir(env, fromFile, fallback) {
     if (env === '0' || env?.toLowerCase() === 'off') {

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].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('');
@@ -192,7 +192,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].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)));
     }
@@ -282,6 +282,8 @@ function cmdConfig() {
         ['projectsDir', 'USAGEFLEET_PROJECTS', 'override ~/.claude/projects'],
         ['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

@@ -0,0 +1,104 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { str } from './parser.js';
+// "claude" and "claude-oauth" run on the Claude subscription; "claude-api" is a billed API key.
+const SUBSCRIPTION_PROVIDERS = new Set(['claude', 'claude-oauth']);
+// Same reason as the scanner's QUIET_MS: a write right after a read can keep the read's mtime.
+const QUIET_MS = 10_000;
+export function listJcodeSessions(dir) {
+    if (!existsSync(dir)) {
+        return [];
+    }
+    return readdirSync(dir)
+        .filter(name => name.startsWith('session_') && name.endsWith('.json'))
+        .map(name => join(dir, name));
+}
+/**
+ * New subscription turns of one jcode session, or null when its files have not
+ * changed since `prev`. jcode keeps a session as `<id>.json`, rewritten whole, plus
+ * `<id>.journal.jsonl`, appended per turn and folded into the snapshot at checkpoints
+ * (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, 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) {
+        return null;
+    }
+    const snapshot = JSON.parse(readFileSync(snapshotPath, 'utf-8'));
+    // shortcut: snapshot turns take the session's current provider/model; a provider switch rewrites
+    // the snapshot, so a first backfill of such a session books older turns on the new provider.
+    const turns = (snapshot.messages ?? []).map(m => [m, snapshot]);
+    for (const line of readJournal(journalPath)) {
+        for (const m of line.append_messages ?? []) {
+            turns.push([m, line.meta ?? snapshot]);
+        }
+    }
+    const uploadedThrough = prev?.uploadedThrough ?? 0;
+    let newest = uploadedThrough;
+    const seen = new Set();
+    const records = [];
+    for (const [message, meta] of turns) {
+        const record = toRecord(message, meta, str(snapshot.id), source);
+        if (!record || seen.has(record.uuid) || Date.parse(record.timestamp) <= uploadedThrough) {
+            continue;
+        }
+        seen.add(record.uuid);
+        records.push(record);
+        newest = Math.max(newest, Date.parse(record.timestamp));
+    }
+    return {
+        nextState: { mtimeMs: Date.now() - mtimeMs > QUIET_MS ? mtimeMs : 0, uploadedThrough: newest },
+        records,
+    };
+}
+function readJournal(path) {
+    if (!existsSync(path)) {
+        return [];
+    }
+    const lines = [];
+    for (const text of readFileSync(path, 'utf-8').split('\n')) {
+        try {
+            lines.push(JSON.parse(text));
+        }
+        catch {
+            // The empty tail after the last newline, or the line jcode is still writing.
+        }
+    }
+    return lines;
+}
+/** jcode's `token_usage` is Anthropic's usage block (`prompt_tokens` is their sum, left out). */
+function toRecord(m, meta, sessionId, source) {
+    const u = m.token_usage;
+    const id = str(m.id);
+    const timestamp = str(m.timestamp);
+    if (m.role !== 'assistant' ||
+        !u ||
+        !id ||
+        !timestamp ||
+        Number.isNaN(Date.parse(timestamp)) ||
+        !SUBSCRIPTION_PROVIDERS.has(str(meta.provider_key) ?? '')) {
+        return null;
+    }
+    return {
+        // jcode does not log the cache-write TTL; the server prices it by the user's setting.
+        cacheCreation1h: null,
+        cacheCreation5m: null,
+        cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
+        cacheReadTokens: u.cache_read_input_tokens ?? 0,
+        cwd: str(meta.working_dir),
+        gitBranch: null,
+        inputTokens: u.input_tokens ?? 0,
+        messageId: id,
+        model: str(meta.model),
+        outputTokens: u.output_tokens ?? 0,
+        requestId: null,
+        serviceTier: null,
+        sessionId,
+        source,
+        timestamp,
+        uuid: `${source}:${id}`,
+        version: null,
+    };
+}

package/dist/parser.js

@@ -1,5 +1,5 @@
 /** Only accept genuine strings; ignores numbers/objects that would later break. */
-function str(v) {
+export function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : null;
 }
 /** A valid ISO-ish timestamp string, else the current time (never an invalid one). */

package/dist/paths.js

@@ -63,6 +63,15 @@ function realDir(dir) {
         return dir;
     }
 }
+/** jcode keeps every session flat in `~/.jcode/sessions`. JCODE_HOME moves it, but a
+ *  service never inherits the user's shell env, so a moved one is set via USAGEFLEET_JCODE. */
+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.162";
+export const RELEASE_VERSION = "1.2.164";

package/dist/store.js

@@ -52,6 +52,7 @@ function normalize(raw) {
         desktopDir: raw.desktopDir,
         hook: raw.hook,
         interval: raw.interval,
+        jcodeDir: raw.jcodeDir,
         limits: raw.limits,
         limitsInterval: raw.limitsInterval,
         notifications: raw.notifications,
@@ -61,10 +62,12 @@ function normalize(raw) {
         },
         notifyThresholds: raw.notifyThresholds,
         piDir: raw.piDir,
+        pjDir: raw.pjDir,
         projectsDir: raw.projectsDir,
         state: {
             deviceId: raw.state?.deviceId || randomUUID(),
             files: raw.state?.files ?? {},
+            jcode: raw.state?.jcode ?? {},
             updatedAt: raw.state?.updatedAt ?? new Date().toISOString(),
         },
         token: raw.token,

package/package.json

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