@phnx-labs/agents-cli 1.22.84 → 1.22.85

package/dist/lib/secrets/list-filter.js

@@ -1,261 +0,0 @@
-/**
- * Filters for `agents secrets list`.
- *
- * The listing had no filtering at all: `--device`/`--device` pick a machine and
- * `--json` picks a format, but nothing selected over the bundles themselves. On
- * a fleet with fifty-odd bundles the answerable questions — which ones read with
- * no Touch ID at all, which hold a raw literal, which have already expired, what
- * has not been touched in three months — meant piping the table through grep, or
- * were simply unanswerable.
- *
- * Everything here is pure: parsing produces a `SecretsListFilter`, and
- * `bundleMatchesFilter` is a predicate over a bundle plus the ambient facts it
- * cannot derive itself (which bundles the broker currently holds, and the
- * current time). That keeps the whole surface unit-testable without a keychain.
- *
- * Shape follows the `agents sessions` house style: comma-separated lists, an
- * unknown value is a loud error naming the valid set (never a silent ignore),
- * and every axis narrows independently so they AND-compose.
- */
-import { parseCommaSeparatedList } from '../format.js';
-// From the leaf module, NOT discover.js — the latter imports `../sqlite.js`, so
-// reaching through it for one parser would pull node:sqlite into every `agents
-// secrets` invocation and print Node's SQLite ExperimentalWarning on stderr.
-import { parseTimeFilter } from '../text/relative-time.js';
-import { describeBundle, bundlePolicy, SECRET_TYPES, } from './bundles.js';
-/** Ref kinds a var's value can have, from `describeBundle`. */
-export const REF_KINDS = ['literal', 'keychain', 'env', 'file', 'exec'];
-const POLICIES = ['always', 'hold', 'never'];
-const BACKENDS = ['keychain', 'file', 'vault'];
-/** Default window for `--expiring` with no argument — matches the EXPIRING column. */
-export const DEFAULT_EXPIRING_DAYS = 30;
-/**
- * Validate one comma-separated enum list. An unknown value throws and names the
- * whole valid set — a silent ignore would let `--policy hodl` quietly return
- * every bundle, which reads as "nothing matches that" and is worse than an error.
- * Values are lowercased, matching `parsePolicyOpt`'s handling of policy names.
- */
-export function parseEnumList(raw, flag, valid) {
-    const parts = parseCommaSeparatedList(raw).map((s) => s.toLowerCase());
-    if (parts.length === 0) {
-        throw new Error(`${flag} requires at least one value. Valid values: ${valid.join(', ')}`);
-    }
-    for (const p of parts) {
-        if (!valid.includes(p)) {
-            throw new Error(`Invalid value "${p}" for ${flag}. Valid values: ${valid.join(', ')}`);
-        }
-    }
-    // De-dup so `--policy hold,hold` behaves like `--policy hold`.
-    return [...new Set(parts)];
-}
-/** Parse `--expiring` — a bare flag means the default window, a value means N days. */
-function parseExpiringDays(raw) {
-    if (raw === undefined || raw === false)
-        return undefined;
-    if (raw === true || raw === '')
-        return DEFAULT_EXPIRING_DAYS;
-    const n = Number(raw);
-    // 0 is rejected rather than accepted as a no-op: the window is `0 <= d < N`,
-    // so `--expiring 0` can never match anything, not even a key expiring today.
-    // A flag that silently returns nothing is worse than one that says why.
-    if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) {
-        throw new Error(`Invalid --expiring '${raw}'. Use a whole number of days >= 1, e.g. --expiring 7. ` +
-            'For keys that have already lapsed, use --expired.');
-    }
-    return n;
-}
-/** Build a validated filter from commander's option bag. Throws on bad input. */
-export function parseListFilters(opts, query) {
-    if (opts.held && opts.notHeld) {
-        throw new Error('--held and --not-held are mutually exclusive');
-    }
-    const filter = {};
-    const trimmedQuery = query?.trim();
-    if (trimmedQuery)
-        filter.query = trimmedQuery.toLowerCase();
-    if (opts.policy)
-        filter.policy = parseEnumList(opts.policy, '--policy', POLICIES);
-    if (opts.backend)
-        filter.backend = parseEnumList(opts.backend, '--backend', BACKENDS);
-    if (opts.type)
-        filter.type = parseEnumList(opts.type, '--type', SECRET_TYPES);
-    if (opts.kind)
-        filter.kind = parseEnumList(opts.kind, '--kind', REF_KINDS);
-    if (opts.held)
-        filter.held = true;
-    if (opts.notHeld)
-        filter.held = false;
-    if (opts.expired)
-        filter.expired = true;
-    const expiringDays = parseExpiringDays(opts.expiring);
-    if (expiringDays !== undefined)
-        filter.expiringDays = expiringDays;
-    if (opts.unused) {
-        // parseTimeFilter turns '90d' into "the epoch-ms 90 days ago"; a bundle is
-        // unused when its last_used predates that instant.
-        const cutoff = parseTimeFilter(opts.unused);
-        if (!cutoff) {
-            throw new Error(`Invalid --unused '${opts.unused}'. Use e.g. 30d, 4w, 3mo, or an ISO date.`);
-        }
-        filter.unusedBefore = cutoff;
-    }
-    return filter;
-}
-/** True when any axis is set — used to decide whether the empty state should
- * explain itself rather than claim there are no bundles at all. */
-export function filterIsActive(f) {
-    return Object.keys(f).length > 0;
-}
-/** Whole days from now until end-of-day UTC of an ISO date. Negative once past.
- * Mirrors the `daysUntil` used by the human render so the filter and the column
- * can never disagree about whether something has expired. */
-function daysUntil(iso, now) {
-    const target = new Date(`${iso}T23:59:59Z`).getTime();
-    return Math.floor((target - now) / (24 * 60 * 60 * 1000));
-}
-/** Expiry tallies for one bundle: how many vars are already past, and how many
- * fall due within `withinDays`. */
-export function bundleExpiry(b, now, withinDays = DEFAULT_EXPIRING_DAYS) {
-    let expired = 0;
-    let soon = 0;
-    for (const m of Object.values(b.meta ?? {})) {
-        if (!m.expires)
-            continue;
-        const d = daysUntil(m.expires, now);
-        if (d < 0)
-            expired++;
-        else if (d < withinDays)
-            soon++;
-    }
-    return { expired, soon };
-}
-/** Does this bundle satisfy every set axis? Pure. */
-export function bundleMatchesFilter(b, f, ctx) {
-    if (f.query) {
-        const haystack = `${b.name} ${b.description ?? ''}`.toLowerCase();
-        if (!haystack.includes(f.query))
-            return false;
-    }
-    if (f.policy && !f.policy.includes(bundlePolicy(b)))
-        return false;
-    if (f.backend && !f.backend.includes(b.backend ?? 'keychain'))
-        return false;
-    if (f.held !== undefined) {
-        // A lapsed entry is not held — same liveness rule the POLICY column uses.
-        const exp = ctx.held.get(b.name);
-        const isHeld = exp !== undefined && exp > ctx.now;
-        if (isHeld !== f.held)
-            return false;
-    }
-    if (f.type) {
-        const types = Object.values(b.meta ?? {}).map((m) => m.type).filter(Boolean);
-        if (!types.some((t) => f.type.includes(t)))
-            return false;
-    }
-    if (f.kind) {
-        const kinds = describeBundle(b).map((e) => e.kind);
-        if (!kinds.some((k) => f.kind.includes(k)))
-            return false;
-    }
-    if (f.expired || f.expiringDays !== undefined) {
-        const { expired, soon } = bundleExpiry(b, ctx.now, f.expiringDays ?? DEFAULT_EXPIRING_DAYS);
-        if (f.expired && expired === 0)
-            return false;
-        if (f.expiringDays !== undefined && soon === 0)
-            return false;
-    }
-    if (f.unusedBefore !== undefined) {
-        // Never used counts as unused — it is the strongest form of the answer.
-        if (b.last_used && new Date(b.last_used).getTime() >= f.unusedBefore)
-            return false;
-    }
-    return true;
-}
-/** Sort fields for `--sort`. `name` is the default and matches `listBundles()`.
- * `used` is most-recently-used first and `uses` is most-frequently-accessed
- * first; both read the value-free usage read-model (lib/secrets/usage-db.ts). */
-export const SORT_FIELDS = ['name', 'used', 'uses', 'created', 'updated', 'expiry'];
-export function parseSortField(raw) {
-    if (!raw)
-        return 'name';
-    const v = raw.toLowerCase();
-    if (!SORT_FIELDS.includes(v)) {
-        throw new Error(`Invalid --sort '${raw}'. Valid values: ${SORT_FIELDS.join(', ')}`);
-    }
-    return v;
-}
-/** Epoch-ms of a bundle's soonest expiry, or Infinity when nothing expires — so
- * `--sort expiry` puts the most urgent first and never-expiring bundles last. */
-function soonestExpiry(b) {
-    let soonest = Infinity;
-    for (const m of Object.values(b.meta ?? {})) {
-        if (!m.expires)
-            continue;
-        const t = new Date(`${m.expires}T23:59:59Z`).getTime();
-        if (t < soonest)
-            soonest = t;
-    }
-    return soonest;
-}
-/** Sort a copy. Time fields are most-recent-first (the useful direction for
- * "what did I touch lately"); `uses` is most-frequently-accessed first; `expiry`
- * is soonest-first; ties fall back to name so the order is stable. `usage`
- * carries the value-free read-model facts `used`/`uses` rank on — when omitted,
- * `used` falls back to the throttled `last_used` stamp and `uses` sees zero. */
-export function sortBundles(bundles, field, usage) {
-    const stamp = (iso) => (iso ? new Date(iso).getTime() : 0);
-    const byName = (a, z) => a.name.localeCompare(z.name);
-    // `used` combines the throttled keychain stamp with the exact usage-DB recency
-    // so a just-recorded access ranks a bundle even before its stamp catches up.
-    const usedMs = (b) => Math.max(stamp(b.last_used), stamp(usage?.get(b.name)?.lastUsedAt));
-    const usesOf = (b) => usage?.get(b.name)?.uses ?? 0;
-    const out = [...bundles];
-    if (field === 'name')
-        return out.sort(byName);
-    out.sort((a, z) => {
-        if (field === 'expiry') {
-            const d = soonestExpiry(a) - soonestExpiry(z);
-            return d !== 0 ? d : byName(a, z);
-        }
-        if (field === 'used') {
-            const d = usedMs(z) - usedMs(a);
-            return d !== 0 ? d : byName(a, z);
-        }
-        if (field === 'uses') {
-            const d = usesOf(z) - usesOf(a);
-            return d !== 0 ? d : byName(a, z);
-        }
-        const key = field === 'created' ? 'created_at' : 'updated_at';
-        const d = stamp(z[key]) - stamp(a[key]);
-        return d !== 0 ? d : byName(a, z);
-    });
-    return out;
-}
-/** Human summary of the active filters, for the empty state. `sessions` only
- * echoes --project/--all on a miss, which leaves you guessing which flag emptied
- * the list; naming every active axis is the difference between "nothing matched"
- * and knowing what to relax. */
-export function describeFilter(f) {
-    const parts = [];
-    if (f.query)
-        parts.push(`matching "${f.query}"`);
-    if (f.policy)
-        parts.push(`policy ${f.policy.join('/')}`);
-    if (f.backend)
-        parts.push(`backend ${f.backend.join('/')}`);
-    if (f.type)
-        parts.push(`type ${f.type.join('/')}`);
-    if (f.kind)
-        parts.push(`kind ${f.kind.join('/')}`);
-    if (f.held === true)
-        parts.push('currently held');
-    if (f.held === false)
-        parts.push('not currently held');
-    if (f.expired)
-        parts.push('with an expired key');
-    if (f.expiringDays !== undefined)
-        parts.push(`expiring within ${f.expiringDays}d`);
-    if (f.unusedBefore !== undefined)
-        parts.push('unused since the given cutoff');
-    return parts.join(', ');
-}

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

@@ -1,93 +0,0 @@
-/**
- * Zero-knowledge / JIT secret delivery over MCP (issue #333).
- *
- * A stdio MCP server exposing a single `get_secret(bundle, key)` tool. Unlike
- * `agents secrets exec`, which spawns the child process with EVERY resolved
- * value baked into `process.env` (any subprocess can `printenv` the lot — see
- * buildSecretsExecEnv in src/commands/secrets.ts), this server hands an
- * MCP-speaking agent framework ONE credential at a time, by name, at call
- * time. The raw value is returned only inside the tool result: it never enters
- * the child's environment, is never logged, and never appears in `tools/list`
- * metadata (names only).
- *
- * Resolution reuses the canonical bundle read path
- * (readAndResolveBundleEnv -> getKeychainToken); no keychain access is
- * re-implemented here. On Linux the libsecret backend (or its encrypted-file
- * fallback for locked/headless collections) applies transparently through that
- * abstraction, so the server stays backend-agnostic and works unchanged on
- * macOS.
- *
- * Transport: the MCP stdio transport is newline-delimited JSON-RPC 2.0 (one
- * message per line, UTF-8, no embedded newlines). That framing is trivial, so
- * we implement it directly rather than pull in the @modelcontextprotocol/sdk
- * server dependency — keeping the tree dependency-free and the handler pure and
- * unit-testable in-process.
- */
-/** MCP protocol revision this server negotiates. */
-export declare const MCP_PROTOCOL_VERSION = "2024-11-05";
-/** The single tool this server exposes. */
-export declare const GET_SECRET_TOOL = "get_secret";
-/** serverInfo.name reported at `initialize`. */
-export declare const MCP_SERVER_NAME = "agents-secrets";
-export interface JsonRpcRequest {
-    jsonrpc?: string;
-    id?: string | number | null;
-    method?: string;
-    params?: unknown;
-}
-interface JsonRpcSuccess {
-    jsonrpc: '2.0';
-    id: string | number | null;
-    result: unknown;
-}
-interface JsonRpcErrorResponse {
-    jsonrpc: '2.0';
-    id: string | number | null;
-    error: {
-        code: number;
-        message: string;
-    };
-}
-export type JsonRpcResponse = JsonRpcSuccess | JsonRpcErrorResponse;
-/** Per-bundle metadata for `tools/list` — names only, NEVER values. */
-export interface BundleKeyMetadata {
-    bundle: string;
-    description?: string;
-    keys: string[];
-}
-/**
- * Enumerate every bundle and its key names WITHOUT resolving or reading any
- * value. Mirrors how `agents secrets list` surfaces bundle metadata: names are
- * safe to expose, values are not. `listBundles()` reads only the bundle
- * metadata items (var definitions), never the secret items behind them.
- */
-export declare function listSecretMetadata(): BundleKeyMetadata[];
-/**
- * Resolve a single secret value by bundle + key through the canonical read
- * path. Throws a clear error when the bundle or the key is absent.
- *
- * The bundle metadata is read first (readBundle) so a missing key is reported
- * without triggering resolution — and, on macOS, without prompting Touch ID —
- * for the other keys in the bundle.
- */
-export declare function resolveSecret(bundle: string, key: string): string;
-/**
- * Handle one parsed JSON-RPC request. Returns the response object, or `null`
- * for notifications (which take no reply). Pure — no I/O, no logging — so tests
- * drive it directly.
- */
-export declare function handleMcpRequest(req: JsonRpcRequest, ctx?: {
-    version?: string;
-}): JsonRpcResponse | null;
-/**
- * Run the stdio MCP server: read newline-delimited JSON-RPC requests from
- * `input`, write responses to `output`. Resolves when the input stream ends.
- * Streams are injectable so tests can drive a full request/response loop
- * without spawning a process.
- */
-export declare function runSecretsMcpServer(opts?: {
-    input?: NodeJS.ReadableStream;
-    output?: NodeJS.WritableStream;
-    version?: string;
-}): Promise<void>;
-export {};

package/dist/lib/secrets/mcp.js

@@ -1,211 +0,0 @@
-/**
- * Zero-knowledge / JIT secret delivery over MCP (issue #333).
- *
- * A stdio MCP server exposing a single `get_secret(bundle, key)` tool. Unlike
- * `agents secrets exec`, which spawns the child process with EVERY resolved
- * value baked into `process.env` (any subprocess can `printenv` the lot — see
- * buildSecretsExecEnv in src/commands/secrets.ts), this server hands an
- * MCP-speaking agent framework ONE credential at a time, by name, at call
- * time. The raw value is returned only inside the tool result: it never enters
- * the child's environment, is never logged, and never appears in `tools/list`
- * metadata (names only).
- *
- * Resolution reuses the canonical bundle read path
- * (readAndResolveBundleEnv -> getKeychainToken); no keychain access is
- * re-implemented here. On Linux the libsecret backend (or its encrypted-file
- * fallback for locked/headless collections) applies transparently through that
- * abstraction, so the server stays backend-agnostic and works unchanged on
- * macOS.
- *
- * Transport: the MCP stdio transport is newline-delimited JSON-RPC 2.0 (one
- * message per line, UTF-8, no embedded newlines). That framing is trivial, so
- * we implement it directly rather than pull in the @modelcontextprotocol/sdk
- * server dependency — keeping the tree dependency-free and the handler pure and
- * unit-testable in-process.
- */
-import * as readline from 'readline';
-import { listBundles, readAndResolveBundleEnv, readBundle, validateBundleName, } from './bundles.js';
-/** MCP protocol revision this server negotiates. */
-export const MCP_PROTOCOL_VERSION = '2024-11-05';
-/** The single tool this server exposes. */
-export const GET_SECRET_TOOL = 'get_secret';
-/** serverInfo.name reported at `initialize`. */
-export const MCP_SERVER_NAME = 'agents-secrets';
-// JSON-RPC 2.0 error codes we use.
-const JSONRPC_PARSE_ERROR = -32700;
-const JSONRPC_INVALID_REQUEST = -32600;
-const JSONRPC_METHOD_NOT_FOUND = -32601;
-const JSONRPC_INVALID_PARAMS = -32602;
-/**
- * Enumerate every bundle and its key names WITHOUT resolving or reading any
- * value. Mirrors how `agents secrets list` surfaces bundle metadata: names are
- * safe to expose, values are not. `listBundles()` reads only the bundle
- * metadata items (var definitions), never the secret items behind them.
- */
-export function listSecretMetadata() {
-    return listBundles()
-        .map((b) => ({
-        bundle: b.name,
-        description: b.description,
-        keys: Object.keys(b.vars).sort(),
-    }))
-        .sort((a, b) => a.bundle.localeCompare(b.bundle));
-}
-/**
- * Resolve a single secret value by bundle + key through the canonical read
- * path. Throws a clear error when the bundle or the key is absent.
- *
- * The bundle metadata is read first (readBundle) so a missing key is reported
- * without triggering resolution — and, on macOS, without prompting Touch ID —
- * for the other keys in the bundle.
- */
-export function resolveSecret(bundle, key) {
-    validateBundleName(bundle);
-    // readBundle throws `Secrets bundle '<name>' not found.` for a missing bundle.
-    const meta = readBundle(bundle);
-    if (!Object.prototype.hasOwnProperty.call(meta.vars, key)) {
-        const available = Object.keys(meta.vars).sort();
-        throw new Error(`Key '${key}' not found in bundle '${bundle}'.` +
-            (available.length ? ` Available keys: ${available.join(', ')}.` : ' Bundle has no keys.'));
-    }
-    // An MCP `get_secret` tool call is a program asking for a value, never a human
-    // at a Touch ID sheet — so the read is always `agentOnly` (SEC-13: never pop
-    // biometry on its own). A `never`/no-ACL or broker-held bundle resolves
-    // silently; a locked bundle THROWS the actionable "unlock <name>" message,
-    // which propagates as the MCP tool error (the caller surfaces it) rather than
-    // popping an unanswerable prompt.
-    const { env } = readAndResolveBundleEnv(bundle, { caller: 'secrets-mcp', keys: [key], keyMode: 'storage', agentOnly: true });
-    const value = env[key];
-    if (value === undefined) {
-        throw new Error(`Key '${key}' in bundle '${bundle}' could not be resolved.`);
-    }
-    return value;
-}
-/** Build the `get_secret` tool definition, advertising available names only. */
-function getSecretToolDefinition() {
-    let catalog = '(no bundles configured)';
-    try {
-        const meta = listSecretMetadata();
-        if (meta.length > 0) {
-            catalog = meta
-                .map((b) => `${b.bundle}: ${b.keys.length ? b.keys.join(', ') : '(no keys)'}`)
-                .join(' | ');
-        }
-    }
-    catch {
-        // Listing is best-effort decoration; never fail tools/list because the
-        // keychain enumeration hiccuped.
-        catalog = '(unavailable)';
-    }
-    return {
-        name: GET_SECRET_TOOL,
-        description: 'Fetch a single secret value by bundle + key, resolved at call time. The value ' +
-            'is returned only in this tool result and never enters the process environment. ' +
-            `Available bundles and keys (names only): ${catalog}`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                bundle: { type: 'string', description: 'Secrets bundle name' },
-                key: { type: 'string', description: 'Key / env-var name within the bundle' },
-            },
-            required: ['bundle', 'key'],
-            additionalProperties: false,
-        },
-    };
-}
-function success(id, result) {
-    return { jsonrpc: '2.0', id, result };
-}
-function rpcError(id, code, message) {
-    return { jsonrpc: '2.0', id, error: { code, message } };
-}
-/**
- * A tool-execution failure. Per the MCP spec, tool errors are reported IN the
- * result (`isError: true`) — not as a JSON-RPC error — so the model sees and
- * can react to the message. The value channel (`content`) still carries no
- * secret here.
- */
-function toolError(id, message) {
-    return success(id, { content: [{ type: 'text', text: message }], isError: true });
-}
-function handleToolCall(id, params) {
-    const p = (params ?? {});
-    if (p.name !== GET_SECRET_TOOL) {
-        return rpcError(id, JSONRPC_INVALID_PARAMS, `Unknown tool: ${String(p.name)}`);
-    }
-    const args = (p.arguments ?? {});
-    if (typeof args.bundle !== 'string' || !args.bundle || typeof args.key !== 'string' || !args.key) {
-        return toolError(id, `${GET_SECRET_TOOL} requires non-empty string 'bundle' and 'key' arguments.`);
-    }
-    try {
-        const value = resolveSecret(args.bundle, args.key);
-        return success(id, { content: [{ type: 'text', text: value }] });
-    }
-    catch (err) {
-        return toolError(id, err.message);
-    }
-}
-/**
- * Handle one parsed JSON-RPC request. Returns the response object, or `null`
- * for notifications (which take no reply). Pure — no I/O, no logging — so tests
- * drive it directly.
- */
-export function handleMcpRequest(req, ctx = {}) {
-    const id = req.id ?? null;
-    const isNotification = req.id === undefined || req.id === null;
-    switch (req.method) {
-        case 'initialize':
-            return success(id, {
-                protocolVersion: MCP_PROTOCOL_VERSION,
-                capabilities: { tools: {} },
-                serverInfo: { name: MCP_SERVER_NAME, version: ctx.version ?? '0.0.0' },
-            });
-        case 'notifications/initialized':
-        case 'initialized':
-            return null; // notification — no response
-        case 'ping':
-            return success(id, {});
-        case 'tools/list':
-            return success(id, { tools: [getSecretToolDefinition()] });
-        case 'tools/call':
-            return handleToolCall(id, req.params);
-        default:
-            if (isNotification)
-                return null; // unknown notification — stay silent
-            return rpcError(id, JSONRPC_METHOD_NOT_FOUND, `Method not found: ${String(req.method)}`);
-    }
-}
-function writeMessage(output, msg) {
-    output.write(JSON.stringify(msg) + '\n');
-}
-/**
- * Run the stdio MCP server: read newline-delimited JSON-RPC requests from
- * `input`, write responses to `output`. Resolves when the input stream ends.
- * Streams are injectable so tests can drive a full request/response loop
- * without spawning a process.
- */
-export async function runSecretsMcpServer(opts = {}) {
-    const input = opts.input ?? process.stdin;
-    const output = opts.output ?? process.stdout;
-    const rl = readline.createInterface({ input, crlfDelay: Infinity });
-    for await (const line of rl) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        let req;
-        try {
-            req = JSON.parse(trimmed);
-        }
-        catch {
-            writeMessage(output, rpcError(null, JSONRPC_PARSE_ERROR, 'Parse error'));
-            continue;
-        }
-        if (!req || typeof req !== 'object' || typeof req.method !== 'string') {
-            writeMessage(output, rpcError((req && req.id) ?? null, JSONRPC_INVALID_REQUEST, 'Invalid Request'));
-            continue;
-        }
-        const res = handleMcpRequest(req, { version: opts.version });
-        if (res)
-            writeMessage(output, res);
-    }
-}

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

@@ -1,10 +0,0 @@
-/**
- * Thin compatibility shim over the shared secrets library.
- *
- * Profile tokens are stored at `agents-cli.<provider>.token`; secrets bundles
- * live at `agents-cli.secrets.<bundle>.<KEY>`. Both go through the same
- * keychain primitives in ./index.ts.
- */
-export { hasKeychainToken, getKeychainToken, setKeychainToken, deleteKeychainToken, } from './index.js';
-/** Map a provider name to its keychain item identifier. */
-export declare function keychainItemName(provider: string): string;

package/dist/lib/secrets/profiles.js

@@ -1,13 +0,0 @@
-/**
- * Thin compatibility shim over the shared secrets library.
- *
- * Profile tokens are stored at `agents-cli.<provider>.token`; secrets bundles
- * live at `agents-cli.secrets.<bundle>.<KEY>`. Both go through the same
- * keychain primitives in ./index.ts.
- */
-export { hasKeychainToken, getKeychainToken, setKeychainToken, deleteKeychainToken, } from './index.js';
-import { profileKeychainItem } from './index.js';
-/** Map a provider name to its keychain item identifier. */
-export function keychainItemName(provider) {
-    return profileKeychainItem(provider);
-}