@phnx-labs/agents-cli 1.22.22 → 1.22.24

package/dist/lib/sync-umbrella.js

@@ -18,6 +18,7 @@
 import { pullRepo } from './git.js';
 import { getUserAgentsDir, getEnabledExtraRepos } from './state.js';
 import { listRemoteBundles, pullBundle } from './secrets/sync.js';
+import { SYNC_PASSPHRASE_ENV } from './secrets/sync-passphrase.js';
 /**
  * Decide which stages run. Pure — no I/O. Semantics:
  *   bare (no flags)        fetch repos, then reconcile
@@ -52,7 +53,7 @@ export function planUmbrellaStages(f) {
  * reconcile — `agents sync` should make as much current as it can in one pass.
  */
 export async function runUmbrellaSync(args) {
-    const { flags, log, yes, passphrase } = args;
+    const { flags, log, yes, passphrase, quiet = false } = args;
     const plan = planUmbrellaStages(flags);
     const result = { plan, reconciled: false };
     if (plan.fetchRepos) {
@@ -79,10 +80,10 @@ export async function runUmbrellaSync(args) {
             result.secrets = {
                 pulled: 0,
                 skipped: true,
-                reason: 'no passphrase — set AGENTS_SECRETS_PASSPHRASE or run `agents login` (#366)',
+                reason: `no passphrase — set ${SYNC_PASSPHRASE_ENV} or run \`agents login\` (#366)`,
                 errors: [],
             };
-            log('secrets: skipped (no passphrase available)');
+            log(`secrets: skipped (no passphrase — set ${SYNC_PASSPHRASE_ENV})`);
         }
         else {
             let pulled = 0;
@@ -108,7 +109,7 @@ export async function runUmbrellaSync(args) {
     }
     if (plan.reconcile) {
         const { refresh } = await import('./refresh.js');
-        await refresh({ skipPrompts: yes });
+        await refresh({ skipPrompts: yes, quiet });
         result.reconciled = true;
         // Keep already-registered devices' reachability current, and surface newly
         // appeared tailnet nodes as "pending" for the menu-bar Register/Ignore gate

package/dist/lib/tmux/session.d.ts

@@ -114,6 +114,8 @@ export interface TmuxClient {
 export declare function listClients(socket?: string): Promise<TmuxClient[]>;
 /** A dead pane's exit status, read from tmux while the pane lingers under remain-on-exit. */
 export interface PaneExit {
+    /** False when the pane/socket no longer exists or tmux could not query it. */
+    found: boolean;
     /** True once the process that ran in the pane has exited (pane is dead). */
     dead: boolean;
     /** Exit status of the dead pane's process, when tmux reports it. */
@@ -122,8 +124,8 @@ export interface PaneExit {
 /**
  * Read whether a pane's process has exited and, if so, its exit status. Used by
  * the spawn-wrap path to recover the wrapped agent's exit code after the attach
- * client returns. Returns `{ dead: false }` when tmux can't answer (session gone,
- * pane missing) so the caller treats an unreadable pane as "still alive / detach".
+ * client returns. `found: false` distinguishes a missing pane from a living one;
+ * focus must recover the former instead of attaching a retained/stale target.
  */
 export declare function paneExitStatus(pane: string, socket?: string): Promise<PaneExit>;
 /**

package/dist/lib/tmux/session.js

@@ -248,8 +248,8 @@ export async function listClients(socket) {
 /**
  * Read whether a pane's process has exited and, if so, its exit status. Used by
  * the spawn-wrap path to recover the wrapped agent's exit code after the attach
- * client returns. Returns `{ dead: false }` when tmux can't answer (session gone,
- * pane missing) so the caller treats an unreadable pane as "still alive / detach".
+ * client returns. `found: false` distinguishes a missing pane from a living one;
+ * focus must recover the former instead of attaching a retained/stale target.
  */
 export async function paneExitStatus(pane, socket) {
     let res;
@@ -261,13 +261,13 @@ export async function paneExitStatus(pane, socket) {
         });
     }
     catch {
-        return { dead: false };
+        return { found: false, dead: false };
     }
     if (res.code !== 0)
-        return { dead: false };
+        return { found: false, dead: false };
     const [deadRaw, statusRaw] = res.stdout.trim().split(/\s+/);
     const status = statusRaw !== undefined && statusRaw !== '' ? parseInt(statusRaw, 10) : undefined;
-    return { dead: deadRaw === '1', status: Number.isFinite(status) ? status : undefined };
+    return { found: true, dead: deadRaw === '1', status: Number.isFinite(status) ? status : undefined };
 }
 /**
  * Bind a per-session hook. Used by the spawn-wrap path to install a `pane-died`

package/dist/lib/types.d.ts

@@ -8,9 +8,10 @@
 import type { CloudProviderId } from './cloud/types.js';
 import type { FeedBroadcastConfig } from './feed-broadcast.js';
 /** Unique identifier for a current or legacy AI coding agent. */
-export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'copilot' | 'amp' | 'kiro' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'pi';
+export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'copilot' | 'amp' | 'kiro' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'pi' | 'muse';
 /** How `agents run <agent>` chooses an installed version when none is pinned. */
 export type RunStrategy = 'pinned' | 'available' | 'balanced';
+export type RunEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max' | 'auto';
 /**
  * Reserved `<agent>` keyword for `agents run auto` — full-auto dispatch:
  * host (14d launch affinity) → harness (best-account headroom, weighted) →
@@ -36,6 +37,7 @@ export interface AgentRunConfig {
 export interface RunDefaults {
     mode?: Mode;
     model?: string;
+    effort?: RunEffort;
 }
 /** `run:` section in agents.yaml. Agent keys keep strategy; `defaults` stores selector rules. */
 export type RunConfig = Partial<Record<AgentId, AgentRunConfig>> & {

package/dist/lib/usage.d.ts

@@ -141,6 +141,10 @@ declare const USAGE_SOURCES: {
         readonly fetch: typeof getAntigravityUsageInfo;
         readonly network: true;
     };
+    readonly muse: {
+        readonly fetch: typeof getMuseUsageInfo;
+        readonly network: true;
+    };
 };
 export declare const USAGE_SOURCE_AGENT_IDS: (keyof typeof USAGE_SOURCES)[];
 /** Fetch usage info for a given agent through the canonical source registry. */
@@ -510,6 +514,15 @@ export declare function renderBar(usedPercent: number, length: number, minimumVi
 export declare function getUsageColor(usedPercent: number): (text: string) => string;
 /** Parse the latest billing info from Grok's unified log. */
 declare function getGrokUsageInfo(options?: UsageOptions): Promise<UsageInfo>;
+/**
+ * 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.
+ */
+declare function getMuseUsageInfo(options?: UsageOptions): Promise<UsageInfo>;
 /** Per-model bucket in Cursor's /api/usage response. */
 interface CursorUsageModel {
     numRequests?: number | null;

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) {
@@ -1873,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.22",
+  "version": "1.22.24",
   "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",