@phnx-labs/agents-cli 1.20.86 → 1.20.87

package/dist/lib/session/team-filter.d.ts

@@ -12,14 +12,33 @@ import type { SessionMeta, TeamOrigin } from './types.js';
  *
  * Primary signal is `session.isTeamOrigin`, captured at scan time from the
  * JSONL `entrypoint` field ('sdk-cli' for team spawns, 'cli' for real CLI).
- * When a team meta.json exists we additionally enrich with handle/mode — but
- * its absence no longer demotes a session: older team runs whose meta dir
- * was cleaned up still get recognized via the entrypoint flag.
+ * When a team meta.json exists we additionally enrich with handle/mode/team and
+ * the orchestrator that spawned it — but its absence no longer demotes a
+ * session: older team runs whose meta dir was cleaned up still get recognized
+ * via the entrypoint flag.
  *
  * Returns the TeamOrigin metadata when the session is team-origin, or null
  * when it is a normal interactive session.
  */
 export declare function classifyTeamSession(session: SessionMeta): TeamOrigin | null;
+/**
+ * A team name / handle as it is safe to render: a real string, terminal escapes
+ * stripped, or undefined.
+ *
+ * These values reach the row and the preview pane, and for a peer's row they are
+ * whatever JSON that machine sent — `parseRemoteList` copies the object through
+ * without inspecting its fields, so neither the type nor the content is ours to
+ * assume. A non-string `spawnedTeam` used to throw out of `teamBadge`, which runs
+ * on every row, taking down the whole listing rather than one entry.
+ */
+export declare function safeTeamText(value: unknown): string | undefined;
+/** Drop the cached teammate index — for tests that rewrite AGENTS_TEAMS_DIR. */
+export declare function _resetTeamOriginIndex(): void;
+/**
+ * Attach `teamOrigin` to every team-spawned row in `sessions`, from the shared
+ * teammate index rather than a stat per row.
+ */
+export declare function enrichTeamOrigins(sessions: SessionMeta[]): SessionMeta[];
 /** Result of splitting sessions into visible and hidden (team-origin) groups. */
 export interface FilterResult {
     visible: SessionMeta[];

package/dist/lib/session/team-filter.js

@@ -9,6 +9,7 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { sanitizeForTerminal } from './parse.js';
 import { getTeamsAgentsDir } from '../state.js';
 const HOME = os.homedir();
 // Default path; tests can override via AGENTS_TEAMS_DIR env var.
@@ -21,33 +22,121 @@ function teamsAgentsDir() {
  *
  * Primary signal is `session.isTeamOrigin`, captured at scan time from the
  * JSONL `entrypoint` field ('sdk-cli' for team spawns, 'cli' for real CLI).
- * When a team meta.json exists we additionally enrich with handle/mode — but
- * its absence no longer demotes a session: older team runs whose meta dir
- * was cleaned up still get recognized via the entrypoint flag.
+ * When a team meta.json exists we additionally enrich with handle/mode/team and
+ * the orchestrator that spawned it — but its absence no longer demotes a
+ * session: older team runs whose meta dir was cleaned up still get recognized
+ * via the entrypoint flag.
  *
  * Returns the TeamOrigin metadata when the session is team-origin, or null
  * when it is a normal interactive session.
  */
 export function classifyTeamSession(session) {
-    const metaPath = path.join(teamsAgentsDir(), session.id, 'meta.json');
-    if (fs.existsSync(metaPath)) {
-        try {
-            const raw = fs.readFileSync(metaPath, 'utf-8');
-            const meta = JSON.parse(raw);
-            const name = typeof meta.name === 'string' && meta.name ? meta.name : undefined;
-            const handle = name ?? session.id.slice(0, 8);
-            const mode = typeof meta.mode === 'string' ? meta.mode : undefined;
-            return { handle, mode };
-        }
-        catch {
-            return { handle: session.id.slice(0, 8) };
-        }
-    }
+    const origin = teamOriginIndex().get(session.id);
+    if (origin)
+        return origin;
     if (session.isTeamOrigin) {
         return { handle: session.id.slice(0, 8) };
     }
     return null;
 }
+/**
+ * Parse one teammate `meta.json` into a {@link TeamOrigin}. Degrades to a bare
+ * handle when the file is unreadable or malformed — a teammate whose record we
+ * can't parse is still a teammate.
+ */
+function readTeamOrigin(metaPath, agentId) {
+    try {
+        const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+        const str = (v) => (typeof v === 'string' && v ? v : undefined);
+        return {
+            origin: {
+                handle: str(meta.name) ?? agentId.slice(0, 8),
+                mode: str(meta.mode),
+                team: str(meta.task_name),
+                parentSessionId: str(meta.parent_session_id),
+            },
+            sessionId: str(meta.remote_session_id),
+        };
+    }
+    catch {
+        return { origin: { handle: agentId.slice(0, 8) } };
+    }
+}
+/**
+ * A team name / handle as it is safe to render: a real string, terminal escapes
+ * stripped, or undefined.
+ *
+ * These values reach the row and the preview pane, and for a peer's row they are
+ * whatever JSON that machine sent — `parseRemoteList` copies the object through
+ * without inspecting its fields, so neither the type nor the content is ours to
+ * assume. A non-string `spawnedTeam` used to throw out of `teamBadge`, which runs
+ * on every row, taking down the whole listing rather than one entry.
+ */
+export function safeTeamText(value) {
+    if (typeof value !== 'string' || value === '')
+        return undefined;
+    return sanitizeForTerminal(value);
+}
+/** Cached teammate index; the directory is small (teams GC it after 7 days). */
+let originIndexCache = null;
+/** Drop the cached teammate index — for tests that rewrite AGENTS_TEAMS_DIR. */
+export function _resetTeamOriginIndex() {
+    originIndexCache = null;
+}
+/**
+ * Every teammate record, keyed by the session ids it can be reached under.
+ *
+ * A teammate's directory name is its **agent id**, which is only sometimes the
+ * id of the transcript it produced: the harness mints its own session id, and
+ * the spawn records it separately as `remote_session_id`. Keying the lookup on
+ * the directory name alone therefore missed most teammates — on a live box, 14
+ * of 16 records were reachable only by `remote_session_id` — so a teammate row
+ * could not name its team however good the record was. Both keys are registered.
+ *
+ * Read once per process rather than per row: the old per-session `existsSync` +
+ * `readFileSync` cost a pair of syscalls for every row in the pool, which the
+ * interactive browser re-pays on each hotkey.
+ */
+function teamOriginIndex() {
+    if (originIndexCache)
+        return originIndexCache;
+    const dir = teamsAgentsDir();
+    const index = new Map();
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        entries = [];
+    }
+    for (const agentId of entries) {
+        const metaPath = path.join(dir, agentId, 'meta.json');
+        if (!fs.existsSync(metaPath))
+            continue;
+        const { origin, sessionId } = readTeamOrigin(metaPath, agentId);
+        index.set(agentId, origin);
+        if (sessionId)
+            index.set(sessionId, origin);
+    }
+    originIndexCache = index;
+    return index;
+}
+/**
+ * Attach `teamOrigin` to every team-spawned row in `sessions`, from the shared
+ * teammate index rather than a stat per row.
+ */
+export function enrichTeamOrigins(sessions) {
+    const index = teamOriginIndex();
+    return sessions.map((session) => {
+        // A peer's rows are classified on the peer (its meta.json is on its disk, not
+        // ours) and ride across in the --json fan-out already populated. Re-deriving
+        // here would find no local record and downgrade a named teammate to a bare id.
+        if (session.teamOrigin)
+            return session;
+        const origin = index.get(session.id) ?? (session.isTeamOrigin ? { handle: session.id.slice(0, 8) } : null);
+        return origin ? { ...session, teamOrigin: origin } : session;
+    });
+}
 /**
  * Split `sessions` into visible and hidden (team-origin) groups.
  * When `showTeams` is true every session is visible and `teamOrigin` is

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

@@ -88,6 +88,14 @@ export interface TeamOrigin {
     handle?: string;
     /** Agent mode: 'plan', 'edit', 'auto', or 'skip' ('full' accepted as legacy alias for 'skip'). */
     mode?: string;
+    /** The team this teammate belongs to (`task_name` in its meta.json). */
+    team?: string;
+    /**
+     * The orchestrator session that spawned this teammate (`parent_session_id`).
+     * Absent for a team started outside any agent session, and for teammates whose
+     * meta dir has aged past the teams cleanup window.
+     */
+    parentSessionId?: string;
 }
 /** Lightweight metadata for a discovered session, used in listings and pickers. */
 export interface SessionMeta {

package/dist/lib/signin-badge.d.ts

@@ -23,6 +23,23 @@ export declare function loginHint(agentId: AgentId): string;
  * agents (the ones the feature is for), so the resume's `forceInteractive` flag is
  * consulted directly.
  */
+/**
+ * Is a Claude run on this box going to authenticate from an ambient
+ * `CLAUDE_CODE_OAUTH_TOKEN` rather than a per-version login?
+ *
+ * `AccountInfo.signedIn` is `!!email` read from a version home's `.claude.json`
+ * (agents.ts), so a version with no account written there reports signed-out —
+ * even though Claude Code authenticates fine from the env token and the run
+ * succeeds. Rendering that as "logged out" sends people hunting a login that is
+ * not missing (a real fleet incident: every version on a box read as locked out
+ * while all of them answered a live prompt).
+ *
+ * It is also the more useful warning: an ambient token is ONE account, so every
+ * version on the box resolves to it and balanced rotation across them rotates
+ * nothing. `env` is a parameter so the branch is testable without mutating the
+ * process environment.
+ */
+export declare function ambientClaudeToken(agentId: AgentId | string, env?: NodeJS.ProcessEnv): boolean;
 export declare function shouldCheckLoginBeforeLaunch(o: {
     interactive?: boolean;
     forceInteractive?: boolean;

package/dist/lib/signin-badge.js

@@ -46,6 +46,25 @@ export function loginHint(agentId) {
  * agents (the ones the feature is for), so the resume's `forceInteractive` flag is
  * consulted directly.
  */
+/**
+ * Is a Claude run on this box going to authenticate from an ambient
+ * `CLAUDE_CODE_OAUTH_TOKEN` rather than a per-version login?
+ *
+ * `AccountInfo.signedIn` is `!!email` read from a version home's `.claude.json`
+ * (agents.ts), so a version with no account written there reports signed-out —
+ * even though Claude Code authenticates fine from the env token and the run
+ * succeeds. Rendering that as "logged out" sends people hunting a login that is
+ * not missing (a real fleet incident: every version on a box read as locked out
+ * while all of them answered a live prompt).
+ *
+ * It is also the more useful warning: an ambient token is ONE account, so every
+ * version on the box resolves to it and balanced rotation across them rotates
+ * nothing. `env` is a parameter so the branch is testable without mutating the
+ * process environment.
+ */
+export function ambientClaudeToken(agentId, env = process.env) {
+    return agentId === 'claude' && (env.CLAUDE_CODE_OAUTH_TOKEN ?? '').trim().length > 0;
+}
 export function shouldCheckLoginBeforeLaunch(o) {
     if (o.json || o.quiet || o.authCheckDisabled || o.rotated)
         return false;

package/dist/lib/state.d.ts

@@ -181,6 +181,8 @@ export declare function getTeamsRegistryPath(): string;
 export declare function getDevicesRegistryPath(): string;
 /** Path to the device ignore-list — tailscale node names the user dismissed, so auto-discovery never re-suggests them. Per-machine, same dir as the registry. */
 export declare function getDevicesIgnoredPath(): string;
+/** Path to the device auto-launch preference file — which registered devices are eligible/preferred for Factory's auto-host selection. Per-machine, same dir as the registry. */
+export declare function getDevicesAutoLaunchPath(): string;
 /** Dir of "pending device" sentinels (~/.agents/.cache/state/devices-pending/) — one empty-ish file per newly-discovered, not-yet-approved tailnet node. Written by the daemon probe, read by the menu-bar helper (mirrors the attention sentinel dir). */
 export declare function getDevicesPendingDir(): string;
 /** Path to cloud dispatch cache (~/.agents/.cache/cloud/). */

package/dist/lib/state.js

@@ -402,6 +402,8 @@ function getDevicesDir() {
 export function getDevicesRegistryPath() { return path.join(getDevicesDir(), 'registry.json'); }
 /** Path to the device ignore-list — tailscale node names the user dismissed, so auto-discovery never re-suggests them. Per-machine, same dir as the registry. */
 export function getDevicesIgnoredPath() { return path.join(getDevicesDir(), 'ignored.json'); }
+/** Path to the device auto-launch preference file — which registered devices are eligible/preferred for Factory's auto-host selection. Per-machine, same dir as the registry. */
+export function getDevicesAutoLaunchPath() { return path.join(getDevicesDir(), 'auto-launch.json'); }
 /** Dir of "pending device" sentinels (~/.agents/.cache/state/devices-pending/) — one empty-ish file per newly-discovered, not-yet-approved tailnet node. Written by the daemon probe, read by the menu-bar helper (mirrors the attention sentinel dir). */
 export function getDevicesPendingDir() { return path.join(RUNTIME_STATE_DIR, 'devices-pending'); }
 /** Path to cloud dispatch cache (~/.agents/.cache/cloud/). */

package/dist/lib/usage.js

@@ -18,7 +18,7 @@ import chalk from 'chalk';
 import { decodeJwtPayload, decryptDroidAuthPayload } from './agents.js';
 import { walkForFiles } from './fs-walk.js';
 import { getKeychainToken, setKeychainToken, deleteKeychainToken, isKeychainBackendOverridden, } from './secrets/index.js';
-import { bundleExists, bundleBackend, readAndResolveBundleEnv } from './secrets/bundles.js';
+import { resolveClaudeSetupToken } from './claude-account-token.js';
 import { getCacheDir } from './state.js';
 const execFileAsync = promisify(execFile);
 const CLAUDE_USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
@@ -999,65 +999,6 @@ function deleteCachedClaudeOauth(service) {
         /* best-effort — cache is an optimization */
     }
 }
-/**
- * Reserved FILE-BASED secrets bundle holding long-lived, non-rotating Claude
- * setup-tokens. Usage/probe reads authenticate with these instead of Claude
- * Code's ACL-bound login item, so they never pop Touch ID. Keyed strictly
- * per-account (`CLAUDE_CODE_OAUTH_TOKEN_<slug>` from the account email) — never a
- * bare key, so one account's token can't be misapplied to another in a
- * multi-account fleet.
- */
-const AUTH_BUNDLE = 'auth';
-/** The per-account key an email maps to inside the `auth` bundle. */
-function claudeAccountTokenKey(account) {
-    const slug = account
-        .trim()
-        .toUpperCase()
-        .replace(/@/g, '_AT_')
-        .replace(/\./g, '_DOT_')
-        .replace(/[^A-Z0-9_]/g, '_');
-    return `CLAUDE_CODE_OAUTH_TOKEN_${slug}`;
-}
-/** Signed-in account email for a version home, from `.claude.json` (no keychain). */
-function readClaudeAccountEmail(home) {
-    const base = home ?? os.homedir();
-    for (const p of [path.join(base, '.claude', '.claude.json'), path.join(base, '.claude.json')]) {
-        try {
-            const email = JSON.parse(fs.readFileSync(p, 'utf-8')).oauthAccount?.emailAddress;
-            if (typeof email === 'string' && email.trim().length > 0)
-                return email.trim();
-        }
-        catch {
-            // Missing/unreadable at this location — try the next.
-        }
-    }
-    return null;
-}
-/**
- * Resolve a long-lived `claude setup-token` for the account signed into `home`
- * from the reserved FILE-BASED `auth` bundle. Returns the token or null. Reads
- * ONLY when the bundle is file-backed (never keychain), so this path itself can
- * never trigger a Touch ID prompt — that is the entire point: usage/probe reads
- * authenticate with the shareable setup-token, not the ACL-bound login item.
- */
-function resolveClaudeSetupToken(home) {
-    try {
-        // Require a known account (email) up front: without it we cannot key a
-        // per-account token, and we must NOT fall back to a bare shared key that
-        // would misapply one account's setup-token to another.
-        const email = readClaudeAccountEmail(home);
-        if (!email)
-            return null;
-        if (!bundleExists(AUTH_BUNDLE) || bundleBackend(AUTH_BUNDLE) !== 'file')
-            return null;
-        const { env } = readAndResolveBundleEnv(AUTH_BUNDLE, { caller: 'usage', agentOnly: true });
-        const v = (env[claudeAccountTokenKey(email)] ?? '').trim();
-        return v.length > 0 ? v : null;
-    }
-    catch {
-        return null;
-    }
-}
 /**
  * Load a version home's Claude OAuth credential from the two stores Claude Code
  * uses, tried in order:

package/package.json

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