@phnx-labs/agents-cli 1.20.67 → 1.20.69

package/dist/lib/resources/mcp.js

@@ -12,8 +12,9 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
-import * as TOML from 'smol-toml';
 import { capableAgents } from '../capabilities.js';
+import { getProjectMcpConfigPath } from '../agents.js';
+import { writeMcpConfig } from '../mcp.js';
 import { getSystemMcpDir, getUserMcpDir, getProjectAgentsDir, getEnabledExtraRepos, } from '../state.js';
 /**
  * Parse an MCP YAML file into an McpItem.
@@ -132,316 +133,10 @@ export function getMcpConfigPath(agent, versionHome) {
     }
 }
 /**
- * Strip JSON comments (for JSONC files).
+ * Dispatch MCP items to the agent-specific config writer.
  */
-function stripJsonComments(content) {
-    let result = '';
-    let inString = false;
-    let escape = false;
-    let i = 0;
-    while (i < content.length) {
-        const char = content[i];
-        const next = content[i + 1];
-        if (escape) {
-            result += char;
-            escape = false;
-            i++;
-            continue;
-        }
-        if (char === '\\' && inString) {
-            result += char;
-            escape = true;
-            i++;
-            continue;
-        }
-        if (char === '"') {
-            inString = !inString;
-            result += char;
-            i++;
-            continue;
-        }
-        if (!inString) {
-            if (char === '/' && next === '/') {
-                while (i < content.length && content[i] !== '\n') {
-                    i++;
-                }
-                continue;
-            }
-            if (char === '/' && next === '*') {
-                i += 2;
-                while (i < content.length && !(content[i] === '*' && content[i + 1] === '/')) {
-                    i++;
-                }
-                i += 2;
-                continue;
-            }
-        }
-        result += char;
-        i++;
-    }
-    return result;
-}
-/**
- * Write MCP servers to Claude settings.json format.
- */
-function syncToClaudeConfig(configPath, items) {
-    let config = {};
-    if (fs.existsSync(configPath)) {
-        try {
-            config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-        }
-        catch {
-            config = {};
-        }
-    }
-    const mcpServers = {};
-    for (const item of items) {
-        if (item.transport === 'stdio') {
-            mcpServers[item.name] = {
-                command: item.command,
-                args: item.args || [],
-                env: item.env || {},
-            };
-        }
-        else {
-            mcpServers[item.name] = {
-                url: item.url,
-                ...(item.headers && { headers: item.headers }),
-            };
-        }
-    }
-    config.mcpServers = mcpServers;
-    fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
-}
-/**
- * Write MCP servers to Codex config.toml format.
- */
-function syncToCodexConfig(configPath, items) {
-    let config = {};
-    if (fs.existsSync(configPath)) {
-        try {
-            config = TOML.parse(fs.readFileSync(configPath, 'utf-8'));
-        }
-        catch {
-            config = {};
-        }
-    }
-    const mcpServers = {};
-    for (const item of items) {
-        if (item.transport === 'stdio') {
-            mcpServers[item.name] = {
-                command: item.command,
-                args: item.args || [],
-                ...(item.env && { env: item.env }),
-            };
-        }
-        // Codex may not support HTTP MCPs
-    }
-    config.mcp_servers = mcpServers;
-    fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    fs.writeFileSync(configPath, TOML.stringify(config), 'utf-8');
-}
-/**
- * Write MCP servers to Grok config.toml format ([mcp_servers] section).
- */
-function syncToGrokConfig(configPath, items) {
-    let config = {};
-    if (fs.existsSync(configPath)) {
-        try {
-            config = TOML.parse(fs.readFileSync(configPath, 'utf-8'));
-        }
-        catch {
-            config = {};
-        }
-    }
-    const mcpServers = {};
-    for (const item of items) {
-        if (item.transport === 'stdio') {
-            mcpServers[item.name] = {
-                command: item.command,
-                args: item.args || [],
-                ...(item.env && { env: item.env }),
-            };
-        }
-        else if (item.transport === 'http' || item.transport === 'sse') {
-            mcpServers[item.name] = {
-                url: item.url,
-                ...(item.headers && { headers: item.headers }),
-            };
-        }
-    }
-    config.mcp_servers = mcpServers;
-    fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    fs.writeFileSync(configPath, TOML.stringify(config), 'utf-8');
-}
-function syncToHermesConfig(configPath, items) {
-    let config = {};
-    if (fs.existsSync(configPath)) {
-        try {
-            const parsed = yaml.parse(fs.readFileSync(configPath, 'utf-8'));
-            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                config = parsed;
-            }
-        }
-        catch {
-            config = {};
-        }
-    }
-    const mcpServers = {};
-    for (const item of items) {
-        if (item.transport === 'stdio') {
-            mcpServers[item.name] = {
-                command: item.command,
-                args: item.args || [],
-                ...(item.env && { env: item.env }),
-            };
-        }
-        else {
-            mcpServers[item.name] = {
-                url: item.url,
-            };
-        }
-    }
-    config.mcp_servers = mcpServers;
-    fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    fs.writeFileSync(configPath, yaml.stringify(config), 'utf-8');
-}
-/**
- * Write MCP servers to OpenCode opencode.jsonc format.
- */
-function syncToOpenCodeConfig(configPath, items) {
-    let config = {};
-    if (fs.existsSync(configPath)) {
-        try {
-            const content = stripJsonComments(fs.readFileSync(configPath, 'utf-8'));
-            config = JSON.parse(content);
-        }
-        catch {
-            config = {};
-        }
-    }
-    const mcp = {};
-    for (const item of items) {
-        if (item.transport === 'stdio') {
-            // OpenCode uses command as array
-            const commandArray = [item.command, ...(item.args || [])];
-            mcp[item.name] = {
-                type: 'local',
-                command: commandArray,
-                ...(item.env && { env: item.env }),
-            };
-        }
-        else {
-            mcp[item.name] = {
-                type: 'remote',
-                url: item.url,
-            };
-        }
-    }
-    config.mcp = mcp;
-    fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
-}
-/**
- * Write MCP servers to Cursor mcp.json format.
- */
-function syncToCursorConfig(configPath, items) {
-    let config = {};
-    if (fs.existsSync(configPath)) {
-        try {
-            config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-        }
-        catch {
-            config = {};
-        }
-    }
-    const mcpServers = {};
-    for (const item of items) {
-        if (item.transport === 'stdio') {
-            mcpServers[item.name] = {
-                command: item.command,
-                args: item.args || [],
-                env: item.env || {},
-            };
-        }
-        else {
-            mcpServers[item.name] = {
-                url: item.url,
-            };
-        }
-    }
-    config.mcpServers = mcpServers;
-    fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
-}
-/**
- * Write MCP servers to Gemini settings.json format.
- */
-function syncToGeminiConfig(configPath, items) {
-    let config = {};
-    if (fs.existsSync(configPath)) {
-        try {
-            config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-        }
-        catch {
-            config = {};
-        }
-    }
-    const mcpServers = {};
-    for (const item of items) {
-        if (item.transport === 'stdio') {
-            mcpServers[item.name] = {
-                command: item.command,
-                args: item.args || [],
-                env: item.env || {},
-            };
-        }
-        else {
-            mcpServers[item.name] = {
-                url: item.url,
-            };
-        }
-    }
-    config.mcpServers = mcpServers;
-    fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
-}
-/**
- * Write MCP servers to OpenClaw openclaw.json format.
- */
-function syncToOpenClawConfig(configPath, items) {
-    let config = {};
-    if (fs.existsSync(configPath)) {
-        try {
-            config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-        }
-        catch {
-            config = {};
-        }
-    }
-    if (!config.mcp || typeof config.mcp !== 'object') {
-        config.mcp = {};
-    }
-    const servers = {};
-    for (const item of items) {
-        if (item.transport === 'stdio') {
-            servers[item.name] = {
-                command: item.command,
-                args: item.args,
-                env: item.env,
-            };
-        }
-        else {
-            servers[item.name] = {
-                url: item.url,
-                transport: item.transport,
-            };
-        }
-    }
-    config.mcp.servers = servers;
-    fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+function syncToAgentConfig(agent, configPath, items, mode = 'overwrite') {
+    writeMcpConfig(agent, configPath, items, mode);
 }
 /**
  * MCP resource handler implementing ResourceHandler<McpItem>.
@@ -511,39 +206,22 @@ export const McpHandler = {
         if (items.length === 0) {
             return;
         }
+        // Sync resolved MCPs to the version home (user-level agent config).
         const configPath = getMcpConfigPath(agent, versionHome);
-        if (!configPath) {
-            return;
-        }
-        const mcpItems = items.map((r) => r.item);
-        switch (agent) {
-            case 'claude':
-                syncToClaudeConfig(configPath, mcpItems);
-                break;
-            case 'codex':
-                syncToCodexConfig(configPath, mcpItems);
-                break;
-            case 'opencode':
-                syncToOpenCodeConfig(configPath, mcpItems);
-                break;
-            case 'cursor':
-                syncToCursorConfig(configPath, mcpItems);
-                break;
-            case 'gemini':
-                syncToGeminiConfig(configPath, mcpItems);
-                break;
-            case 'openclaw':
-                syncToOpenClawConfig(configPath, mcpItems);
-                break;
-            case 'grok':
-                syncToGrokConfig(configPath, mcpItems);
-                break;
-            case 'hermes':
-                syncToHermesConfig(configPath, mcpItems);
-                break;
-            case 'forge':
-                syncToCursorConfig(configPath, mcpItems);
-                break;
+        if (configPath) {
+            const mcpItems = items.map((r) => r.item);
+            syncToAgentConfig(agent, configPath, mcpItems, 'overwrite');
+        }
+        // Sync project-layer MCPs to the agent's project-level config path so each
+        // agent CLI can discover them alongside its user-level config. Merge so we
+        // do not clobber entries added manually or by the agent's own CLI.
+        const projectAgentsDir = cwd ? getProjectAgentsDir(cwd) : null;
+        if (projectAgentsDir) {
+            const projectItems = items.filter((r) => r.layer === 'project').map((r) => r.item);
+            if (projectItems.length > 0) {
+                const projectConfigPath = getProjectMcpConfigPath(agent, path.dirname(projectAgentsDir));
+                syncToAgentConfig(agent, projectConfigPath, projectItems, 'merge');
+            }
         }
     },
     format(agent) {

package/dist/lib/rotate.d.ts

@@ -11,6 +11,8 @@ import { type UsageSnapshot } from './usage.js';
 export interface RotateCandidate {
     agent: AgentId;
     version: string;
+    accountKey: string | null;
+    accountLabel: string;
     email: string | null;
     /**
      * Per-org usage/quota key (e.g. `claude:org=<orgUuid>`) — the unit rate
@@ -21,7 +23,9 @@ export interface RotateCandidate {
     usageKey: string | null;
     usageStatus: AccountInfo['usageStatus'];
     usageSnapshot: UsageSnapshot | null;
-    authValid: boolean;
+    usageError: string | null;
+    plan: string | null;
+    signedIn: boolean;
     lastActive: Date | null;
 }
 export interface RotateResult {
@@ -58,7 +62,7 @@ export declare function getConfiguredRunStrategy(agent: AgentId, startPath?: str
 export declare function setGlobalRunStrategy(agent: AgentId, strategy: RunStrategy): void;
 /**
  * Whether a specific account can serve a run right now, and — when it can't —
- * why. `signed_out` covers no-email / invalid-auth; `rate_limited` and
+ * why. `signed_out` covers a missing usable credential; `rate_limited` and
  * `out_of_credits` name the throttle. Used to pre-warn on a version-pinned
  * teammate whose account rotation won't route around (a pin IS the target).
  */
@@ -71,7 +75,7 @@ export type AccountReadiness = {
 };
 /**
  * Pure decision reusing the router's own eligibility gate (`hasUsageAvailable`
- * + email/auth, i.e. `isRotationEligible`), so a pre-flight warning can NEVER
+ * + canonical signed-in state, i.e. `isRotationEligible`), so a pre-flight warning can NEVER
  * disagree with what rotation would actually do. The `reason` combines the two
  * signals `hasUsageAvailable` reads: the live snapshot (session-inclusive
  * rate-limit) and the coarse cached `usageStatus` (out-of-credits, which a
@@ -100,17 +104,16 @@ export declare function checkRunAccountReadiness(agent: AgentId, version: string
  * headroom, with no stampede on the lowest-usage one. Stateless — parallel
  * callers naturally fan out via the random roll.
  *
- * Eligibility: signed in (email present), auth valid, and not currently
+ * Eligibility: signed in according to AccountInfo and not currently
  * rate-limited — no blocking window (session OR weekly) at 100%, matching the
  * `agents view` badge; or the local cached status is usable when no live
  * snapshot exists. Note the split: eligibility considers the session window
  * (a session-maxed account can't run now), but the capacity *weight* above is
  * driven by weekly headroom so a brief session spike doesn't distort routing.
  *
- * Dedupe: when multiple versions share an email, collapse to one candidate
- * per email (the least-recently-active version). Prevents two parallel pods
- * from "balancing" to different versions but hitting the same Anthropic
- * account and both 429ing.
+ * Dedupe: when multiple versions share a usage/account identity, collapse to
+ * one candidate (the least-recently-active version). The org-scoped usage key
+ * wins over email so same-email personal and Team accounts remain distinct.
  *
  * Returns null if no candidate is eligible — callers fall back to the pinned
  * version so behavior stays predictable.
@@ -122,6 +125,7 @@ export declare function pickBalancedCandidate(candidates: RotateCandidate[]): Ro
  * usage headroom.
  */
 export declare function pickAvailableCandidate(candidates: RotateCandidate[], preferredVersion?: string | null): RotateResult | null;
+export declare function collectRunCandidates(agent: AgentId): Promise<RotateCandidate[]>;
 /**
  * Pick a healthy version for `agent` using weighted random by remaining
  * capacity. See `pickBalancedCandidate` for algorithm details.

package/dist/lib/rotate.js

@@ -6,7 +6,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { getAccountInfo } from './agents.js';
+import { accountDisplayLabel, getAccountInfo } from './agents.js';
 import { readMeta, writeMeta, getHelpersDir } from './state.js';
 import { listInstalledVersions, getVersionHomePath, resolveVersion } from './versions.js';
 import { getProjectRunConfigs } from './run-config.js';
@@ -65,14 +65,10 @@ export function setGlobalRunStrategy(agent, strategy) {
     writeMeta(meta);
 }
 function isRotationEligible(candidate) {
-    return !!candidate.email
-        && candidate.authValid
-        && hasUsageAvailable(candidate);
+    return candidate.signedIn && hasUsageAvailable(candidate);
 }
 function isAvailableEligible(candidate) {
-    return !!candidate.email
-        && candidate.authValid
-        && hasUsageAvailable(candidate);
+    return isRotationEligible(candidate);
 }
 function hasUsageAvailable(candidate) {
     const snapshot = candidate.usageSnapshot;
@@ -95,7 +91,7 @@ function hasUsageAvailable(candidate) {
 }
 /**
  * Pure decision reusing the router's own eligibility gate (`hasUsageAvailable`
- * + email/auth, i.e. `isRotationEligible`), so a pre-flight warning can NEVER
+ * + canonical signed-in state, i.e. `isRotationEligible`), so a pre-flight warning can NEVER
  * disagree with what rotation would actually do. The `reason` combines the two
  * signals `hasUsageAvailable` reads: the live snapshot (session-inclusive
  * rate-limit) and the coarse cached `usageStatus` (out-of-credits, which a
@@ -104,7 +100,7 @@ function hasUsageAvailable(candidate) {
  * reported while the account is actually serving requests.
  */
 export function readinessFromCandidate(candidate) {
-    if (!candidate.email || !candidate.authValid) {
+    if (!candidate.signedIn) {
         return { ready: false, reason: 'signed_out', email: candidate.email };
     }
     if (hasUsageAvailable(candidate)) {
@@ -162,7 +158,7 @@ function compareCandidates(a, b) {
  * key; fall back to email only when no usage identity is available.
  */
 function candidateIdentity(c) {
-    return c.usageKey ?? c.email;
+    return c.usageKey ?? c.accountKey ?? c.email ?? `${c.agent}@${c.version}`;
 }
 function dedupeAndSortCandidates(candidates) {
     const byIdentity = new Map();
@@ -189,17 +185,16 @@ function dedupeAndSortCandidates(candidates) {
  * headroom, with no stampede on the lowest-usage one. Stateless — parallel
  * callers naturally fan out via the random roll.
  *
- * Eligibility: signed in (email present), auth valid, and not currently
+ * Eligibility: signed in according to AccountInfo and not currently
  * rate-limited — no blocking window (session OR weekly) at 100%, matching the
  * `agents view` badge; or the local cached status is usable when no live
  * snapshot exists. Note the split: eligibility considers the session window
  * (a session-maxed account can't run now), but the capacity *weight* above is
  * driven by weekly headroom so a brief session spike doesn't distort routing.
  *
- * Dedupe: when multiple versions share an email, collapse to one candidate
- * per email (the least-recently-active version). Prevents two parallel pods
- * from "balancing" to different versions but hitting the same Anthropic
- * account and both 429ing.
+ * Dedupe: when multiple versions share a usage/account identity, collapse to
+ * one candidate (the least-recently-active version). The org-scoped usage key
+ * wins over email so same-email personal and Team accounts remain distinct.
  *
  * Returns null if no candidate is eligible — callers fall back to the pinned
  * version so behavior stays predictable.
@@ -278,12 +273,11 @@ export function pickAvailableCandidate(candidates, preferredVersion) {
         : undefined;
     return { picked: preferred ?? sorted[0], healthy: sorted, excluded };
 }
-async function collectRunCandidates(agent) {
+export async function collectRunCandidates(agent) {
     const versions = listInstalledVersions(agent);
     const rows = await Promise.all(versions.map(async (version) => {
         const home = getVersionHomePath(agent, version);
         const info = await getAccountInfo(agent, home);
-        // `info.email` (from .claude.json's oauthAccount) is the auth heuristic.
         // We used to additionally call isClaudeAuthValid(home), which reads
         // "Claude Code-credentials-<hash>" from the system keychain. That item is
         // written by Claude Code itself with its own process in the ACL, so our
@@ -291,15 +285,17 @@ async function collectRunCandidates(agent) {
         // one per installed version, every time `agents run` cold-starts. If
         // claude's stored token has actually expired, the spawned agent detects
         // it at its own startup and re-auths; that's the correct UX.
-        const authValid = info.email != null;
         return {
             agent,
             version,
             home,
             info,
+            accountKey: info.accountKey,
+            accountLabel: accountDisplayLabel(info),
             email: info.email,
             usageStatus: info.usageStatus,
-            authValid,
+            plan: info.plan,
+            signedIn: info.signedIn,
             lastActive: info.lastActive,
         };
     }));
@@ -311,10 +307,13 @@ async function collectRunCandidates(agent) {
     })));
     return rows.map(({ home: _home, info, ...candidate }) => {
         const usageKey = getUsageLookupKey(info);
-        const usageSnapshot = usageKey
-            ? usageByKey.get(usageKey)?.snapshot ?? null
-            : null;
-        return { ...candidate, usageKey, usageSnapshot };
+        const usage = usageKey ? usageByKey.get(usageKey) : undefined;
+        return {
+            ...candidate,
+            usageKey,
+            usageSnapshot: usage?.snapshot ?? null,
+            usageError: usage?.error ?? null,
+        };
     });
 }
 /**

package/dist/lib/routines.d.ts

@@ -134,12 +134,25 @@ export interface RunMeta {
     startedAt: string;
     completedAt: string | null;
     exitCode: number | null;
+    /** Machine-readable failure reason when the run did not complete successfully. */
+    errorMessage?: string;
+    /** Wall-clock duration of the run in milliseconds (set when the run finishes). */
+    duration?: number;
     /** Set for `host:`-placed runs — where the job body executes (no local pid). */
     host?: string;
     /** The host-task sidecar id backing a `host:` run; the daemon monitor
      *  finalizes the run by reconciling it against the remote `.exit`. */
     hostTaskId?: string;
 }
+/**
+ * Finalize a run record with a terminal status, computing `duration` from
+ * `startedAt` and the completion timestamp. Keeps failure-reason population
+ * centralized so every completion path writes the same machine-readable fields.
+ */
+export declare function finalizeRunMeta(meta: RunMeta, status: RunMeta['status'], exitCode: number | null, opts?: {
+    errorMessage?: string;
+    completedAt?: string;
+}): void;
 /**
  * True when the job may execute on this machine: no `devices` allowlist (or
  * empty), or the allowlist includes this device. Both sides go through

package/dist/lib/routines.js

@@ -50,6 +50,27 @@ export function normalizeTriggerEvent(input) {
     };
     return aliases[key] ?? null;
 }
+/**
+ * Finalize a run record with a terminal status, computing `duration` from
+ * `startedAt` and the completion timestamp. Keeps failure-reason population
+ * centralized so every completion path writes the same machine-readable fields.
+ */
+export function finalizeRunMeta(meta, status, exitCode, opts) {
+    meta.status = status;
+    meta.exitCode = exitCode;
+    meta.completedAt = opts?.completedAt ?? new Date().toISOString();
+    const started = Date.parse(meta.startedAt);
+    const completed = Date.parse(meta.completedAt);
+    meta.duration = Number.isFinite(started) && Number.isFinite(completed) && completed >= started
+        ? completed - started
+        : 0;
+    if (opts?.errorMessage) {
+        meta.errorMessage = opts.errorMessage;
+    }
+    else {
+        delete meta.errorMessage;
+    }
+}
 /**
  * True when the job may execute on this machine: no `devices` allowlist (or
  * empty), or the allowlist includes this device. Both sides go through