@usagefleet/cli 1.2.69 → 1.2.71

package/dist/service.js

@@ -2,9 +2,9 @@ import { execFileSync } from 'node:child_process';
 import { chmodSync, existsSync, mkdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
 import { delimiter, join } from 'node:path';
-import { DEFAULT_ENDPOINT } from './config.js';
+import { DEFAULT_ENDPOINT, loadConfig } from './config.js';
 import { installPromptHook, uninstallPromptHook } from './hook.js';
-import { readStore } from './store.js';
+import { readStore, storePath, updateStore } from './store.js';
 import { fail, header, hint, host, row, step, tilde, warn } from './ui.js';
 const LABEL = 'dev.usagefleet.collector';
 /** Scheduled Task name on Windows (mirrors the launchd label / systemd unit). */
@@ -216,23 +216,40 @@ function xml(s) {
         .replaceAll("'", ''');
 }
 export function install() {
-    // Pre-flight: refuse to install a service that can't resolve a token,
-    // otherwise the baked `watch` process throws on every launch and the service
-    // manager crash-loops it invisibly (only the log file shows it). Use the same
-    // env-OR-file precedence loadConfig() uses so an earlier install's token is
-    // honored; the endpoint needs no check, it falls back to the hosted default.
-    const file = readStore();
-    const endpoint = process.env.USAGEFLEET_ENDPOINT || file.endpoint || DEFAULT_ENDPOINT;
-    const token = process.env.USAGEFLEET_TOKEN || file.token || '';
-    if (!token) {
-        console.error(fail('config', 'no device token resolved'));
-        console.error(hint('  usagefleet install --token <device-token>'));
-        console.error(hint('  or set USAGEFLEET_TOKEN'));
-        process.exit(1);
+    // Pre-flight: refuse to install a service whose baked `watch` would throw on
+    // every launch, because the service manager crash-loops it invisibly (only the
+    // log file shows it). Resolving through loadConfig() is what makes this a real
+    // pre-flight rather than a lookalike: it is the same call `watch` makes, so a
+    // missing token or a non-https endpoint fails here or not at all.
+    let cfg;
+    try {
+        cfg = loadConfig();
+    }
+    catch (error) {
+        console.error(fail('config', error.message));
+        console.error(hint('  usagefleet install --endpoint <url> --token <device-token>'));
+        return process.exit(1);
+    }
+    // Config that only ever lived in this shell's env is lost to every later
+    // invocation: `usagefleet guard` runs from Claude Code's environment, which
+    // carries no USAGEFLEET_* vars (hook.ts bakes the command, not the env). The
+    // endpoint would fall back to the hosted default and send this device's token
+    // there; the token would be missing outright and the guard would fail open. So
+    // pin both to disk. The default endpoint is stored as absent rather than
+    // written out, so it can still move under an existing install.
+    const desiredEndpoint = cfg.endpoint === DEFAULT_ENDPOINT ? undefined : cfg.endpoint;
+    const stored = readStore();
+    if (stored.token !== cfg.token || stored.endpoint !== desiredEndpoint) {
+        // Only on a real change: `update` re-runs install every six hours, and this
+        // file is shared with the running collector's offset writes.
+        updateStore(storePath(), store => {
+            store.token = cfg.token;
+            store.endpoint = desiredEndpoint;
+        });
     }
     console.log(header());
     console.log('');
-    console.log(step('configured', host(endpoint)));
+    console.log(step('configured', host(cfg.endpoint)));
     // Windows: stop a running task first, or `schtasks /run` below is ignored (the
     // task is IgnoreNew) — leaving the OLD version resident after an "update".
     if (process.platform === 'win32') {

package/dist/uploader.js

@@ -44,7 +44,9 @@ export async function uploadBatch(payload, cfg) {
     }
     return { fatal: 'transient', ok: false };
 }
-/** Map a 4xx (never 429, the caller filters it) to a failure kind. */
+/** Map a non-OK status to a failure kind. uploadBatch only ever passes a 4xx it
+ *  has already decided not to retry; postLimits passes anything, and the 5xx/429
+ *  fall-through to 'transient' is the answer it wants. */
 function classifyClientError(status) {
     if (status === 401 || status === 403) {
         return 'auth';
@@ -76,7 +78,11 @@ function retryAfterMs(header, fallback) {
     }
     return Math.min(Math.max(wait, 0), 60_000) + Math.floor(Math.random() * 500);
 }
-/** Report the account's real limit utilization to the server. */
+/** Report the account's real limit utilization to the server. Shares uploadBatch's
+ *  failure vocabulary so a plan wall reads as one on this leg too: it runs every
+ *  cycle even when no usage records moved, so collapsing 402 to a bare failure
+ *  would log an unactionable warning forever. Single-shot by design — a stale
+ *  reading is worth less than the next cycle's fresh one. */
 export async function postLimits(report, cfg) {
     try {
         const res = await fetch(`${cfg.endpoint}/api/v1/limits`, {
@@ -88,9 +94,9 @@ export async function postLimits(report, cfg) {
             method: 'POST',
             signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
         });
-        return res.ok;
+        return res.ok ? 'ok' : classifyClientError(res.status);
     }
     catch {
-        return false;
+        return 'transient';
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@usagefleet/cli",
-	"version": "1.2.69",
+	"version": "1.2.71",
 	"description": "Tails Claude Code, Claude Desktop, and pi agent JSONL logs and reports token usage to a UsageFleet server.",
 	"keywords": [
 		"claude",
@@ -10,7 +10,7 @@
 		"usage"
 	],
 	"homepage": "https://usagefleet.com",
-	"license": "MIT",
+	"license": "GPL-3.0-or-later",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/rokartur/usagefleet.git",