@usagefleet/cli 1.2.73 → 1.2.75

package/README.md

@@ -43,12 +43,12 @@ usagefleet uninstall      # remove it
 usagefleet completion zsh # print a shell completion script (zsh, fish)
 ```
 
-Completions are printed, not installed — send them where your shell looks:
+`install` sets up completions for you, for each shell you actually use — zsh
+gets `~/.zsh/completions/_usagefleet` plus an `fpath` block appended to
+`.zshrc`, fish gets `~/.config/fish/completions/usagefleet.fish`. Restart the
+shell once. `uninstall` removes both again, and self-update keeps them current.
 
-```bash
-usagefleet completion zsh  > ~/.zsh/completions/_usagefleet   # a dir on your fpath
-usagefleet completion fish > ~/.config/fish/completions/usagefleet.fish
-```
+`completion` stays for piping a script somewhere else yourself.
 
 ## What it collects
 

package/dist/claude-account.js

@@ -0,0 +1,34 @@
+import { readFileSync } from 'node:fs';
+import { claudeStatePath } from './paths.js';
+/** Pull the account out of a parsed `~/.claude.json`. Everything but the uuid is
+ *  cosmetic, so a missing display field yields null rather than no account. */
+export function parseClaudeAccount(raw) {
+    if (typeof raw !== 'object' || raw === null) {
+        return null;
+    }
+    const acc = raw.oauthAccount;
+    if (typeof acc !== 'object' || acc === null) {
+        return null;
+    }
+    const { accountUuid, emailAddress, organizationName } = acc;
+    if (typeof accountUuid !== 'string' || accountUuid === '') {
+        return null;
+    }
+    const str = (v) => (typeof v === 'string' && v !== '' ? v.slice(0, 200) : null);
+    return { email: str(emailAddress), extId: accountUuid.slice(0, 100), org: str(organizationName) };
+}
+/**
+ * Read the local Claude Code login. Purely a local file read — no network, no
+ * credentials — so it is safe to call on every limits cycle. Returns null when
+ * Claude Code has never signed in on this machine (an ANTHROPIC_API_KEY-only
+ * setup has no account identity at all); those devices fall back to the
+ * server's unidentified-account bucket, i.e. today's behaviour.
+ */
+export function detectClaudeAccount(path = claudeStatePath()) {
+    try {
+        return parseClaudeAccount(JSON.parse(readFileSync(path, 'utf-8')));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/collector.js

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs';
 import { hostname } from 'node:os';
 import { sep } from 'node:path';
+import { detectClaudeAccount } from './claude-account.js';
 import { detectClaudeCreds, macKeychainDenied } from './claude-creds.js';
 import { fetchLimits } from './claude-limits.js';
 import { maybeNotify } from './notifier.js';
@@ -243,7 +244,11 @@ export async function reportLimitsOnce(cfg, log = () => {
     // Same vocabulary as the usage leg: a rejection the operator can act on has to
     // say which one it is, since this runs every cycle and an anonymous failure
     // would repeat forever without ever naming the fix.
-    const outcome = await postLimits(report, cfg);
+    // Tag the reading with the Claude account it came from, so a fleet split over
+    // 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;
+    const outcome = await postLimits({ ...report, account }, cfg);
     if (outcome === 'plan') {
         log('warn', planWall(cfg.endpoint));
     }

package/dist/completion.js

@@ -1,9 +1,16 @@
-/** The command list, shared by `help` and the generated completion scripts, so
- *  a new command can't land in one and be missing from the other. `args` is the
- *  hint `help` prints after the name; completion only needs the bare name. */
+import { existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { writeFileAtomic } from './atomic-write.js';
+/** The user-facing command list, shared by `help` and the generated completion
+ *  scripts, so a command can't land in one and be missing from the other. `args`
+ *  is the hint `help` prints after the name; completion only needs the bare name.
+ *
+ *  `watch` is deliberately absent: it is the entrypoint the installed service
+ *  runs, not something to type. It still dispatches — every plist and unit on
+ *  disk names it — it just isn't advertised. */
 export const commands = [
     { name: 'run', meaning: 'scan once, upload usage + report limits' },
-    { name: 'watch', args: '[--interval s]', meaning: 'poll continuously (default 15s)' },
     { name: 'limits', meaning: 'report only your real 5h/weekly usage' },
     { name: 'guard', meaning: 'exit 2 when the group is over a blocking limit' },
     { name: 'update', meaning: 'update to the latest release now' },
@@ -11,17 +18,94 @@ export const commands = [
     { name: 'status', meaning: 'service health, limits, resolved config' },
     { name: 'config', meaning: 'config file location and env overrides' },
     { name: 'completion', args: '<zsh|fish>', meaning: 'print a shell completion script' },
-    { name: 'version', meaning: 'print the release version' },
     { name: 'install', args: '--token <t>', meaning: 'configure + install the service and prompt guard' },
     { name: 'uninstall', meaning: 'remove the service and the guard' },
 ];
 export const shells = ['zsh', 'fish'];
-/** A completion script for `shell`, on stdout — the user decides where it goes
- *  (`> ~/.zsh/completions/_usagefleet`, `> ~/.config/fish/completions/…`).
- *  Writing those files ourselves would mean guessing at fpath and rc files. */
+/** A completion script for `shell`, on stdout. `install` writes these to the
+ *  right place automatically; this command stays for piping one somewhere else. */
 export function completionScript(shell) {
     return shell === 'zsh' ? zsh() : fish();
 }
+/** Sentinels around our .zshrc block, so `uninstall` removes exactly what we
+ *  added even after the user has edited around it. */
+const RC_START = '# >>> usagefleet completions >>>';
+const RC_END = '# <<< usagefleet completions <<<';
+// Resolved per call, not once at import: homedir() is what the tests vary, and
+// service.ts derives its paths the same way.
+const zshDir = () => join(homedir(), '.zsh', 'completions');
+const zshrc = () => join(homedir(), '.zshrc');
+/** Where each shell loads completions from. fish scans its directory with no
+ *  further setup; zsh only scans what is on fpath, which is why zsh also needs
+ *  the .zshrc block. */
+function completionPath(shell) {
+    return shell === 'fish'
+        ? join(homedir(), '.config', 'fish', 'completions', 'usagefleet.fish')
+        : join(zshDir(), '_usagefleet');
+}
+/** Only touch a shell the user actually runs — as the login shell or by already
+ *  having its config on disk. Installing should not scatter dotfiles for shells
+ *  that were never used. */
+function shellInUse(shell) {
+    if ((process.env.SHELL ?? '').includes(shell)) {
+        return true;
+    }
+    return existsSync(shell === 'fish' ? join(homedir(), '.config', 'fish') : zshrc());
+}
+/**
+ * Put the completion scripts where each shell looks, and for zsh make sure that
+ * directory is on fpath. Re-running is a no-op beyond rewriting the scripts, so
+ * self-update refreshes completions for free.
+ *
+ * Returns one row per shell touched: the script path, plus the rc file when this
+ * call was the one that added the block.
+ */
+export function installCompletions() {
+    const done = [];
+    for (const shell of shells) {
+        if (!shellInUse(shell)) {
+            continue;
+        }
+        const path = completionPath(shell);
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileAtomic(path, completionScript(shell));
+        done.push(shell === 'zsh' ? { shell, path, rc: ensureZshFpath() } : { shell, path });
+    }
+    return done;
+}
+/** Append the fpath block to .zshrc, once. Returns the file when this call added
+ *  it, undefined when it was already there. */
+function ensureZshFpath() {
+    const rc = zshrc();
+    const current = existsSync(rc) ? readFileSync(rc, 'utf-8') : '';
+    if (current.includes(RC_START)) {
+        return undefined;
+    }
+    // Appended, never prepended: fpath has to be set before the compinit that
+    // reads it, and we cannot know whether the user already ran compinit earlier
+    // in the file. Adding our own after theirs is the only ordering that works
+    // from the end of the file; -C skips the dump check so the second run is cheap.
+    const block = `${RC_START}\nfpath=("${zshDir().replace(homedir(), '$HOME')}" $fpath)\nautoload -Uz compinit && compinit -C\n${RC_END}\n`;
+    writeFileAtomic(rc, current === '' || current.endsWith('\n') ? current + block : `${current}\n${block}`);
+    return rc;
+}
+/** Undo installCompletions: drop the scripts and strip the .zshrc block. */
+export function removeCompletions() {
+    for (const shell of shells) {
+        rmSync(completionPath(shell), { force: true });
+    }
+    const rc = zshrc();
+    if (!existsSync(rc)) {
+        return;
+    }
+    const current = readFileSync(rc, 'utf-8');
+    const start = current.indexOf(RC_START);
+    const end = current.indexOf(RC_END);
+    if (start === -1 || end < start) {
+        return;
+    }
+    writeFileAtomic(rc, current.slice(0, start) + current.slice(end + RC_END.length).replace(/^\n/, ''));
+}
 function zsh() {
     // zsh splits a _describe entry on the first colon, so any colon in the text
     // has to be escaped or the description gets cut in half.

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { detectClaudeCreds } from './claude-creds.js';
 import { reportLimitsOnce, runOnce } from './collector.js';
-import { commands, completionScript, shells } from './completion.js';
+import { commands, completionScript, installCompletions, removeCompletions, shells } from './completion.js';
 import { loadConfig } from './config.js';
 import { runGuard } from './guard.js';
 import { loadNotifyConfig } from './notifier.js';
@@ -211,6 +211,20 @@ async function cmdInstall() {
     }
     const { install } = await import('./service.js');
     install();
+    // After the service, so a completion problem can never fail the part that
+    // matters. Self-update re-runs `install`, which keeps completions in step with
+    // new commands without the user doing anything.
+    try {
+        for (const { shell, path, rc } of installCompletions()) {
+            console.log(step(`${shell} completions`, tilde(path)));
+            if (rc) {
+                console.log(row('shell', `${tilde(rc)} updated · restart the shell to pick it up`));
+            }
+        }
+    }
+    catch (error) {
+        console.log(warn('completions', error.message));
+    }
 }
 /** Padded two-column list — name in white, meaning in gray, like the result
  *  lines. Shared by `help` and `config`. */
@@ -310,8 +324,7 @@ async function main() {
         case 'completion': {
             return cmdCompletion();
         }
-        // Bare version, so the installer can compare builds without parsing help.
-        case 'version':
+        // Flags only: bare `usagefleet` already prints the version in its header.
         case '--version':
         case '-v': {
             console.log(RELEASE_VERSION);
@@ -324,7 +337,9 @@ async function main() {
         }
         case 'uninstall': {
             const { uninstall } = await import('./service.js');
-            return uninstall();
+            uninstall();
+            removeCompletions();
+            return;
         }
         default: {
             return help();

package/dist/paths.js

@@ -46,3 +46,10 @@ export function defaultPiSessionsDirs() {
 export function claudeSettingsPath() {
     return join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'), 'settings.json');
 }
+/** Claude Code's global state file (`~/.claude.json`), which records which
+ *  Anthropic account this machine is logged into. Unlike settings.json it sits
+ *  next to the config dir, not inside it. */
+export function claudeStatePath() {
+    const dir = process.env.CLAUDE_CONFIG_DIR;
+    return dir ? join(dir, '.claude.json') : join(homedir(), '.claude.json');
+}

package/dist/release.js

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

package/package.json

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