@usagefleet/cli 1.2.59

package/dist/parser.js

@@ -0,0 +1,126 @@
+/** Only accept genuine strings; ignores numbers/objects that would later break. */
+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). */
+function validTimestamp(v) {
+    if (typeof v === 'string' && !Number.isNaN(new Date(v).getTime())) {
+        return v;
+    }
+    return new Date().toISOString();
+}
+function cacheCreation(u) {
+    if (typeof u.cache_creation_input_tokens === 'number') {
+        return u.cache_creation_input_tokens;
+    }
+    const c = u.cache_creation;
+    if (c) {
+        return (c.ephemeral_5m_input_tokens ?? 0) + (c.ephemeral_1h_input_tokens ?? 0);
+    }
+    return 0;
+}
+/** pi agent session line: `{type:"message", id, timestamp, message:{role:"assistant",
+ *  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) {
+    if (o.type !== 'message') {
+        return null;
+    }
+    const m = o.message;
+    if (!m || m.role !== 'assistant' || m.provider !== 'anthropic') {
+        return null;
+    }
+    const u = m.usage;
+    if (typeof u !== 'object' || u === null) {
+        return null;
+    }
+    // Idempotency key: the Anthropic response id is globally unique; the line's own
+    // short id needs the timestamp to be collision-safe across sessions.
+    const rid = str(m.responseId);
+    const lid = str(o.id);
+    const uuid = rid ? `pi:${rid}` : lid ? `pi:${lid}:${validTimestamp(o.timestamp)}` : null;
+    if (!uuid) {
+        return null;
+    }
+    return {
+        cacheCreationTokens: u.cacheWrite ?? 0,
+        cacheReadTokens: u.cacheRead ?? 0,
+        cwd: null,
+        gitBranch: null,
+        inputTokens: u.input ?? 0,
+        messageId: rid,
+        model: str(m.model),
+        outputTokens: u.output ?? 0,
+        requestId: null,
+        serviceTier: null,
+        sessionId: null,
+        source: 'pi',
+        timestamp: validTimestamp(o.timestamp),
+        uuid,
+        version: null,
+    };
+}
+/**
+ * Parse a single JSONL line. Returns a UsageRecord only for assistant messages
+ * that carry a usage object; everything else (user/system/summary/tool/…) → null.
+ * `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.
+ */
+export function parseLine(line, source = 'cli') {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return null;
+    }
+    // JSON.parse is typed `any`, so a valid-JSON line that is not an object sails
+    // past the try/catch. A bare `null` line then throws on the first property
+    // access below, and that throw escapes tailFile and leaves the file's offset
+    // unadvanced forever, silently dropping every later record in it. Numbers,
+    // strings and arrays never threw (`(123).type` is just undefined); they are in
+    // the guard so the `as Record<string, unknown>` cast below is not a lie.
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        return null;
+    }
+    const o = parsed;
+    if (source === 'pi') {
+        return parsePiLine(o);
+    }
+    if (o.type !== 'assistant') {
+        return null;
+    }
+    const message = o.message;
+    if (!message || typeof message.usage !== 'object' || message.usage === null) {
+        return null;
+    }
+    const { uuid } = o;
+    if (typeof uuid !== 'string' || !uuid) {
+        return null;
+    }
+    const u = message.usage;
+    return {
+        cacheCreationTokens: cacheCreation(u),
+        cacheReadTokens: u.cache_read_input_tokens ?? 0,
+        cwd: str(o.cwd),
+        gitBranch: str(o.gitBranch),
+        inputTokens: u.input_tokens ?? 0,
+        messageId: str(message.id),
+        model: str(message.model),
+        outputTokens: u.output_tokens ?? 0,
+        requestId: str(o.requestId),
+        serviceTier: u.service_tier ?? null,
+        sessionId: str(o.sessionId),
+        source,
+        timestamp: validTimestamp(o.timestamp),
+        uuid,
+        version: str(o.version),
+    };
+}

package/dist/paths.js

@@ -0,0 +1,48 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export function defaultProjectsDir() {
+    return process.env.USAGEFLEET_PROJECTS ?? join(homedir(), '.claude', 'projects');
+}
+/** Claude Desktop's Electron userData dir, per-OS. Mirrors the app's own
+ *  `app.getPath("userData")` (= platform appData + the "Claude" product name),
+ *  verified against the installed app's main bundle. */
+function claudeDesktopUserData() {
+    if (process.platform === 'win32') {
+        const appData = process.env.APPDATA || join(homedir(), 'AppData', 'Roaming');
+        return join(appData, 'Claude');
+    }
+    if (process.platform === 'darwin') {
+        return join(homedir(), 'Library', 'Application Support', 'Claude');
+    }
+    // linux + other unix: respect XDG_CONFIG_HOME, else ~/.config
+    const xdg = process.env.XDG_CONFIG_HOME;
+    return join(xdg && xdg.length > 0 ? xdg : join(homedir(), '.config'), 'Claude');
+}
+/** Root under which Claude Desktop agent-mode (Cowork) sessions write their
+ *  Claude-Code-format JSONL usage logs. The actual logs live deeper, under
+ *  `<session>/.claude/projects/`; the collector filters to that subtree. */
+export function defaultDesktopSessionsDir() {
+    return join(claudeDesktopUserData(), 'local-agent-mode-sessions');
+}
+/** Roots under which the pi coding agent writes its per-project session JSONLs
+ *  (`<root>/<project>/<timestamp>_<uuid>.jsonl`). pi relocates them via
+ *  PI_CODING_AGENT_SESSION_DIR / PI_CODING_AGENT_DIR — but those live in the
+ *  user's shell, which a launchd/systemd service never inherits, so the default
+ *  is every plausible root at once (missing ones scan to nothing). */
+export function defaultPiSessionsDirs() {
+    const dirs = [join(homedir(), '.pi', 'agent', 'sessions')];
+    const session = process.env.PI_CODING_AGENT_SESSION_DIR;
+    const agent = process.env.PI_CODING_AGENT_DIR;
+    if (session) {
+        dirs.push(session);
+    }
+    if (agent) {
+        dirs.push(join(agent, 'sessions'));
+    }
+    return [...new Set(dirs)];
+}
+/** Claude Code's user settings file, where the prompt guard hook is registered.
+ *  CLAUDE_CONFIG_DIR is Claude Code's own relocation knob. */
+export function claudeSettingsPath() {
+    return join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'), 'settings.json');
+}

package/dist/release.js

@@ -0,0 +1,8 @@
+// Overwritten by .github/workflows/release.yml with the version being published
+// to npm. "dev" means "built locally", which disables self-update — a dev build
+// must never be replaced by a published one behind your back.
+// The annotation is load-bearing: without it the literal type would be 'dev'
+// here and '1.2.3' in CI, so every `=== '1.2.59'` check compiles locally and
+// fails the release build as a comparison with no overlap.
+// oxlint-disable-next-line typescript/no-inferrable-types -- see above
+export const RELEASE_VERSION = '1.2.59';

package/dist/scanner.js

@@ -0,0 +1,24 @@
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+/** Recursively list all *.jsonl files under a directory. Returns [] if the
+ *  directory is missing. */
+export function listJsonlFiles(dir) {
+    const out = [];
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        const full = join(dir, e.name);
+        if (e.isDirectory()) {
+            out.push(...listJsonlFiles(full));
+        }
+        else if (e.isFile() && e.name.endsWith('.jsonl')) {
+            out.push(full);
+        }
+    }
+    return out;
+}