@phnx-labs/agents-cli 1.22.21 → 1.22.23

package/dist/lib/usage.js

@@ -139,6 +139,7 @@ const USAGE_SOURCES = {
     grok: { fetch: getGrokUsageInfo, network: false },
     cursor: { fetch: getCursorUsageInfo, network: true },
     antigravity: { fetch: getAntigravityUsageInfo, network: true },
+    muse: { fetch: getMuseUsageInfo, network: true },
 };
 export const USAGE_SOURCE_AGENT_IDS = Object.keys(USAGE_SOURCES);
 function getUsageSource(agentId) {
@@ -605,7 +606,34 @@ export function formatUsageSection(usage) {
 /** Fetch Codex usage by scanning the most recent session files for rate-limit events. */
 async function getCodexUsageInfo(options) {
     try {
-        const files = collectCodexSessionFiles(options?.home);
+        // Codex usage is read from on-disk session transcripts, which carry no
+        // account identity and are not removed on logout. To keep the bar scoped to
+        // the account signed in NOW, floor the scan at the current login time: the
+        // id_token's `auth_time` claim — the OIDC time-of-authentication. A session
+        // written before that login belongs to whoever was signed in before (e.g.
+        // after `codex logout` + login into a different account), and showing its
+        // rate_limits is the "wrong usage after switch" bug.
+        //
+        // `auth_time` — not the auth.json file mtime — is the correct floor: Codex
+        // rewrites auth.json on every token refresh (advancing its mtime), but a
+        // refresh_token grant does not re-authenticate the user, so `auth_time`
+        // stays at the real login. Flooring on mtime would blank the bar after each
+        // background refresh; flooring on `auth_time` does not. No readable
+        // credential means the version is signed out — report no usage. A credential
+        // that carries no `auth_time` falls back to no floor (prior behavior) rather
+        // than hide a signed-in account's usage.
+        const base = options?.home || os.homedir();
+        let sinceMs;
+        try {
+            const tokens = JSON.parse(fs.readFileSync(path.join(base, '.codex', 'auth.json'), 'utf-8')).tokens;
+            const authTime = decodeJwtPayload(tokens?.id_token || tokens?.access_token || '')?.auth_time;
+            if (typeof authTime === 'number' && authTime > 0)
+                sinceMs = authTime * 1000;
+        }
+        catch {
+            return { snapshot: null, error: null };
+        }
+        const files = collectCodexSessionFiles(options?.home, sinceMs);
         for (const filePath of files) {
             const match = await readLatestCodexRateLimits(filePath);
             if (!match)
@@ -1099,8 +1127,15 @@ function normalizeDroidWindow(window, key, label, shortLabel) {
         windowMinutes: inferWindowMinutes(key),
     };
 }
-/** Collect Codex JSONL session files sorted newest-first. */
-function collectCodexSessionFiles(home) {
+/**
+ * Collect Codex JSONL session files sorted newest-first.
+ *
+ * `sinceMs` drops files modified before it. Codex session transcripts are not
+ * tagged with the account that wrote them, so this mtime floor is how usage is
+ * kept account-scoped: a session older than the current login belongs to a
+ * prior account (see {@link getCodexUsageInfo}).
+ */
+function collectCodexSessionFiles(home, sinceMs) {
     const base = home || os.homedir();
     const dir = path.join(base, '.codex', 'sessions');
     if (!fs.existsSync(dir))
@@ -1115,6 +1150,8 @@ function collectCodexSessionFiles(home) {
         const stat = safeStatSync(filePath);
         if (!stat)
             continue;
+        if (sinceMs !== undefined && stat.mtimeMs < sinceMs)
+            continue;
         files.push({ path: filePath, mtime: stat.mtimeMs });
     }
     files.sort((a, b) => b.mtime - a.mtime);
@@ -1837,6 +1874,220 @@ async function getGrokUsageInfo(options) {
         return { snapshot: null, error: null };
     }
 }
+/**
+ * Muse Code usage.
+ *
+ * Prefer live Meta Model API rate-limit headers when a key is available
+ * (META_API_KEY / MODEL_API_KEY / ~/.config/muse/auth.json). Fall back to
+ * aggregating `model_completed.usage` from local session.jsonl logs under
+ * ~/.local/share/muse/sessions for a last-7-days token window.
+ */
+async function getMuseUsageInfo(options) {
+    try {
+        const base = options?.home || os.homedir();
+        const live = await probeMuseRateLimits(base);
+        if (live)
+            return { snapshot: live, error: null };
+        const local = await readMuseLocalSessionUsage(base);
+        if (!local)
+            return { snapshot: null, error: null };
+        return { snapshot: local, error: null };
+    }
+    catch {
+        return { snapshot: null, error: null };
+    }
+}
+/** Resolve a Muse API key from env or auth.json without logging the value. */
+function resolveMuseApiKey(base) {
+    const envKey = process.env.META_API_KEY?.trim() || process.env.MODEL_API_KEY?.trim();
+    if (envKey)
+        return envKey;
+    const authPath = path.join(base, '.config', 'muse', 'auth.json');
+    try {
+        if (!fs.existsSync(authPath))
+            return null;
+        const data = JSON.parse(fs.readFileSync(authPath, 'utf-8'));
+        if (typeof data.access_token === 'string' && data.access_token)
+            return data.access_token;
+        if (typeof data.api_key === 'string' && data.api_key)
+            return data.api_key;
+        for (const slot of Object.values(data)) {
+            if (!slot || typeof slot !== 'object' || Array.isArray(slot))
+                continue;
+            const entry = slot;
+            if (typeof entry.access_token === 'string' && entry.access_token)
+                return entry.access_token;
+            if (typeof entry.api_key === 'string' && entry.api_key)
+                return entry.api_key;
+        }
+    }
+    catch {
+        /* unreadable auth */
+    }
+    return null;
+}
+/**
+ * Probe Meta Model API for rate-limit headers. Uses GET /v1/models (no token
+ * spend). Returns null when unauthenticated or the headers are absent.
+ */
+async function probeMuseRateLimits(base) {
+    if (usageRateLimitedUntil('muse'))
+        return null;
+    const key = resolveMuseApiKey(base);
+    if (!key)
+        return null;
+    try {
+        const response = await fetch('https://api.meta.ai/v1/models', {
+            headers: { Authorization: `Bearer ${key}` },
+            signal: AbortSignal.timeout(8_000),
+        });
+        if (response.status === 429) {
+            noteUsageRateLimited('muse', response.headers.get('retry-after'));
+            return null;
+        }
+        if (!response.ok)
+            return null;
+        const limitTokens = headerNumber(response.headers, 'x-ratelimit-limit-tokens');
+        const remainingTokens = headerNumber(response.headers, 'x-ratelimit-remaining-tokens');
+        const limitRequests = headerNumber(response.headers, 'x-ratelimit-limit-requests');
+        const remainingRequests = headerNumber(response.headers, 'x-ratelimit-remaining-requests');
+        const windows = [];
+        if (limitTokens !== null && remainingTokens !== null && limitTokens > 0) {
+            const used = Math.max(0, Math.min(100, ((limitTokens - remainingTokens) / limitTokens) * 100));
+            windows.push({
+                key: 'session',
+                label: 'Tokens (current window)',
+                shortLabel: 'Tok',
+                usedPercent: used,
+                resetsAt: null,
+                windowMinutes: 1,
+            });
+        }
+        if (limitRequests !== null && remainingRequests !== null && limitRequests > 0) {
+            const used = Math.max(0, Math.min(100, ((limitRequests - remainingRequests) / limitRequests) * 100));
+            windows.push({
+                key: 'session',
+                label: 'Requests (current window)',
+                shortLabel: 'Req',
+                usedPercent: used,
+                resetsAt: null,
+                windowMinutes: 1,
+            });
+        }
+        if (windows.length === 0)
+            return null;
+        return {
+            source: 'live',
+            sourceLabel: 'Meta Model API rate limits',
+            capturedAt: new Date(),
+            windows,
+            plan: 'Meta Model API',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function headerNumber(headers, name) {
+    const raw = headers.get(name);
+    if (raw === null || raw === '')
+        return null;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : null;
+}
+/**
+ * Aggregate Muse session token usage from local session.jsonl files for the
+ * last 7 days. Scales the bar against 10M tokens (soft visibility scale — Meta
+ * is pay-as-you-go with no hard local cap).
+ */
+async function readMuseLocalSessionUsage(base) {
+    const root = path.join(base, '.local', 'share', 'muse', 'sessions');
+    if (!fs.existsSync(root))
+        return null;
+    const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cachedTokens = 0;
+    let latestAt = null;
+    let files = 0;
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            const full = path.join(dir, ent.name);
+            if (ent.isDirectory()) {
+                walk(full);
+                continue;
+            }
+            if (ent.name !== 'session.jsonl')
+                continue;
+            try {
+                const st = fs.statSync(full);
+                if (st.mtimeMs < cutoff)
+                    continue;
+                files++;
+                if (!latestAt || st.mtime > latestAt)
+                    latestAt = st.mtime;
+                const content = fs.readFileSync(full, 'utf-8');
+                for (const line of content.split('\n')) {
+                    if (!line.trim())
+                        continue;
+                    let raw;
+                    try {
+                        raw = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const event = raw?.payload?.event ?? raw?.payload;
+                    if (!event || event.kind !== 'model_completed')
+                        continue;
+                    const usage = event.usage;
+                    if (!usage || typeof usage !== 'object')
+                        continue;
+                    if (typeof usage.input_tokens === 'number')
+                        inputTokens += usage.input_tokens;
+                    if (typeof usage.output_tokens === 'number')
+                        outputTokens += usage.output_tokens;
+                    if (typeof usage.cached_tokens === 'number')
+                        cachedTokens += usage.cached_tokens;
+                }
+            }
+            catch {
+                /* skip unreadable session */
+            }
+        }
+    };
+    walk(root);
+    const total = inputTokens + outputTokens + cachedTokens;
+    if (total === 0 && files === 0)
+        return null;
+    // Soft 10M-token scale for the bar (pay-as-you-go has no hard local cap).
+    const softCap = 10_000_000;
+    const usedPercent = Math.max(0, Math.min(100, (total / softCap) * 100));
+    const formatK = (n) => n >= 1_000_000 ? `${(n / 1_000_000).toFixed(1)}M` : n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
+    return {
+        source: 'last_seen',
+        sourceLabel: `local Muse sessions · ${formatK(total)} tokens (7d)`,
+        capturedAt: latestAt,
+        windows: [
+            {
+                key: 'week',
+                label: 'Local tokens (7d)',
+                shortLabel: '7d',
+                usedPercent,
+                resetsAt: null,
+                windowMinutes: 7 * 24 * 60,
+            },
+        ],
+        plan: 'Meta Model API',
+    };
+}
 async function readLatestGrokBilling(filePath) {
     return new Promise((resolve) => {
         let latest = null;

package/dist/lib/versions.js

@@ -917,6 +917,17 @@ export function getBinaryPath(agent, version) {
             ? path.join(getHomeDir(), 'bin', 'droid.exe')
             : path.join(getHomeDir(), '.local', 'bin', 'droid');
     }
+    if (agent === 'muse') {
+        // Muse Code install script drops a self-updating launcher at
+        // ~/.local/bin/muse (curl -fsSL https://dev.meta.ai/install.sh | sh).
+        // Same global-binary shape as droid: one binary for every version dir,
+        // config isolation via version-home HOME rewrite. Mirror the shim's
+        // `muse` branch so isVersionInstalled / agents view / agents import
+        // agree with what executes.
+        return IS_WINDOWS
+            ? path.join(getHomeDir(), 'bin', 'muse.exe')
+            : path.join(getHomeDir(), '.local', 'bin', 'muse');
+    }
     const versionDir = getVersionDir(agent, version);
     return path.join(versionDir, 'node_modules', '.bin', agentConfig.cliCommand);
 }
@@ -1521,14 +1532,14 @@ export async function installVersion(agent, version, onProgress, opts) {
         // ~/.local/bin (or similar) rather than the version's node_modules/.bin.
         //
         // Agents whose binary is special-cased in getBinaryPath (grok ->
-        // ~/.grok/downloads, droid -> ~/.local/bin/droid) need no symlink — and
+        // ~/.grok/downloads, droid/muse -> ~/.local/bin/<cli>) need no symlink — and
         // creating one is actively harmful: `which <cli>` can resolve to OUR OWN
         // dispatcher shim, because ~/.agents/.cache/shims sits ahead of ~/.local/bin
         // on PATH. Symlinking node_modules/.bin/<cli> at the shim makes the shim
         // exec itself forever. So we skip the resolver-backed agents here AND, for
         // everyone else, filter the shims dir out of the `which` candidates so the
         // same race can't bite a non-special-cased installScript agent.
-        if (agent !== 'grok' && agent !== 'droid') {
+        if (agent !== 'grok' && agent !== 'droid' && agent !== 'muse') {
             // findInPath is a pure-Node PATH scan that already skips our own shims
             // dir — so it returns the genuine install, never our dispatcher shim
             // (which sits ahead of ~/.local/bin on PATH and would otherwise be

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.21",
+  "version": "1.22.23",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",