@phnx-labs/agents-cli 1.20.33 → 1.20.35

package/dist/lib/usage.js

@@ -33,6 +33,7 @@ const CLAUDE_SCOPES = [
 const CLAUDE_KEYCHAIN_SERVICE = 'Claude Code-credentials';
 const getClaudeUsageCachePath = () => path.join(getCacheDir(), 'claude-usage.json');
 const CACHED_CLAUDE_USAGE_SOURCE_LABEL = 'last seen live account data';
+const KIMI_USAGES_URL = 'https://api.kimi.com/coding/v1/usages';
 const COMPACT_BAR_LEN = 5;
 const USAGE_BAR_LEN = 10;
 const FULL = '\u2588';
@@ -44,6 +45,8 @@ export async function getUsageInfo(agentId, options) {
             return getClaudeUsageInfo(options);
         case 'codex':
             return getCodexUsageInfo(options);
+        case 'kimi':
+            return getKimiUsageInfo(options);
         default:
             return { snapshot: null, error: null };
     }
@@ -114,8 +117,14 @@ const inFlightRefreshes = new Map();
  */
 export async function getUsageInfoForIdentity(input) {
     const usageKey = getUsageLookupKey(input.info);
-    // Non-Claude or no identity: legacy path, blocking fetch.
-    if (input.agentId !== 'claude' || !usageKey) {
+    // Agents whose usage comes from a live network call (Claude, Kimi) go through
+    // the stale-while-revalidate cache below so `agents run`/`agents view` stay off
+    // the network on the hot path. Everything else (Codex reads local session
+    // logs) takes the legacy blocking path. The on-disk cache is shared and keyed
+    // by usageKey, which is namespaced per agent (`claude:org=…`, `kimi:user=…`),
+    // so one cache file holds every account without collision.
+    const usesNetworkUsage = input.agentId === 'claude' || input.agentId === 'kimi';
+    if (!usesNetworkUsage || !usageKey) {
         return getUsageInfo(input.agentId, {
             home: input.home,
             cliVersion: input.cliVersion,
@@ -356,6 +365,152 @@ async function getClaudeUsageInfo(options) {
         return { snapshot: null, error: 'Usage data unavailable right now.' };
     }
 }
+/**
+ * Resolve Kimi's OAuth credential file. Sign-in is account-global but each
+ * installed version has an isolated home; the file physically lives only in the
+ * home the user logged in under. Check the per-version home first, then the
+ * active location under the real HOME — mirrors resolveAccountCredentialPath in
+ * agents.ts so every version reflects the true account state.
+ */
+function resolveKimiCredentialPath(home) {
+    const rel = ['.kimi-code', 'credentials', 'kimi-code.json'];
+    const perVersion = path.join(home || os.homedir(), ...rel);
+    try {
+        if (fs.existsSync(perVersion))
+            return perVersion;
+    }
+    catch { /* unreadable */ }
+    const active = path.join(process.env.AGENTS_REAL_HOME || os.homedir(), ...rel);
+    if (active !== perVersion) {
+        try {
+            if (fs.existsSync(active))
+                return active;
+        }
+        catch { /* unreadable */ }
+    }
+    return null;
+}
+/**
+ * Fetch Kimi usage via the Kimi Code /usages API. Kimi's JWT has no email
+ * claim, so the account row can't show an address — but /usages returns quota
+ * windows and the membership tier, which is what we render.
+ *
+ * Deliberately NO token refresh: `agents view` is a read/inspect command and
+ * must not rotate the user's Kimi OAuth credential (rewriting the file,
+ * invalidating the old refresh token, racing a concurrently-running kimi CLI).
+ * The kimi CLI refreshes on its own launch; if the stored token is expired we
+ * skip the live fetch and let the SWR cache serve the last-seen snapshot.
+ */
+async function getKimiUsageInfo(options) {
+    try {
+        const credPath = resolveKimiCredentialPath(options?.home);
+        if (!credPath)
+            return { snapshot: null, error: null };
+        const cred = JSON.parse(fs.readFileSync(credPath, 'utf-8'));
+        const accessToken = cred?.access_token;
+        if (typeof accessToken !== 'string' || !accessToken) {
+            return { snapshot: null, error: null };
+        }
+        const expiresAt = typeof cred?.expires_at === 'number' ? cred.expires_at : null;
+        if (expiresAt !== null && Date.now() / 1000 >= expiresAt) {
+            return { snapshot: null, error: null };
+        }
+        const response = await fetch(KIMI_USAGES_URL, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                Accept: 'application/json',
+            },
+            signal: AbortSignal.timeout(5000),
+        });
+        // 401/403/404 => expired token or no Kimi For Coding subscription; render
+        // nothing rather than a misleading empty bar.
+        if (!response.ok) {
+            return { snapshot: null, error: null };
+        }
+        const data = await response.json();
+        const windows = normalizeKimiWindows(data);
+        if (windows.length === 0) {
+            return { snapshot: null, error: null };
+        }
+        return {
+            snapshot: {
+                source: 'live',
+                sourceLabel: 'live account data',
+                capturedAt: new Date(),
+                windows,
+                plan: formatKimiPlan(data),
+            },
+            error: null,
+        };
+    }
+    catch {
+        return { snapshot: null, error: null };
+    }
+}
+/** Normalize the Kimi /usages payload into the common UsageWindow shape. */
+export function normalizeKimiWindows(data) {
+    const windows = [];
+    // Per-window rate limit (e.g. a 300-minute bucket) -> "session".
+    const shortLimit = Array.isArray(data.limits)
+        ? data.limits.find((entry) => entry?.detail)
+        : null;
+    const session = normalizeKimiWindow(shortLimit?.detail, 'session', 'Current session', 'S', kimiWindowMinutes(shortLimit?.window));
+    if (session)
+        windows.push(session);
+    // Rolling account quota -> "week".
+    const period = normalizeKimiWindow(data.usage, 'week', 'Current period', 'W', null);
+    if (period)
+        windows.push(period);
+    return windows;
+}
+/** Normalize a single Kimi quota bucket (used/limit strings) into a UsageWindow. */
+function normalizeKimiWindow(quota, key, label, shortLabel, windowMinutes) {
+    const limit = kimiNumber(quota?.limit);
+    const used = kimiNumber(quota?.used);
+    if (limit === null || used === null || limit <= 0)
+        return null;
+    const usedPercent = normalizePercent((used / limit) * 100);
+    if (usedPercent === null)
+        return null;
+    return {
+        key,
+        label,
+        shortLabel,
+        usedPercent,
+        resetsAt: parseDateValue(quota?.resetTime),
+        windowMinutes: windowMinutes ?? inferWindowMinutes(key),
+    };
+}
+/** Parse a numeric field that Kimi serializes as a string (e.g. "100"). */
+function kimiNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && value.trim() !== '' && !Number.isNaN(Number(value))) {
+        return Number(value);
+    }
+    return null;
+}
+/** Convert a Kimi limit window (duration + timeUnit enum) to minutes. */
+function kimiWindowMinutes(window) {
+    const duration = typeof window?.duration === 'number' ? window.duration : null;
+    if (duration === null || duration <= 0)
+        return null;
+    switch (window?.timeUnit) {
+        case 'TIME_UNIT_HOUR': return duration * 60;
+        case 'TIME_UNIT_SECOND': return duration / 60;
+        default: return duration; // TIME_UNIT_MINUTE or unknown -> minutes
+    }
+}
+/** Derive a display plan label from Kimi's membership tier or subscription type. */
+export function formatKimiPlan(data) {
+    const level = data.user?.membership?.level;
+    const raw = (typeof level === 'string' && level) || (typeof data.subType === 'string' && data.subType) || '';
+    const tail = raw.split('_').pop() || ''; // LEVEL_INTERMEDIATE -> INTERMEDIATE
+    if (!tail)
+        return null;
+    return tail.charAt(0).toUpperCase() + tail.slice(1).toLowerCase();
+}
 /** Collect Codex JSONL session files sorted newest-first. */
 function collectCodexSessionFiles(home) {
     const base = home || os.homedir();
@@ -590,6 +745,7 @@ function writeClaudeUsageCacheFile(cache, cachePath) {
 function serializeClaudeUsageSnapshot(snapshot) {
     return {
         capturedAt: snapshot.capturedAt?.toISOString() || null,
+        plan: snapshot.plan ?? null,
         windows: snapshot.windows.map((window) => ({
             key: window.key,
             label: window.label,
@@ -626,6 +782,7 @@ function deserializeClaudeUsageSnapshot(snapshot, now) {
         sourceLabel: CACHED_CLAUDE_USAGE_SOURCE_LABEL,
         capturedAt,
         windows,
+        plan: snapshot.plan ?? null,
     };
 }
 /** Check whether a cached usage window is still relevant (not expired or reset). */

package/dist/lib/versions.d.ts

@@ -337,9 +337,13 @@ export declare function listRepoNames(): string[];
  * sync path uses. Passing the result as an explicit `selection` means the sync
  * touches only that repo's resources — no orphan-sweep of the other layers.
  *
- * `memory` is set to `[]` (not omitted): that empty-array sentinel is what
- * `syncResourcesToVersion`'s `skipMemory` gate keys on to leave the memory
- * file untouched — it's a merge of all layers, not a per-repo artifact.
+ * `memory` is set to `'all'`, NOT `[]`: the composed rules-memory file is a
+ * merge of ALL layers, so scoping the sync to a single repo must still
+ * recompile it in the same pass (RUSH-1354). Leaving it out — or using the
+ * `[]` skip-sentinel — silently strands the memory file at its old content
+ * whenever a repo-scoped sync runs after a rules change. `'all'` makes
+ * `syncResourcesToVersion` recompose from every layer via the active preset,
+ * exactly as an unscoped full reconcile does.
  */
 export declare function buildRepoScopedSelection(repo: string, cwd?: string): ResourceSelection;
 /**

package/dist/lib/versions.js

@@ -1692,9 +1692,13 @@ function resourceSourceMap(kind, cwd, available) {
  * sync path uses. Passing the result as an explicit `selection` means the sync
  * touches only that repo's resources — no orphan-sweep of the other layers.
  *
- * `memory` is set to `[]` (not omitted): that empty-array sentinel is what
- * `syncResourcesToVersion`'s `skipMemory` gate keys on to leave the memory
- * file untouched — it's a merge of all layers, not a per-repo artifact.
+ * `memory` is set to `'all'`, NOT `[]`: the composed rules-memory file is a
+ * merge of ALL layers, so scoping the sync to a single repo must still
+ * recompile it in the same pass (RUSH-1354). Leaving it out — or using the
+ * `[]` skip-sentinel — silently strands the memory file at its old content
+ * whenever a repo-scoped sync runs after a rules change. `'all'` makes
+ * `syncResourcesToVersion` recompose from every layer via the active preset,
+ * exactly as an unscoped full reconcile does.
  */
 export function buildRepoScopedSelection(repo, cwd = process.cwd()) {
     const patterns = [`${repo}:*`];
@@ -1706,8 +1710,9 @@ export function buildRepoScopedSelection(repo, cwd = process.cwd()) {
         if (names.length > 0)
             selection[kind] = names;
     }
-    // Empty-array sentinel → skip the memory writer (see skipMemory below).
-    selection.memory = [];
+    // Recompile the memory file from all layers even under a repo scope — it is
+    // composed, not a per-repo artifact (see skipMemory below and RUSH-1354).
+    selection.memory = 'all';
     return selection;
 }
 /**

package/dist/lib/whats-new.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Render a compact "What's new" summary from a CHANGELOG.md body: one bullet
+ * per feature/fix heading (the `**...**` lines) for each version in the range
+ * the user actually moved through, `(fromVersion, toVersion]`. The verbose
+ * sub-bullets are intentionally dropped — the full notes live in the changelog.
+ *
+ * Returns colored lines ready to print, empty when nothing is in range.
+ */
+export declare function renderWhatsNew(changelog: string, fromVersion: string, toVersion: string): string[];

package/dist/lib/whats-new.js

@@ -0,0 +1,35 @@
+import chalk from 'chalk';
+import { compareVersions } from './agent-spec/primitives.js';
+/**
+ * Render a compact "What's new" summary from a CHANGELOG.md body: one bullet
+ * per feature/fix heading (the `**...**` lines) for each version in the range
+ * the user actually moved through, `(fromVersion, toVersion]`. The verbose
+ * sub-bullets are intentionally dropped — the full notes live in the changelog.
+ *
+ * Returns colored lines ready to print, empty when nothing is in range.
+ */
+export function renderWhatsNew(changelog, fromVersion, toVersion) {
+    const out = [];
+    let inRelevantSection = false;
+    for (const line of changelog.split('\n')) {
+        const versionMatch = line.match(/^## (\d+\.\d+\.\d+)/);
+        if (versionMatch) {
+            const currentVersion = versionMatch[1];
+            // Bounding the top end matters when upgrading to a specific older
+            // version, and guards against a changelog that lists unreleased entries.
+            inRelevantSection =
+                compareVersions(currentVersion, fromVersion) > 0 &&
+                    compareVersions(currentVersion, toVersion) <= 0;
+            if (inRelevantSection) {
+                out.push('');
+                out.push(chalk.bold(`v${currentVersion}`));
+            }
+            continue;
+        }
+        // Only the bold headings — one bullet per feature/fix.
+        if (inRelevantSection && line.startsWith('**') && line.endsWith('**')) {
+            out.push(`  ${chalk.cyan('•')} ${line.replace(/\*\*/g, '')}`);
+        }
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.33",
+  "version": "1.20.35",
   "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",