@phnx-labs/agents-cli 1.22.84 → 1.22.85

package/dist/lib/secrets/headless.d.ts

@@ -1,43 +0,0 @@
-/**
- * The headless-context detector shared by every secrets read path that could
- * raise a macOS Touch ID sheet: bundle resolution (bundles.ts) and raw item
- * reads (index.ts). It lives in its own module so index.ts can use it without
- * importing bundles.ts (which already imports index.ts).
- */
-/**
- * True when the current process was structurally launched by an agent runtime
- * that must NEVER raise a Keychain biometry prompt on the user's screen:
- *   - `AGENTS_RUNTIME` is `headless`, `teams`, or `terminal` — i.e. ANY agent
- *     launch, interactive included, and inherited by everything spawned beneath
- *     one (set on the child env by `agents run --headless`, scheduled routines,
- *     teammates, and interactive runs — see exec.ts:430, runner.ts,
- *     teams/agents.ts).
- *
- * Only **macOS keychain** reads pop an interactive Touch ID sheet — the secrets
- * broker itself is a no-op off darwin (see agent.ts), and libsecret (Linux) /
- * the Windows credential store resolve without any prompt. So off-darwin this
- * ALWAYS returns false: forcing broker-only there would break every headless
- * Linux/Windows read (CI, `agents run --headless`, routines, the Linux-driven
- * release flow) for no benefit — there is no prompt to suppress.
- *
- * A read in a macOS headless context resolves broker-only (agentOnly) and fails
- * fast with an actionable error instead of hijacking Touch ID. This generalizes
- * the per-caller broker-only pattern used across the headless secrets readers.
- */
-export declare function isHeadlessSecretsContext(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): boolean;
-/**
- * True when this process runs structurally inside a coding-agent session: any
- * `agents run` launch (AGENTS_RUNTIME / AGENT_SESSION_ID ride the child env —
- * exec.ts buildExecEnv — and are inherited by every shell the agent spawns), or
- * a harness's own tool shell launched outside agents-cli (Claude Code stamps
- * CLAUDECODE on its Bash tool).
- *
- * Distinct from isHeadlessSecretsContext above on both axes: it is
- * platform-independent (no biometry involved), and a TTY does not clear it (an
- * agent inside tmux has one). Its job is the materialization boundary, not the
- * prompt boundary: a command that would PRINT a plaintext value refuses under
- * an agent, because anything printed lands in the agent's context and session
- * transcript. The agent path to secret values is injection — `secrets exec`,
- * `run --secrets` — which places them only in a child process env.
- */
-export declare function isAgentInvocationContext(env?: NodeJS.ProcessEnv): boolean;

package/dist/lib/secrets/headless.js

@@ -1,56 +0,0 @@
-/**
- * The headless-context detector shared by every secrets read path that could
- * raise a macOS Touch ID sheet: bundle resolution (bundles.ts) and raw item
- * reads (index.ts). It lives in its own module so index.ts can use it without
- * importing bundles.ts (which already imports index.ts).
- */
-/**
- * True when the current process was structurally launched by an agent runtime
- * that must NEVER raise a Keychain biometry prompt on the user's screen:
- *   - `AGENTS_RUNTIME` is `headless`, `teams`, or `terminal` — i.e. ANY agent
- *     launch, interactive included, and inherited by everything spawned beneath
- *     one (set on the child env by `agents run --headless`, scheduled routines,
- *     teammates, and interactive runs — see exec.ts:430, runner.ts,
- *     teams/agents.ts).
- *
- * Only **macOS keychain** reads pop an interactive Touch ID sheet — the secrets
- * broker itself is a no-op off darwin (see agent.ts), and libsecret (Linux) /
- * the Windows credential store resolve without any prompt. So off-darwin this
- * ALWAYS returns false: forcing broker-only there would break every headless
- * Linux/Windows read (CI, `agents run --headless`, routines, the Linux-driven
- * release flow) for no benefit — there is no prompt to suppress.
- *
- * A read in a macOS headless context resolves broker-only (agentOnly) and fails
- * fast with an actionable error instead of hijacking Touch ID. This generalizes
- * the per-caller broker-only pattern used across the headless secrets readers.
- */
-export function isHeadlessSecretsContext(env = process.env, platform = process.platform) {
-    if (platform !== 'darwin')
-        return false; // no biometry prompt to suppress off-darwin
-    // Every agent-launch runtime resolves broker-only, interactive included.
-    const runtime = env.AGENTS_RUNTIME;
-    if (runtime === 'headless' || runtime === 'teams' || runtime === 'terminal')
-        return true;
-    return false;
-}
-/**
- * True when this process runs structurally inside a coding-agent session: any
- * `agents run` launch (AGENTS_RUNTIME / AGENT_SESSION_ID ride the child env —
- * exec.ts buildExecEnv — and are inherited by every shell the agent spawns), or
- * a harness's own tool shell launched outside agents-cli (Claude Code stamps
- * CLAUDECODE on its Bash tool).
- *
- * Distinct from isHeadlessSecretsContext above on both axes: it is
- * platform-independent (no biometry involved), and a TTY does not clear it (an
- * agent inside tmux has one). Its job is the materialization boundary, not the
- * prompt boundary: a command that would PRINT a plaintext value refuses under
- * an agent, because anything printed lands in the agent's context and session
- * transcript. The agent path to secret values is injection — `secrets exec`,
- * `run --secrets` — which places them only in a child process env.
- */
-export function isAgentInvocationContext(env = process.env) {
-    return Boolean(env.AGENTS_RUNTIME ||
-        env.AGENT_SESSION_ID ||
-        env.AGENTS_SESSION_ID ||
-        env.CLAUDECODE);
-}

package/dist/lib/secrets/icloud-import.d.ts

@@ -1,79 +0,0 @@
-/**
- * Recovery for LEGACY SYNCHRONIZABLE (iCloud Keychain) bundles.
- *
- * The pre-biometry helper era defaulted bundles to iCloud Keychain sync. The
- * device-local cutover (biometry ACL + kSecAttrSynchronizable false on every
- * query) orphaned those items: they still sync back via iCloud Keychain, but
- * neither `secrets list` nor `migrate-acl` can see them. This module powers
- * `agents secrets import --from icloud` — discover the orphaned bundles,
- * re-import them as normal device-local bundles, and optionally purge the
- * iCloud copies.
- *
- * The item-name scheme is the same one the modern store uses (see bundles.ts):
- * metadata under `agents-cli.bundles.<name>`, one value per key under
- * `agents-cli.secrets.<bundle>.<key>`. Legacy env keys never contained a dot,
- * so metadata-less synced secret services split at their LAST dot to recover
- * the bundle/key boundary even for dotted bundle names like `hetzner.com`.
- */
-import { type SecretsBackend } from './bundles.js';
-/** One orphaned iCloud bundle, as discovered from the synced item names. */
-export interface SyncedBundleCandidate {
-    /** Bundle name derived from the iCloud service names. */
-    name: string;
-    /** Env keys that have a per-key secret item in the iCloud keychain. */
-    keys: string[];
-    /** True when an `agents-cli.bundles.<name>` metadata item exists in iCloud. */
-    hasMeta: boolean;
-    /** Every iCloud service name belonging to this candidate (the purge set). */
-    services: string[];
-}
-/**
- * Group raw synced service names into per-bundle candidates. Pure — separated
- * from discovery so the parsing rules are unit-testable without a keychain.
- *
- * A bundle can surface as metadata only (`agents-cli.bundles.<name>`), as
- * secret items only (`agents-cli.secrets.<bundle>.<KEY>` — metadata never
- * synced), or both; all three shapes appear in real iCloud strays, so every
- * one becomes a candidate.
- */
-export declare function groupSyncedServices(services: string[]): SyncedBundleCandidate[];
-/** Enumerate the iCloud keychain and return every orphaned bundle candidate. */
-export declare function discoverSyncedBundles(): SyncedBundleCandidate[];
-export interface ImportSyncedOptions {
-    /** Overwrite keys that already exist in the local bundle. */
-    force?: boolean;
-    /** Store imported values as literals in the bundle metadata (no keychain items). */
-    allPlaintext?: boolean;
-    /** Backend for a newly created bundle (existing bundles keep theirs). */
-    backend?: SecretsBackend;
-    /** Delete the iCloud copies of successfully-read items after import. */
-    purge?: boolean;
-}
-export interface ImportSyncedResult {
-    name: string;
-    added: number;
-    skipped: number;
-    /** Keys whose iCloud value could not be read (left in place, never purged). */
-    missing: string[];
-    /**
-     * Keys the modern store refuses by policy (reserved env names like USER,
-     * loader/interpreter vars like DYLD_*) — the pre-cutover store accepted
-     * them. Left in iCloud, never purged: the iCloud item is the only copy.
-     */
-    unimportable: string[];
-    purged: number;
-}
-/**
- * Import one discovered iCloud bundle into the local (device-local) store.
- *
- * Values come from the synced secret items; the synced metadata item, when
- * present, contributes the description, literal vars, and non-keychain refs
- * (env:/file:/exec: refs carry no stored secret, so copying the ref preserves
- * them exactly). Existing local keys are skipped unless `force`. Keys the
- * modern store refuses by policy (reserved / loader env names the pre-cutover
- * store accepted) are reported as `unimportable` instead of aborting the whole
- * bundle. With `purge`, only services whose value provably lives locally
- * (imported now, or skipped-because-present) are deleted from iCloud — an
- * unreadable or unimportable item is never destroyed.
- */
-export declare function importSyncedBundle(candidate: SyncedBundleCandidate, opts?: ImportSyncedOptions): ImportSyncedResult;

package/dist/lib/secrets/icloud-import.js

@@ -1,206 +0,0 @@
-/**
- * Recovery for LEGACY SYNCHRONIZABLE (iCloud Keychain) bundles.
- *
- * The pre-biometry helper era defaulted bundles to iCloud Keychain sync. The
- * device-local cutover (biometry ACL + kSecAttrSynchronizable false on every
- * query) orphaned those items: they still sync back via iCloud Keychain, but
- * neither `secrets list` nor `migrate-acl` can see them. This module powers
- * `agents secrets import --from icloud` — discover the orphaned bundles,
- * re-import them as normal device-local bundles, and optionally purge the
- * iCloud copies.
- *
- * The item-name scheme is the same one the modern store uses (see bundles.ts):
- * metadata under `agents-cli.bundles.<name>`, one value per key under
- * `agents-cli.secrets.<bundle>.<key>`. Legacy env keys never contained a dot,
- * so metadata-less synced secret services split at their LAST dot to recover
- * the bundle/key boundary even for dotted bundle names like `hetzner.com`.
- */
-import { deleteSyncedKeychainItem, getSyncedKeychainTokens, listSyncedKeychainItems, parseBundleValue, secretsKeychainItem, serializeRef, SECRETS_ITEM_PREFIX, } from './index.js';
-import { BUNDLE_META_PREFIX, BUNDLE_NAME_PATTERN, BUNDLE_KEY_PATTERN, ENV_KEY_PATTERN, bundleKeyToEnvKey, bundleExists, bundleItemStore, bundlePolicy, isLoaderOrInterpreterEnv, isReservedEnvName, keychainRef, readBundle, writeBundle, } from './bundles.js';
-/**
- * Group raw synced service names into per-bundle candidates. Pure — separated
- * from discovery so the parsing rules are unit-testable without a keychain.
- *
- * A bundle can surface as metadata only (`agents-cli.bundles.<name>`), as
- * secret items only (`agents-cli.secrets.<bundle>.<KEY>` — metadata never
- * synced), or both; all three shapes appear in real iCloud strays, so every
- * one becomes a candidate.
- */
-export function groupSyncedServices(services) {
-    const byName = new Map();
-    const claim = (name) => {
-        let c = byName.get(name);
-        if (!c) {
-            c = { name, keys: [], hasMeta: false, services: [] };
-            byName.set(name, c);
-        }
-        return c;
-    };
-    for (const svc of services) {
-        if (svc.startsWith(BUNDLE_META_PREFIX)) {
-            const name = svc.slice(BUNDLE_META_PREFIX.length);
-            if (!BUNDLE_NAME_PATTERN.test(name))
-                continue;
-            const c = claim(name);
-            c.hasMeta = true;
-            c.services.push(svc);
-        }
-        else if (svc.startsWith(SECRETS_ITEM_PREFIX)) {
-            const rest = svc.slice(SECRETS_ITEM_PREFIX.length);
-            const cut = rest.lastIndexOf('.');
-            if (cut <= 0)
-                continue;
-            const name = rest.slice(0, cut);
-            const key = rest.slice(cut + 1);
-            if (!BUNDLE_NAME_PATTERN.test(name) || !ENV_KEY_PATTERN.test(key))
-                continue;
-            const c = claim(name);
-            if (!c.keys.includes(key))
-                c.keys.push(key);
-            c.services.push(svc);
-        }
-    }
-    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-/** Enumerate the iCloud keychain and return every orphaned bundle candidate. */
-export function discoverSyncedBundles() {
-    return groupSyncedServices(listSyncedKeychainItems('agents-cli.'));
-}
-/**
- * Import one discovered iCloud bundle into the local (device-local) store.
- *
- * Values come from the synced secret items; the synced metadata item, when
- * present, contributes the description, literal vars, and non-keychain refs
- * (env:/file:/exec: refs carry no stored secret, so copying the ref preserves
- * them exactly). Existing local keys are skipped unless `force`. Keys the
- * modern store refuses by policy (reserved / loader env names the pre-cutover
- * store accepted) are reported as `unimportable` instead of aborting the whole
- * bundle. With `purge`, only services whose value provably lives locally
- * (imported now, or skipped-because-present) are deleted from iCloud — an
- * unreadable or unimportable item is never destroyed.
- */
-export function importSyncedBundle(candidate, opts = {}) {
-    const values = getSyncedKeychainTokens(candidate.services);
-    let bundle;
-    if (bundleExists(candidate.name)) {
-        bundle = readBundle(candidate.name);
-    }
-    else {
-        bundle = {
-            name: candidate.name,
-            backend: opts.backend === 'keychain' ? undefined : opts.backend,
-            vars: {},
-        };
-    }
-    const metaService = BUNDLE_META_PREFIX + candidate.name;
-    let metaVars = {};
-    const metaJson = values.get(metaService);
-    if (metaJson !== undefined) {
-        try {
-            const parsed = JSON.parse(metaJson);
-            if (parsed && typeof parsed === 'object') {
-                if (typeof parsed.description === 'string' && !bundle.description) {
-                    bundle.description = parsed.description;
-                }
-                if (parsed.vars && typeof parsed.vars === 'object') {
-                    metaVars = parsed.vars;
-                }
-            }
-        }
-        catch {
-            // Corrupt legacy metadata — the per-key secret items still import.
-        }
-    }
-    const store = bundleItemStore(bundle.backend, { noAcl: bundlePolicy(bundle) === 'never' });
-    let added = 0;
-    let skipped = 0;
-    const missing = [];
-    const unimportable = [];
-    // Services whose value now provably lives in the local store — imported this
-    // run, or skipped because the local bundle already carries the key. Only
-    // these may be purged; a missing or unimportable key's iCloud item is its
-    // only copy and must survive.
-    const purgeable = new Set();
-    const rejectedByPolicy = (key) => {
-        const envKey = bundleKeyToEnvKey(key);
-        return isLoaderOrInterpreterEnv(envKey) || isReservedEnvName(envKey);
-    };
-    // Keys with a synced secret item: re-store the value device-locally.
-    for (const key of candidate.keys) {
-        // The pre-cutover store accepted keys the modern one refuses (writeBundle
-        // throws) — skip them instead of aborting the whole bundle.
-        if (rejectedByPolicy(key)) {
-            unimportable.push(key);
-            continue;
-        }
-        const value = values.get(secretsKeychainItem(candidate.name, key));
-        if (value === undefined) {
-            missing.push(key);
-            continue;
-        }
-        if (!opts.force && key in bundle.vars) {
-            skipped++;
-            purgeable.add(secretsKeychainItem(candidate.name, key));
-            continue;
-        }
-        if (opts.allPlaintext) {
-            bundle.vars[key] = { value };
-        }
-        else {
-            store.set(secretsKeychainItem(candidate.name, key), value);
-            bundle.vars[key] = keychainRef(key);
-        }
-        purgeable.add(secretsKeychainItem(candidate.name, key));
-        added++;
-    }
-    // Vars declared only in the synced metadata: literals and non-keychain refs
-    // carry everything they need; a keychain ref without its synced item is
-    // unrecoverable.
-    for (const [key, raw] of Object.entries(metaVars)) {
-        if (!BUNDLE_KEY_PATTERN.test(key))
-            continue;
-        if (candidate.keys.includes(key))
-            continue; // the secret item already covered it
-        if (rejectedByPolicy(key)) {
-            if (!unimportable.includes(key))
-                unimportable.push(key);
-            continue;
-        }
-        let parsed;
-        try {
-            parsed = parseBundleValue(raw);
-        }
-        catch {
-            continue; // malformed legacy entry
-        }
-        if ('ref' in parsed && parsed.ref.provider === 'keychain') {
-            if (!missing.includes(key))
-                missing.push(key);
-            continue;
-        }
-        if (!opts.force && key in bundle.vars) {
-            skipped++;
-            continue;
-        }
-        bundle.vars[key] = 'literal' in parsed ? { value: parsed.literal } : serializeRef(parsed.ref);
-        added++;
-    }
-    writeBundle(bundle);
-    // The metadata item is only a projection of what was just written locally —
-    // safe to purge once writeBundle has succeeded, UNLESS it still names keys
-    // that never made it over (missing/unimportable): then it stays as the only
-    // record of them.
-    if (metaJson !== undefined && missing.length === 0 && unimportable.length === 0) {
-        purgeable.add(metaService);
-    }
-    let purged = 0;
-    if (opts.purge) {
-        for (const svc of candidate.services) {
-            if (!purgeable.has(svc))
-                continue;
-            if (deleteSyncedKeychainItem(svc))
-                purged++;
-        }
-    }
-    return { name: candidate.name, added, skipped, missing, unimportable, purged };
-}