@usagefleet/cli 1.2.78 → 1.2.79

package/README.md

@@ -101,6 +101,11 @@ on re-install, and skipped entirely with `USAGEFLEET_HOOK=0`):
 }
 ```
 
+If `USAGEFLEET_CONFIG` was set when you logged in, the installed command carries
+it (`USAGEFLEET_CONFIG=<path> usagefleet guard`, or `set "..." && ...` on
+Windows). That is what binds the hook to the right store, and so to the right
+Anthropic account — see "Two Claude accounts on one machine" below.
+
 `guard` **fails open** everywhere else — no config, server down, timeout (5s),
 old server, 429 — because a tracker problem must never stop you working. Only
 whole prompts are blocked, never tool calls mid-turn, so the current turn always
@@ -149,9 +154,18 @@ CLAUDE_CONFIG_DIR=~/.claude-work \
   usagefleet login uf_...
 ```
 
-Each reports its own account, and the dashboard keeps their limits apart. With a
-relocated config dir the macOS Keychain is skipped on purpose: that item belongs
-to the default login.
+Each reports its own account, and the dashboard keeps their limits apart. The
+prompt guard follows: because `USAGEFLEET_CONFIG` was set for this `login`, the
+hook written into `~/.claude-work/settings.json` carries it, so that account's
+guard reads that account's token and blocks against the right subscription. With
+a relocated config dir the macOS Keychain is skipped on purpose: that item
+belongs to the default login.
+
+**Only one of them can run as the background service.** The launchd label,
+systemd unit and Scheduled Task name are fixed, so the second `login` rewrites
+the first one's service definition rather than adding a second. Run the extra
+collector yourself with the same env — `... usagefleet watch`, under your own
+unit or terminal — and keep `login` for the account you want supervised.
 
 ## Background service
 

package/dist/claude-limits.js

@@ -3,13 +3,7 @@ export function parsePct(v) {
     if (v == null || v === '') {
         return null;
     }
-    const n = Number(v);
-    if (!Number.isFinite(n)) {
-        return null;
-    }
-    // Header is a percent (e.g. "37"); guard the 0–1 fraction form too.
-    const pct = n > 0 && n <= 1 ? n * 100 : n;
-    return Math.min(100, Math.max(0, Math.round(pct)));
+    return clampPct(Number(v));
 }
 export function parseReset(v) {
     if (!v) {
@@ -76,9 +70,17 @@ async function fetchOauthModelLimits(token) {
     }
     return parseOauthUsage(body);
 }
-/** oauth/usage values are already 0–100 percentages (unlike the 0–1 header
- *  fractions) — clamp without the fraction heuristic so 1% never reads as 100%. */
+/** Both sources report 0–100 percentages: the `-utilization` headers ("37") and
+ *  oauth/usage's `utilization`/`percent` fields. Clamping is all they need — a
+ *  0–1 "fraction form" heuristic would read a real 1% as 100%, which reaches the
+ *  headline number, the critical notification and guard's prompt block.
+ *
+ *  Non-finite in, null out: `Infinity` (a JSON `1e999`, or a junk header) would
+ *  otherwise clamp to a perfectly plausible 100 and block every prompt. */
 function clampPct(n) {
+    if (!Number.isFinite(n)) {
+        return null;
+    }
     return Math.min(100, Math.max(0, Math.round(n)));
 }
 /** Normalize a scope's model name to a header-safe key ("Fable" → "fable"). */

package/dist/guard.js

@@ -50,7 +50,10 @@ export async function runGuard() {
     catch {
         return 0; // offline / timeout / bad JSON — fail open
     }
-    const msg = blockMessage(view);
+    // A 200 whose body is literally `null` has to fail open like every other
+    // unexpected shape. Reading `.blocked` off it here would throw past the
+    // try above and out of runGuard, which is the one thing this must never do.
+    const msg = blockMessage(view ?? {});
     if (!msg) {
         return 0;
     }

package/dist/hook.js

@@ -9,9 +9,22 @@ const HOOK_TIMEOUT_S = 10;
 /** Recognises a guard hook we installed (at any binary path, from any version)
  *  so install is idempotent and uninstall is precise. */
 const GUARD_COMMAND = /usagefleet.*\bguard\b/;
-/** `/path/to/usagefleet guard`, quoted for the shell Claude Code runs it in. */
-export function guardCommand(program) {
-    return program.map(p => (p.includes(' ') ? `"${p}"` : p)).join(' ');
+/** `/path/to/usagefleet guard`, quoted for the shell Claude Code runs it in.
+ *  Carries USAGEFLEET_CONFIG through when set: the documented two-subscription
+ *  setup (apps/cli/README.md) gives each account its own store *and* its own
+ *  Claude settings.json, so without it both hooks would read the default config
+ *  and block against the wrong account. `platform` is a parameter so the two
+ *  shells can be tested; cmd.exe has no inline `VAR=value cmd` form, and the
+ *  POSIX prefix there would be read as a program name and never launch. */
+export function guardCommand(program, configPath, platform = process.platform) {
+    const quote = (p) => (p.includes(' ') ? `"${p}"` : p);
+    const command = program.map(quote).join(' ');
+    if (!configPath) {
+        return command;
+    }
+    return platform === 'win32'
+        ? `set "USAGEFLEET_CONFIG=${configPath}" && ${command}`
+        : `USAGEFLEET_CONFIG=${quote(configPath)} ${command}`;
 }
 /** Drop every guard hook we ever installed, leaving the rest of the file alone. */
 export function withoutGuardHook(settings) {
@@ -96,7 +109,7 @@ export function installPromptHook(program) {
     if (process.env.USAGEFLEET_HOOK === '0') {
         return;
     }
-    const command = guardCommand(program);
+    const command = guardCommand(program, process.env.USAGEFLEET_CONFIG);
     editSettings(s => withGuardHook(s, command), path => console.log(step('hook', `prompt guard · ${tilde(path)}`)));
 }
 export function uninstallPromptHook() {

package/dist/index.js

@@ -289,11 +289,15 @@ async function main() {
     // Log-and-continue for the long-running watch daemon: a stray rejection must
     // not silently kill the background service. One-shot commands still set a
     // non-zero exit via their own error paths.
+    //
+    // stderr, not `line()`: `usagefleet guard` runs as a UserPromptSubmit hook and
+    // Claude Code injects a hook's stdout into the model's context, so a crash
+    // notice on stdout would end up in the conversation.
     process.on('unhandledRejection', reason => {
-        line(yellow('!'), `unhandled rejection ${dim(String(reason))}`);
+        console.error(`${yellow('!')} unhandled rejection ${dim(String(reason))}`);
     });
     process.on('uncaughtException', err => {
-        line(yellow('!'), `uncaught exception ${dim(err.message)}`);
+        console.error(`${yellow('!')} uncaught exception ${dim(err.message)}`);
     });
     const cmd = process.argv[2] ?? 'help';
     switch (cmd) {

package/dist/os.js

@@ -10,7 +10,8 @@ export function detectOs() {
             return 'linux';
         }
         default: {
-            return process.platform;
+            // freebsd/sunos/android: still a usable collector, just an unlabelled box.
+            return 'other';
         }
     }
 }

package/dist/parser.js

@@ -23,8 +23,10 @@ function cacheCreation(u) {
  *  provider, model, responseId, usage:{input, output, cacheRead, cacheWrite}}}`.
  *  Only provider "anthropic" hits the user's Claude account — other providers
  *  (openai-codex, openrouter, …) are skipped. `output` already includes reasoning
- *  tokens (totalTokens = input + output + cacheRead + cacheWrite). */
-function parsePiLine(o) {
+ *  tokens (totalTokens = input + output + cacheRead + cacheWrite).
+ *  The line carries no working directory; `sessionCwd` comes from the file's
+ *  session header (see piSessionCwd). */
+function parsePiLine(o, sessionCwd) {
     if (o.type !== 'message') {
         return null;
     }
@@ -47,7 +49,7 @@ function parsePiLine(o) {
     return {
         cacheCreationTokens: u.cacheWrite ?? 0,
         cacheReadTokens: u.cacheRead ?? 0,
-        cwd: null,
+        cwd: sessionCwd,
         gitBranch: null,
         inputTokens: u.input ?? 0,
         messageId: rid,
@@ -68,8 +70,9 @@ function parsePiLine(o) {
  * `uuid` is the per-line idempotency key the server dedups on. `source` tags which
  * app the file came from (the line itself carries no app identifier) and selects
  * the format: `pi` files use pi's own schema, everything else Claude Code's.
+ * `sessionCwd` is the file-level working directory, used only by `pi`.
  */
-export function parseLine(line, source = 'cli') {
+export function parseLine(line, source = 'cli', sessionCwd = null) {
     const trimmed = line.trim();
     if (!trimmed) {
         return null;
@@ -92,7 +95,7 @@ export function parseLine(line, source = 'cli') {
     }
     const o = parsed;
     if (source === 'pi') {
-        return parsePiLine(o);
+        return parsePiLine(o, sessionCwd);
     }
     if (o.type !== 'assistant') {
         return null;

package/dist/release.js

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

package/dist/tailer.js

@@ -3,6 +3,27 @@ import { parseLine } from './parser.js';
 import { dim, line, tilde, yellow } from './ui.js';
 /** Max bytes read from a single file per cycle (bounds memory on huge backlogs). */
 const MAX_READ = 16 * 1024 * 1024;
+/**
+ * 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
+ * tailing usually resumes past the header, so it is re-read per cycle rather
+ * than remembered. The session dir name encodes the same path but lossily
+ * (`/Developer/claude-track` and `/Developer/claude/track` collide), so the
+ * header is the only exact source.
+ */
+function piSessionCwd(fd) {
+    const head = Buffer.alloc(4096);
+    const read = readSync(fd, head, 0, head.length, 0);
+    const nl = head.indexOf(0x0a);
+    try {
+        const o = JSON.parse(head.subarray(0, nl === -1 ? read : nl).toString('utf-8'));
+        const cwd = o?.cwd;
+        return typeof cwd === 'string' && cwd.length > 0 ? cwd : null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Read new, newline-terminated lines from `filePath` starting at the previously
  * stored offset. Handles rotation/truncation (inode change or size < offset →
@@ -27,8 +48,12 @@ export function tailFile(filePath, prev, source = 'cli') {
     const length = Math.min(st.size - start, MAX_READ);
     const buf = Buffer.alloc(length);
     const fd = openSync(filePath, 'r');
+    let sessionCwd = null;
     try {
         readSync(fd, buf, 0, length, start);
+        if (source === 'pi') {
+            sessionCwd = piSessionCwd(fd);
+        }
     }
     finally {
         closeSync(fd);
@@ -52,7 +77,7 @@ export function tailFile(filePath, prev, source = 'cli') {
     const text = consumed.toString('utf-8');
     const records = [];
     for (const line of text.split('\n')) {
-        const rec = parseLine(line, source);
+        const rec = parseLine(line, source, sessionCwd);
         if (rec) {
             records.push(rec);
         }

package/dist/update.js

@@ -19,14 +19,34 @@ function npmCommand() {
     const sibling = join(dirname(process.execPath), process.platform === 'win32' ? 'npm.cmd' : 'npm');
     return existsSync(sibling) ? sibling : 'npm';
 }
-/** Exit code of a finished child, or null when it could not be started. */
+/** An `npm install` that never returns would hang the watch loop forever, since
+ *  the update check is awaited inline before the next tick is scheduled: the
+ *  daemon would still be "running" while collecting nothing, with an empty log.
+ *  Generous enough for a slow registry on a cold cache. */
+const RUN_TIMEOUT_MS = 10 * 60_000;
+/** Exit code of a finished child, or null when it could not be started, was
+ *  killed for exceeding RUN_TIMEOUT_MS, or died on a signal. */
 function run(cmd, args) {
     return new Promise(resolve => {
         // shell on Windows: node refuses to spawn a .cmd directly since the 2024
         // argument-injection fix. Every argument here is a literal or VERSION-checked.
         const child = spawn(cmd, args, { shell: process.platform === 'win32', stdio: 'ignore' });
-        child.on('error', () => resolve(null));
-        child.on('close', code => resolve(code));
+        const timer = setTimeout(() => child.kill(), RUN_TIMEOUT_MS);
+        // Node emits 'close' after 'error' for a failed spawn, so both handlers can
+        // run; `settled` makes the first one win. oxlint's promise rule sees the two
+        // registrations and can't see the guard between them.
+        let settled = false;
+        const finish = (code) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            // oxlint-disable-next-line promise/no-multiple-resolved
+            resolve(code);
+        };
+        child.on('error', () => finish(null));
+        child.on('close', code => finish(code));
     });
 }
 /**

package/package.json

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