@phnx-labs/agents-cli 1.20.63 → 1.20.64

package/dist/lib/sync-umbrella.d.ts

@@ -63,6 +63,7 @@ export interface UmbrellaResult {
         pushed: number;
         pulled: number;
         merged: number;
+        error?: string;
     };
     devices?: {
         synced: number;

package/dist/lib/sync-umbrella.js

@@ -118,9 +118,20 @@ export async function runUmbrellaSync(args) {
         const { isSyncConfigured } = await import('./session/sync/config.js');
         if (isBetaEnabled('session-sync') && isSyncConfigured()) {
             const { syncSessions } = await import('./session/sync/sync.js');
-            const r = await syncSessions();
-            result.sessions = { ran: true, pushed: r.pushed, pulled: r.pulled, merged: r.merged };
-            log(`sessions: pushed ${r.pushed}, pulled ${r.pulled}, merged ${r.merged}`);
+            // Record a failure here instead of letting it throw: like the fetchSecrets
+            // block above, a failure in one fetch stage must not abort the others or
+            // the reconcile below (see this function's doc comment). Without this,
+            // syncSessions() throwing — e.g. via the C1 containment reject on a
+            // malicious peer manifest — would skip `plan.reconcile` entirely.
+            try {
+                const r = await syncSessions();
+                result.sessions = { ran: true, pushed: r.pushed, pulled: r.pulled, merged: r.merged };
+                log(`sessions: pushed ${r.pushed}, pulled ${r.pulled}, merged ${r.merged}`);
+            }
+            catch (err) {
+                result.sessions = { ran: false, pushed: 0, pulled: 0, merged: 0, error: err.message };
+                log(`sessions: failed — ${err.message}`);
+            }
         }
         else {
             result.sessions = { ran: false, pushed: 0, pulled: 0, merged: 0 };

package/dist/lib/types.d.ts

@@ -624,6 +624,15 @@ export interface ExtraRepoConfig {
 export interface Meta {
     agents?: Partial<Record<AgentId, string>>;
     run?: RunConfig;
+    /**
+     * `agents run --lease` config. `secretsBundle` names the keychain secrets bundle
+     * whose provider token (e.g. `HCLOUD_TOKEN`) crabbox uses to reach the cloud API.
+     * When unset, the bundle is resolved by env (`AGENTS_LEASE_SECRETS_BUNDLE`) then
+     * auto-detected (the first bundle that declares a provider token key).
+     */
+    lease?: {
+        secretsBundle?: string;
+    };
     /** macOS secrets-agent config. `policy` is the default prompt policy for
      * bundles without an explicit per-bundle policy: `daily` (the default) asks
      * once per ~7 days, `always` asks every time. `auto` (default on) lets the

package/dist/lib/usage.d.ts

@@ -1,7 +1,7 @@
-import type { AccountInfo } from './agents.js';
+import { type AccountInfo } from './agents.js';
 import type { AgentId } from './types.js';
 /** Discriminator for usage window types. */
-export type UsageWindowKey = 'session' | 'week' | 'sonnet_week';
+export type UsageWindowKey = 'session' | 'week' | 'sonnet_week' | 'month';
 /** A single rate-limit window with utilization percentage and reset time. */
 export interface UsageWindow {
     key: UsageWindowKey;
@@ -154,7 +154,46 @@ export interface KimiUsagesResponse {
 export declare function normalizeKimiWindows(data: KimiUsagesResponse): UsageWindow[];
 /** Derive a display plan label from Kimi's membership tier or subscription type. */
 export declare function formatKimiPlan(data: KimiUsagesResponse): string | null;
-/** Load Claude OAuth credentials from the system keychain/keyring. */
+/** A single Droid token-rate-limit window from /api/billing/limits. */
+interface DroidLimitWindow {
+    usedPercent?: number | null;
+    windowEnd?: string | null;
+}
+/** Response shape from Factory's billing limits endpoint (subset we render). */
+export interface DroidBillingLimitsResponse {
+    usesTokenRateLimitsBilling?: boolean | null;
+    limits?: {
+        standard?: {
+            fiveHour?: DroidLimitWindow | null;
+            weekly?: DroidLimitWindow | null;
+            monthly?: DroidLimitWindow | null;
+        } | null;
+    } | null;
+}
+/**
+ * Normalize the Factory billing-limits payload into the common UsageWindow
+ * shape. Orgs on the legacy (non token-rate-limit) billing model have no
+ * meaningful windows, so they render nothing — mirrors droid's own gate on
+ * `usesTokenRateLimitsBilling` before it reads `limits.standard`.
+ */
+export declare function normalizeDroidWindows(data: DroidBillingLimitsResponse): UsageWindow[];
+/**
+ * Load a version home's Claude OAuth credential from the two stores Claude Code
+ * uses, tried in order:
+ *
+ *  1. The OS keychain (`getKeychainToken`). Canonical on macOS — Claude Code
+ *     writes the token to the login keychain and we read it via `/usr/bin/security`.
+ *  2. `<home>/.claude/.credentials.json`. On a headless Linux box (the
+ *     `agents view --host <linux>` case) there is no reachable Secret Service, so
+ *     the Claude CLI stores its OAuth token in this plaintext file instead. The
+ *     keychain read above finds nothing on that platform, so we fall back to the
+ *     file. Same wrapped `{ claudeAiOauth }` shape, so one parser handles both.
+ *     Mirrors `readClaudeCredentialsBlob` (cloud/rush.ts), the proven pattern.
+ *
+ * Without step 2 the live usage fetch got no token on Linux, so `agents view`
+ * (run remotely over SSH by `--host`) rendered no usage bars even though the
+ * account + plan — read from the plaintext `.claude.json` — showed fine.
+ */
 export declare function loadClaudeOauth(home?: string): Promise<ClaudeOauthCredentials | null>;
 /**
  * Derive the Keychain service name for a Claude home directory.

package/dist/lib/usage.js

@@ -1,7 +1,8 @@
 /**
- * Usage and rate-limit tracking for Claude and Codex agents.
+ * Usage and rate-limit tracking for Claude, Codex, Kimi, and Droid agents.
  *
- * Fetches live usage data from the Anthropic OAuth API (Claude) or parses
+ * Fetches live usage data from each agent's usage API (Anthropic OAuth for
+ * Claude, Kimi Code /usages, Factory billing limits for Droid) or parses
  * rate-limit events from Codex session logs. Results are normalized into a
  * common UsageSnapshot shape, cached to disk, and rendered as terminal
  * progress bars for the `agents view` command.
@@ -14,6 +15,7 @@ import * as path from 'path';
 import * as readline from 'readline';
 import { promisify } from 'util';
 import chalk from 'chalk';
+import { decodeJwtPayload, decryptDroidAuthPayload } from './agents.js';
 import { walkForFiles } from './fs-walk.js';
 import { getKeychainToken, setKeychainToken, deleteKeychainToken, } from './secrets/index.js';
 import { getCacheDir } from './state.js';
@@ -34,6 +36,7 @@ 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 DROID_USAGE_URL = 'https://api.factory.ai/api/billing/limits';
 const COMPACT_BAR_LEN = 5;
 const USAGE_BAR_LEN = 10;
 const FULL = '\u2588';
@@ -47,6 +50,8 @@ export async function getUsageInfo(agentId, options) {
             return getCodexUsageInfo(options);
         case 'kimi':
             return getKimiUsageInfo(options);
+        case 'droid':
+            return getDroidUsageInfo(options);
         default:
             return { snapshot: null, error: null };
     }
@@ -117,13 +122,14 @@ const inFlightRefreshes = new Map();
  */
 export async function getUsageInfoForIdentity(input) {
     const usageKey = getUsageLookupKey(input.info);
-    // 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';
+    // Agents whose usage comes from a live network call (Claude, Kimi, Droid) 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=…`, `droid:org=…`), so one cache file holds every account without
+    // collision.
+    const usesNetworkUsage = input.agentId === 'claude' || input.agentId === 'kimi' || input.agentId === 'droid';
     if (!usesNetworkUsage || !usageKey) {
         return getUsageInfo(input.agentId, {
             home: input.home,
@@ -201,8 +207,12 @@ export function formatUsageSummary(plan, snapshot, planWidth = 3) {
         parts.push(chalk.gray(plan.padEnd(planWidth)));
     }
     if (snapshot) {
+        // Compact rows show the two windows every agent shares (session + week);
+        // extra windows (Claude's Sonnet week, Droid's month) render only in the
+        // full per-version usage section. An exhausted month window still surfaces
+        // here as the rate-limited badge via deriveUsageStatusFromSnapshot.
         const windows = snapshot.windows
-            .filter((window) => window.key !== 'sonnet_week')
+            .filter((window) => window.key === 'session' || window.key === 'week')
             .map((window) => `${chalk.gray(`${window.shortLabel}:`)} ${renderCompactUsageBar(window.usedPercent)}`);
         if (windows.length > 0) {
             parts.push(windows.join(' '));
@@ -513,6 +523,95 @@ export function formatKimiPlan(data) {
         return null;
     return tail.charAt(0).toUpperCase() + tail.slice(1).toLowerCase();
 }
+/**
+ * Fetch Droid usage via Factory's billing limits API — the same endpoint the
+ * droid CLI polls for its token-limit banner. The WorkOS access token comes
+ * from the locally decrypted ~/.factory/auth.v2.file (the same credential
+ * account identity in agents.ts reads).
+ *
+ * Deliberately NO token refresh, for a sharper reason than Kimi's: WorkOS
+ * refresh tokens are single-use and rotate on every exchange, so refreshing
+ * here would race a concurrently running droid session and can permanently
+ * invalidate the user's login chain. Droid refreshes its own credential when
+ * it runs; if the stored token is expired we skip the live fetch and let the
+ * SWR cache serve the last-seen snapshot.
+ */
+async function getDroidUsageInfo(options) {
+    try {
+        const cred = decryptDroidAuthPayload(options?.home || os.homedir());
+        const accessToken = cred?.access_token;
+        if (typeof accessToken !== 'string' || !accessToken) {
+            return { snapshot: null, error: null };
+        }
+        const exp = decodeJwtPayload(accessToken)?.exp;
+        if (typeof exp === 'number' && Date.now() / 1000 >= exp) {
+            return { snapshot: null, error: null };
+        }
+        const response = await fetch(DROID_USAGE_URL, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                Accept: 'application/json',
+            },
+            signal: AbortSignal.timeout(5000),
+        });
+        // 401 => revoked/expired token; render nothing rather than a misleading
+        // empty bar.
+        if (!response.ok) {
+            return { snapshot: null, error: null };
+        }
+        const data = await response.json();
+        const windows = normalizeDroidWindows(data);
+        if (windows.length === 0) {
+            return { snapshot: null, error: null };
+        }
+        return {
+            snapshot: {
+                source: 'live',
+                sourceLabel: 'live account data',
+                capturedAt: new Date(),
+                windows,
+            },
+            error: null,
+        };
+    }
+    catch {
+        return { snapshot: null, error: null };
+    }
+}
+/**
+ * Normalize the Factory billing-limits payload into the common UsageWindow
+ * shape. Orgs on the legacy (non token-rate-limit) billing model have no
+ * meaningful windows, so they render nothing — mirrors droid's own gate on
+ * `usesTokenRateLimitsBilling` before it reads `limits.standard`.
+ */
+export function normalizeDroidWindows(data) {
+    if (data.usesTokenRateLimitsBilling !== true)
+        return [];
+    const standard = data.limits?.standard;
+    if (!standard)
+        return [];
+    const windows = [
+        normalizeDroidWindow(standard.fiveHour, 'session', 'Current session', 'S'),
+        normalizeDroidWindow(standard.weekly, 'week', 'Current week', 'W'),
+        normalizeDroidWindow(standard.monthly, 'month', 'Current month', 'M'),
+    ];
+    return windows.filter((window) => window !== null);
+}
+/** Normalize a single Droid billing-limits window. */
+function normalizeDroidWindow(window, key, label, shortLabel) {
+    const usedPercent = normalizePercent(window?.usedPercent);
+    if (usedPercent === null)
+        return null;
+    return {
+        key,
+        label,
+        shortLabel,
+        usedPercent,
+        resetsAt: parseDateValue(window?.windowEnd),
+        windowMinutes: inferWindowMinutes(key),
+    };
+}
 /** Collect Codex JSONL session files sorted newest-first. */
 function collectCodexSessionFiles(home) {
     const base = home || os.homedir();
@@ -609,19 +708,16 @@ function normalizeClaudeWindow(window, key, label, shortLabel) {
         windowMinutes: inferWindowMinutes(key),
     };
 }
-/** Load Claude OAuth credentials from the system keychain/keyring. */
-export async function loadClaudeOauth(home) {
-    // Windows not yet supported
-    if (process.platform !== 'darwin' && process.platform !== 'linux') {
-        return null;
-    }
+/**
+ * Parse a wrapped Claude OAuth payload — the `{ claudeAiOauth, organizationUuid }`
+ * shape written by BOTH the macOS Keychain item and the Linux `.credentials.json`
+ * file — into our credential struct. Returns null when there is no usable access
+ * token. Never throws (malformed JSON => null).
+ */
+function parseClaudeOauthPayload(raw) {
     try {
-        const service = getClaudeKeychainService(home);
-        const stdout = getKeychainToken(service);
-        const payload = JSON.parse(stdout.trim());
-        if (typeof payload?.claudeAiOauth?.accessToken !== 'string')
-            return null;
-        if (!payload.claudeAiOauth) {
+        const payload = JSON.parse(raw.trim());
+        if (!payload?.claudeAiOauth || typeof payload.claudeAiOauth.accessToken !== 'string') {
             return null;
         }
         return {
@@ -633,6 +729,48 @@ export async function loadClaudeOauth(home) {
         return null;
     }
 }
+/**
+ * Load a version home's Claude OAuth credential from the two stores Claude Code
+ * uses, tried in order:
+ *
+ *  1. The OS keychain (`getKeychainToken`). Canonical on macOS — Claude Code
+ *     writes the token to the login keychain and we read it via `/usr/bin/security`.
+ *  2. `<home>/.claude/.credentials.json`. On a headless Linux box (the
+ *     `agents view --host <linux>` case) there is no reachable Secret Service, so
+ *     the Claude CLI stores its OAuth token in this plaintext file instead. The
+ *     keychain read above finds nothing on that platform, so we fall back to the
+ *     file. Same wrapped `{ claudeAiOauth }` shape, so one parser handles both.
+ *     Mirrors `readClaudeCredentialsBlob` (cloud/rush.ts), the proven pattern.
+ *
+ * Without step 2 the live usage fetch got no token on Linux, so `agents view`
+ * (run remotely over SSH by `--host`) rendered no usage bars even though the
+ * account + plan — read from the plaintext `.claude.json` — showed fine.
+ */
+export async function loadClaudeOauth(home) {
+    // The OS keychain/keyring step is macOS/Linux-only. Windows skips straight
+    // to the .credentials.json fallback — the Claude CLI has no keychain
+    // integration there and stores its OAuth token in that file too.
+    if (process.platform === 'darwin' || process.platform === 'linux') {
+        try {
+            const fromKeychain = parseClaudeOauthPayload(getKeychainToken(getClaudeKeychainService(home)));
+            if (fromKeychain)
+                return fromKeychain;
+        }
+        catch {
+            // No keychain item, or no reachable keyring (headless Linux) — fall through.
+        }
+    }
+    const credsPath = path.join(home ?? os.homedir(), '.claude', '.credentials.json');
+    try {
+        if (fs.existsSync(credsPath)) {
+            return parseClaudeOauthPayload(fs.readFileSync(credsPath, 'utf-8'));
+        }
+    }
+    catch {
+        // Unreadable file — treat as not signed in.
+    }
+    return null;
+}
 /**
  * Save Claude OAuth credentials to the system keychain/keyring.
  * Reads the existing payload, merges the new OAuth fields, and writes back.
@@ -895,6 +1033,8 @@ function inferWindowMinutes(key) {
         case 'week':
         case 'sonnet_week':
             return 10080;
+        case 'month':
+            return 43200;
     }
 }
 /** Parse a date value from a number (epoch seconds or ms) or ISO string. */

package/package.json

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