@phnx-labs/agents-cli 1.22.78 → 1.22.80

package/dist/lib/state.js

@@ -1325,12 +1325,23 @@ export function writeMetaUnlocked(meta) {
         ? deviceAccounts.native : undefined;
     const accountsBindings = deviceAccounts?.bindings && Object.keys(deviceAccounts.bindings).length > 0
         ? deviceAccounts.bindings : undefined;
-    if (accountsNative || accountsBindings) {
+    // This box's account⇄home map (PHNX-3940) is device-scoped, so it round-trips
+    // through the device doc alongside native/bindings, never the synced central file.
+    const accountsHomes = deviceAccounts?.homes && Object.keys(deviceAccounts.homes).length > 0
+        ? deviceAccounts.homes : undefined;
+    // In-flight connect attempts (PHNX-3940), device-scoped like homes.
+    const accountsPending = deviceAccounts?.pendingConnects && Object.keys(deviceAccounts.pendingConnects).length > 0
+        ? deviceAccounts.pendingConnects : undefined;
+    if (accountsNative || accountsBindings || accountsHomes || accountsPending) {
         const da = {};
         if (accountsNative)
             da.native = accountsNative;
         if (accountsBindings)
             da.bindings = accountsBindings;
+        if (accountsHomes)
+            da.homes = accountsHomes;
+        if (accountsPending)
+            da.pendingConnects = accountsPending;
         doc.accounts = da;
     }
     else if (writesDeviceAccounts)
@@ -1470,10 +1481,18 @@ function overlayMachineLocal(meta) {
                 if (acc.bindings !== undefined && !isMap(acc.bindings)) {
                     throw new Error(`Device config corrupted at ${devicePath}: accounts.bindings must be a map.`);
                 }
+                if (acc.homes !== undefined && !isMap(acc.homes)) {
+                    throw new Error(`Device config corrupted at ${devicePath}: accounts.homes must be a map.`);
+                }
+                if (acc.pendingConnects !== undefined && !isMap(acc.pendingConnects)) {
+                    throw new Error(`Device config corrupted at ${devicePath}: accounts.pendingConnects must be a map.`);
+                }
                 const native = acc.native;
                 const bindings = acc.bindings;
-                if (native || bindings)
-                    meta.deviceAccounts = { ...(native ? { native } : {}), ...(bindings ? { bindings } : {}) };
+                const homes = acc.homes;
+                const pendingConnects = acc.pendingConnects;
+                if (native || bindings || homes || pendingConnects)
+                    meta.deviceAccounts = { ...(native ? { native } : {}), ...(bindings ? { bindings } : {}), ...(homes ? { homes } : {}), ...(pendingConnects ? { pendingConnects } : {}) };
             }
             if (Object.prototype.hasOwnProperty.call(dm, 'routines')) {
                 if (!Array.isArray(dm.routines) || dm.routines.some((name) => typeof name !== 'string')) {
@@ -1533,12 +1552,16 @@ function migrateSystemMetaToUser() {
  *   mtime check below catches it on the next read (assuming the mtime advanced).
  * - The cache stores the merged system+user meta; both files' mtimes contribute.
  */
-export function readMeta() {
-    ensureAgentsDir();
+export function readMeta(options = {}) {
+    const migrate = options.migrate !== false;
+    if (migrate)
+        ensureAgentsDir();
+    // A preview must not suppress a later real migration by populating its cache.
+    const remember = (meta) => migrate ? rememberMeta(meta) : meta;
     // Fast path: serve from cache when both source files are byte-identical to
     // what we last parsed. Reduces N readMeta calls per CLI invocation to ~2 stat
     // syscalls plus an in-memory object spread.
-    if (metaCache) {
+    if (migrate && metaCache) {
         if (currentMetaStamp() === metaCache.stamp) {
             return metaCache.meta;
         }
@@ -1575,12 +1598,14 @@ export function readMeta() {
             // non-heartbeated lock. This one-shot legacy migration needs no synchronous
             // commit: it self-heals on the daemon's next publish tick or the next real
             // CLI central write.
-            withMetaLock(() => writeMetaUnlocked(meta));
-            try {
-                fs.unlinkSync(oldMetaFile);
+            if (migrate) {
+                withMetaLock(() => writeMetaUnlocked(meta));
+                try {
+                    fs.unlinkSync(oldMetaFile);
+                }
+                catch { /* non-critical */ }
             }
-            catch { /* non-critical */ }
-            return rememberMeta(meta);
+            return remember(meta);
         }
         catch {
             /* meta.yaml migration failed */
@@ -1621,11 +1646,11 @@ export function readMeta() {
             };
         }
         overlayMachineLocal(meta);
-        return rememberMeta(meta);
+        return remember(meta);
     }
     const meta = createDefaultMeta();
     overlayMachineLocal(meta);
-    return rememberMeta(meta);
+    return remember(meta);
 }
 /** Serialize and write agents.yaml to the user repo, invalidating the in-memory cache. */
 export function writeMeta(meta) {

package/dist/lib/types.d.ts

@@ -8,7 +8,9 @@
 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' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'muse' | 'warp';
+export declare const AGENT_IDS: readonly ["claude", "codex", "gemini", "cursor", "opencode", "openclaw", "copilot", "amp", "goose", "antigravity", "grok", "kimi", "droid", "hermes", "muse", "warp"];
+export type AgentId = typeof AGENT_IDS[number];
+export declare function isAgentId(value: string): value is AgentId;
 /** 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';
@@ -861,6 +863,29 @@ export interface Meta {
             scope: 'version' | 'device';
         }>;
         bindings?: Record<string, string>;
+        /**
+         * THIS box's account⇄home map (PHNX-3940): stable account id → the local
+         * installation label whose isolated home hosts that account's native login,
+         * as created by `agents accounts connect`. It is DEVICE-scoped on purpose —
+         * one account materializes a different home per host, and the label a box
+         * minted must never be assumed to exist on another box — so it lives in the
+         * device doc, never the fleet-synced central `accounts.native` identity row.
+         * A reconnect reads this to reuse the exact home even when its credential has
+         * expired (so local signed-in discovery can no longer find it).
+         */
+        homes?: Record<string, string>;
+        /**
+         * THIS box's IN-FLIGHT `agents accounts connect` attempts (PHNX-3940):
+         * `${agent}:${name}` (lowercased) → the opaque slot minted for that attempt,
+         * BEFORE its login completed. It exists so a failed/cancelled named connect
+         * retries into the SAME fresh home instead of orphaning a new one each time,
+         * WITHOUT a deterministic name→slot function (which would recompute an
+         * already-taken slot after a rename and overwrite another account's login —
+         * the security flaw this replaces). It is cleared the moment the account is
+         * registered, so a live pending slot is by definition not yet an account's
+         * home. Device-scoped for the same reason as {@link homes}.
+         */
+        pendingConnects?: Record<string, string>;
     };
     agents?: Partial<Record<AgentId, string>>;
     /**

package/dist/lib/types.js

@@ -5,6 +5,11 @@
  * configuration schemas, resource tracking, registry types, and permission
  * formats for each supported agent.
  */
+/** Unique identifier for a current or legacy AI coding agent. */
+export const AGENT_IDS = ['claude', 'codex', 'gemini', 'cursor', 'opencode', 'openclaw', 'copilot', 'amp', 'goose', 'antigravity', 'grok', 'kimi', 'droid', 'hermes', 'muse', 'warp'];
+export function isAgentId(value) {
+    return AGENT_IDS.includes(value);
+}
 /**
  * Reserved `<agent>` keyword for `agents run auto` — full-auto dispatch:
  * host (14d launch affinity) → harness (best-account headroom, weighted) →

package/dist/lib/view-types.d.ts

@@ -2,9 +2,13 @@ import type { ConfiguredModelSource } from './models.js';
 import type { ProfileSummary } from './profiles.js';
 import type { AgentId } from './types.js';
 import type { AuthVerdict } from './auth-health.js';
+import type { NativeAccountCatalogRow } from './account-catalog.js';
 export type SyncState = 'synced' | 'new' | 'modified' | 'deleted';
 export interface ViewJsonVersion {
+    /** Stable installation label; retained for existing machine consumers. */
     version: string;
+    /** Actual vendor release, independent of the stable installation label. */
+    releaseVersion?: string;
     isDefault: boolean;
     isolated: boolean;
     isIsolatedDefault: boolean;
@@ -65,6 +69,8 @@ export interface ViewJsonVersion {
 export interface ViewJsonAgent {
     agent: AgentId;
     versions: ViewJsonVersion[];
+    /** Account-first projection, additive so older consumers keep working. */
+    accounts?: NativeAccountCatalogRow[];
     harnesses: ProfileSummary[];
 }
 export type ResourceSection = 'commands' | 'skills' | 'mcp' | 'memory' | 'hooks' | 'workflows' | 'plugins';

package/package.json

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