@usagefleet/cli 1.2.59

package/dist/tailer.js

@@ -0,0 +1,65 @@
+import { closeSync, openSync, readSync, statSync } from 'node:fs';
+import { parseLine } from './parser.js';
+/** Max bytes read from a single file per cycle (bounds memory on huge backlogs). */
+const MAX_READ = 16 * 1024 * 1024;
+/**
+ * Read new, newline-terminated lines from `filePath` starting at the previously
+ * stored offset. Handles rotation/truncation (inode change or size < offset →
+ * restart from 0) and partial trailing lines (never consume past the last \n).
+ */
+export function tailFile(filePath, prev, source = 'cli') {
+    let st;
+    try {
+        st = statSync(filePath);
+    }
+    catch {
+        return null; // file vanished
+    }
+    const rotated = prev !== undefined && (st.ino !== prev.inode || st.size < prev.offset);
+    const start = rotated || prev === undefined ? 0 : prev.offset;
+    const base = { inode: Number(st.ino), offset: start };
+    if (st.size <= start) {
+        return { consumedBytes: 0, nextState: base, records: [] };
+    }
+    // Cap the per-cycle read so a huge backlog can't OOM; the next cycle resumes
+    // from the committed offset.
+    const length = Math.min(st.size - start, MAX_READ);
+    const buf = Buffer.alloc(length);
+    const fd = openSync(filePath, 'r');
+    try {
+        readSync(fd, buf, 0, length, start);
+    }
+    finally {
+        closeSync(fd);
+    }
+    // Only consume up to the last newline; keep any partial trailing line.
+    const lastNl = buf.lastIndexOf(0x0a);
+    if (lastNl === -1) {
+        // No newline in a full MAX_READ window = one pathologically long line.
+        // Skip past it so the file can't stall forever.
+        if (length >= MAX_READ) {
+            console.warn(`usagefleet: skipping a line > ${MAX_READ} bytes in ${filePath} at offset ${start}`);
+            return {
+                consumedBytes: length,
+                nextState: { ...base, offset: start + length },
+                records: [],
+            };
+        }
+        return { consumedBytes: 0, nextState: base, records: [] };
+    }
+    const consumed = buf.subarray(0, lastNl + 1);
+    const text = consumed.toString('utf-8');
+    const records = [];
+    for (const line of text.split('\n')) {
+        const rec = parseLine(line, source);
+        if (rec) {
+            records.push(rec);
+        }
+    }
+    const consumedBytes = consumed.length;
+    return {
+        consumedBytes,
+        nextState: { ...base, offset: start + consumedBytes },
+        records,
+    };
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui.js

@@ -0,0 +1,69 @@
+/**
+ * Terminal output helpers, "quiet" style: one accent colour, detail in gray,
+ * a padded label column so lines align.
+ *
+ * Colour is dropped when stdout is not a TTY (service logs, CI, pipes) or when
+ * NO_COLOR is set. Bars are plain characters, so a log file still shows them.
+ */
+const useColor = process.stdout.isTTY === true && !process.env.NO_COLOR;
+function paint(code) {
+    return s => (useColor ? `\u001B[${code}m${s}\u001B[0m` : s);
+}
+export const dim = paint('90');
+export const green = paint('32');
+export const yellow = paint('33');
+export const red = paint('31');
+export const blue = paint('34');
+export const bold = paint('1');
+/** Width of the label column shared by `step` and `row`. */
+const LABEL = 10;
+/** "✓ installed   ~/.local/bin/usagefleet" — a completed step. */
+export function step(label, detail = '') {
+    return `${green('✓')} ${label.padEnd(LABEL)} ${dim(detail)}`;
+}
+/** "● service     running" — state with a health-coloured dot. */
+export function state(health, label, detail) {
+    const dot = health === 'ok' ? green('●') : health === 'warn' ? yellow('●') : red('●');
+    return `${dot} ${label.padEnd(LABEL)} ${detail}`;
+}
+/** "  config      ~/.config/usagefleet/config.json" — a plain detail line. */
+export function row(label, detail) {
+    return `  ${label.padEnd(LABEL)} ${dim(detail)}`;
+}
+/** Percentage as a fixed-width string, so successive log lines line up. */
+export function pct(value) {
+    return `${value ?? '?'}%`.padStart(4);
+}
+/** Usage bar, coloured by how close the window is to its limit.
+ *  Unknown usage renders as an empty bar rather than a missing column. */
+export function bar(value, width = 10) {
+    if (value === null) {
+        return dim('░'.repeat(width));
+    }
+    // Any real usage lights at least one cell: an empty bar means zero, nothing else.
+    const cells = Math.round((value / 100) * width);
+    const filled = value > 0 ? Math.max(1, Math.min(width, cells)) : 0;
+    const fill = value >= 95 ? red : value >= 80 ? yellow : green;
+    return fill('█'.repeat(filled)) + dim('░'.repeat(width - filled));
+}
+/** "2m ago" / "3d ago" — compact age of an ISO timestamp. */
+export function ago(iso) {
+    if (!iso) {
+        return 'never';
+    }
+    const ms = Date.now() - new Date(iso).getTime();
+    if (!Number.isFinite(ms) || ms < 0) {
+        return 'unknown';
+    }
+    const s = Math.round(ms / 1000);
+    if (s < 60) {
+        return `${s}s ago`;
+    }
+    if (s < 3600) {
+        return `${Math.round(s / 60)}m ago`;
+    }
+    if (s < 86_400) {
+        return `${Math.round(s / 3600)}h ago`;
+    }
+    return `${Math.round(s / 86_400)}d ago`;
+}

package/dist/update.js

@@ -0,0 +1,100 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { RELEASE_VERSION } from './release.js';
+/** The published package: one artifact for every OS, installed with
+ *  `npm i -g @usagefleet/cli`. */
+const PACKAGE = '@usagefleet/cli';
+/** Public registry, so self-update needs no server, no token and no GitHub
+ *  credential — and npm verifies the tarball's integrity on the way in. */
+const REGISTRY = 'https://registry.npmjs.org';
+/** Semver in the shape npm accepts on a command line. The registry is remote
+ *  input that ends up in an `npm install` argv (and on Windows, in a shell), so
+ *  anything unexpected is dropped rather than passed along. */
+const VERSION = /^\d+\.\d+\.\d+(?:-[\w.]+)?$/;
+/** npm from the same install as the node running us. A launchd/systemd service
+ *  gets a minimal PATH that rarely has the user's node manager on it, so the
+ *  bare name is only a fallback. */
+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. */
+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));
+    });
+}
+/**
+ * Upgrade the collector in place via npm and restart the service on the new
+ * version. Returns the version installed, or null when there was nothing to do.
+ *
+ * Every failure path is a silent no-op — a self-updater that breaks a working
+ * install is worse than one that skips a release. `force` is the manual
+ * `usagefleet update`, which ignores USAGEFLEET_UPDATE=0 but still refuses to
+ * touch a dev build.
+ */
+export async function checkForUpdate(log, force = false) {
+    if (RELEASE_VERSION === 'dev') {
+        if (force) {
+            log('update: this is a dev build — install the published package first.');
+        }
+        return null;
+    }
+    // The service is restarted by re-invoking this script, so without a path to
+    // it there is nothing to hand over to.
+    const self = process.argv[1];
+    if (!self) {
+        return null;
+    }
+    if (!force && process.env.USAGEFLEET_UPDATE === '0') {
+        return null;
+    }
+    // A rejected fetch (offline, DNS, timeout) must stay inside this function:
+    // `watch` calls it mid-cycle, so a thrown error would abort the rest of that
+    // cycle — the limits report included — on every tick the registry is down.
+    let latest;
+    try {
+        const res = await fetch(`${REGISTRY}/${PACKAGE}/latest`, { signal: AbortSignal.timeout(15_000) });
+        if (!res.ok) {
+            if (force) {
+                log(`update: registry has no release info (${res.status}).`);
+            }
+            return null;
+        }
+        latest = (await res.json()).version;
+    }
+    catch (error) {
+        if (force) {
+            log(`update: cannot reach the npm registry (${error.message}).`);
+        }
+        return null;
+    }
+    if (!latest || !VERSION.test(latest)) {
+        return null;
+    }
+    if (latest === RELEASE_VERSION) {
+        if (force) {
+            log(`update: already on ${RELEASE_VERSION}.`);
+        }
+        return null;
+    }
+    log(`update: ${RELEASE_VERSION} → ${latest}, installing ${PACKAGE}…`);
+    const code = await run(npmCommand(), ['install', '--global', `${PACKAGE}@${latest}`]);
+    if (code !== 0) {
+        log(code === null
+            ? 'update: npm is not available — reinstall with `npm i -g @usagefleet/cli`.'
+            : `update: npm install failed (exit ${code}) — if the global prefix needs root, run it yourself.`);
+        return null;
+    }
+    // Detached: `install` rewrites the service definition and restarts it, which
+    // kills this process tree. npm replaced the file behind `self`, so this is
+    // already the new version.
+    spawn(process.execPath, [self, 'install'], { detached: true, stdio: 'ignore' }).unref();
+    log(`update: installed ${latest}, restarting service.`);
+    return latest;
+}

package/dist/uploader.js

@@ -0,0 +1,93 @@
+const MAX_ATTEMPTS = 6;
+const REQUEST_TIMEOUT_MS = 15_000;
+function sleep(ms) {
+    return new Promise(resolve => {
+        setTimeout(resolve, ms);
+    });
+}
+/**
+ * POST a batch with exponential backoff + jitter. Returns ok on 2xx, otherwise a
+ * classified failure so the caller advances or retains the file offset correctly.
+ */
+export async function uploadBatch(payload, cfg) {
+    let delay = 1000;
+    for (let attempt = 0; attempt <= MAX_ATTEMPTS; attempt++) {
+        let res = null;
+        try {
+            res = await fetch(`${cfg.endpoint}/api/v1/usage`, {
+                body: JSON.stringify(payload),
+                headers: {
+                    'content-type': 'application/json',
+                    'x-api-key': cfg.token,
+                },
+                method: 'POST',
+                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            });
+        }
+        catch {
+            res = null; // network error / timeout → retry
+        }
+        if (res && res.ok) {
+            const body = (await res.json().catch(() => ({})));
+            return { ok: true, ...body };
+        }
+        // Non-retryable 4xx (except 429): no amount of retrying inside this cycle
+        // changes the answer, so classify and hand it back to the caller now.
+        if (res && res.status >= 400 && res.status < 500 && res.status !== 429) {
+            return { fatal: classifyClientError(res.status), ok: false };
+        }
+        const fallback = Math.min(delay, 60_000) + Math.floor(Math.random() * 500);
+        if (attempt < MAX_ATTEMPTS) {
+            await sleep(retryAfterMs(res?.headers.get('retry-after'), fallback));
+        }
+        delay *= 2;
+    }
+    return { fatal: 'transient', ok: false };
+}
+/** Map a 4xx (never 429, the caller filters it) to a failure kind. */
+function classifyClientError(status) {
+    if (status === 401 || status === 403) {
+        return 'auth';
+    }
+    if (status === 400 || status === 422) {
+        return 'invalid';
+    }
+    return 'transient'; // 402 outside plan, 404, 408, 413, … — the data is fine
+}
+/** Parse a Retry-After header (delta-seconds OR HTTP-date), clamped to [0, 60s]. */
+function retryAfterMs(header, fallback) {
+    if (!header) {
+        return fallback;
+    }
+    let wait;
+    const secs = Number(header);
+    if (Number.isFinite(secs)) {
+        wait = secs * 1000;
+    }
+    else {
+        const when = Date.parse(header);
+        if (!Number.isFinite(when)) {
+            return fallback;
+        }
+        wait = when - Date.now();
+    }
+    return Math.min(Math.max(wait, 0), 60_000) + Math.floor(Math.random() * 500);
+}
+/** Report the account's real limit utilization to the server. */
+export async function postLimits(report, cfg) {
+    try {
+        const res = await fetch(`${cfg.endpoint}/api/v1/limits`, {
+            body: JSON.stringify(report),
+            headers: {
+                'content-type': 'application/json',
+                'x-api-key': cfg.token,
+            },
+            method: 'POST',
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+	"name": "@usagefleet/cli",
+	"version": "1.2.59",
+	"description": "Tails Claude Code, Claude Desktop, and pi agent JSONL logs and reports token usage to a UsageFleet server.",
+	"keywords": [
+		"claude",
+		"claude-code",
+		"telemetry",
+		"tokens",
+		"usage"
+	],
+	"homepage": "https://usagefleet.com",
+	"license": "MIT",
+	"bin": {
+		"usagefleet": "dist/index.js"
+	},
+	"files": [
+		"dist"
+	],
+	"type": "module",
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "tsc",
+		"dev": "bun run src/index.ts",
+		"start": "node dist/index.js",
+		"test": "vitest run",
+		"prepublishOnly": "npm run build"
+	},
+	"devDependencies": {
+		"@types/node": "^24",
+		"typescript": "^7",
+		"vitest": "^4"
+	},
+	"engines": {
+		"node": ">=20"
+	}
+}