@phnx-labs/agents-cli 1.20.0 → 1.20.3

package/dist/commands/profiles.js

@@ -8,10 +8,30 @@
  */
 import chalk from 'chalk';
 import * as fs from 'fs';
-import { listProfiles, readProfile, writeProfile, deleteProfile, profileExists, profileFromPreset, getPresetForProfile, } from '../lib/profiles.js';
-import { getPreset, listPresets } from '../lib/profiles-presets.js';
+import { spawn } from 'child_process';
+import { listProfiles, readProfile, writeProfile, deleteProfile, profileExists, profileFromPreset, validateProfileName, getPresetForProfile, } from '../lib/profiles.js';
+import { getPreset, listPresets, expandPreset } from '../lib/profiles-presets.js';
 import { hasKeychainToken, keychainItemName, setKeychainToken, deleteKeychainToken, } from '../lib/secrets/profiles.js';
 import { isInteractiveTerminal } from './utils.js';
+/**
+ * Pure helper: builds a Profile from collected wizard inputs. Extracted so the
+ * shape of preset->profile mapping for the `create` wizard is unit-testable
+ * without mocking @inquirer/prompts.
+ */
+export function buildProfileFromCollection(name, preset, collected, version) {
+    return {
+        name,
+        host: { agent: preset.host, version },
+        env: { ...preset.env, ...collected },
+        auth: {
+            envVar: preset.authEnvVar,
+            keychainItem: keychainItemName(preset.provider),
+        },
+        description: preset.description,
+        preset: preset.name,
+        provider: preset.provider,
+    };
+}
 /** Prompt the user for a secret value with masked input. Requires an interactive TTY. */
 async function promptForSecret(message) {
     if (!isInteractiveTerminal()) {
@@ -86,7 +106,8 @@ Built-in presets (via OpenRouter, one shared key):
 Run 'agents profiles presets' for the full list with pricing and context sizes.
 
 Typical flow:
-  agents profiles add kimi             # prompts for OpenRouter key, stored in Keychain
+  agents profiles create               # interactive wizard for any provider
+  agents profiles add kimi             # one-line preset (existing)
   agents run kimi "refactor this"      # Claude Code UI, Kimi model responses
   agents profiles add deepseek         # reuses OpenRouter key, no re-prompt
 
@@ -202,6 +223,96 @@ Examples:
             process.exit(1);
         }
     });
+    cmd
+        .command('create')
+        .description('Interactive profile creation wizard (any provider, with prompts for endpoints + keys).')
+        .option('--name <name>', 'Profile name (skips the name prompt)')
+        .option('--provider <provider>', 'Provider preset name (skips the provider prompt)')
+        .option('--no-smoke-test', 'Skip the post-create smoke test prompt')
+        .action(async (opts) => {
+        if (!isInteractiveTerminal()) {
+            console.error(chalk.red('agents profiles create requires an interactive terminal. Use `agents profiles add <preset>` for scriptable creation.'));
+            process.exit(1);
+        }
+        const { input, select, confirm } = await import('@inquirer/prompts');
+        const name = opts.name
+            ? opts.name
+            : await input({
+                message: 'Profile name',
+                validate: (v) => /^[a-z0-9][a-z0-9-_]{0,48}$/i.test(v) || 'lowercase alphanumeric + -_ only, max 48 chars',
+            });
+        validateProfileName(name);
+        if (profileExists(name)) {
+            const overwrite = await confirm({
+                message: `Profile '${name}' already exists. Overwrite?`,
+                default: false,
+            });
+            if (!overwrite) {
+                console.log(chalk.gray('Cancelled.'));
+                return;
+            }
+        }
+        const presets = listPresets();
+        const providerName = opts.provider
+            ? opts.provider
+            : await select({
+                message: 'Provider',
+                choices: presets.map((p) => ({
+                    name: `${p.name.padEnd(18)} ${chalk.gray(p.description.slice(0, 70))}`,
+                    value: p.name,
+                })),
+            });
+        const preset = getPreset(providerName);
+        if (!preset) {
+            console.error(chalk.red(`Unknown provider '${providerName}'. Run 'agents profiles presets' for the list.`));
+            process.exit(1);
+        }
+        const expanded = expandPreset(preset);
+        const collected = {};
+        for (const v of expanded.prompts) {
+            if (v.secret) {
+                collected[v.envVar] = await promptForSecret(v.prompt);
+            }
+            else {
+                const value = await input({
+                    message: v.hint ? `${v.prompt}  ${chalk.gray('(' + v.hint + ')')}` : v.prompt,
+                    default: v.default,
+                    validate: v.pattern
+                        ? (val) => new RegExp(v.pattern).test(val) || `must match ${v.pattern}`
+                        : undefined,
+                });
+                collected[v.envVar] = value;
+            }
+        }
+        if (!preset.authOptional) {
+            await ensureProviderToken(preset.provider, preset.signupUrl);
+        }
+        const profile = buildProfileFromCollection(name, preset, collected);
+        writeProfile(profile);
+        console.log(chalk.green(`Profile '${name}' created.`));
+        if (preset.docPath) {
+            console.log(chalk.gray(`See docs/profiles/${preset.docPath}.md for provider-specific caveats.`));
+        }
+        if (opts.smokeTest !== false) {
+            const run = await confirm({ message: 'Run smoke test now?', default: true });
+            if (run) {
+                console.log(chalk.gray(`Spawning: agents run ${name} "say alive in one word" (60s timeout)`));
+                const child = spawn(process.argv[0], [
+                    process.argv[1],
+                    'run',
+                    name,
+                    'say alive in one word',
+                    '--headless',
+                    '--timeout',
+                    '60s',
+                ], { stdio: 'inherit' });
+                child.on('exit', (code) => process.exit(code ?? 0));
+            }
+            else {
+                console.log(chalk.gray(`Try later: agents run ${name} "hello"`));
+            }
+        }
+    });
     cmd
         .command('add <name>')
         .description('Add a profile. If <name> matches a built-in preset, the preset is applied. Prompts for API key (once per provider).')
@@ -223,7 +334,9 @@ Examples:
                 console.error(chalk.gray('Or pass --preset <name> to pick explicitly.'));
                 process.exit(1);
             }
-            await ensureProviderToken(preset.provider, preset.signupUrl, opts.keyStdin);
+            if (!preset.authOptional) {
+                await ensureProviderToken(preset.provider, preset.signupUrl, opts.keyStdin);
+            }
             const profile = profileFromPreset(name, preset, opts.version);
             writeProfile(profile);
             console.log(chalk.green(`Profile '${name}' added.`));

package/dist/commands/pull.js

@@ -13,8 +13,8 @@ import { getUserAgentsDir, ensureAgentsDir, getEnabledExtraRepos, } from '../lib
 import { isGitRepo, pullRepo, isSystemRepoOrigin, } from '../lib/git.js';
 import * as fs from 'fs';
 import * as path from 'path';
-import { installVersion, listInstalledVersions, getGlobalDefault, setGlobalDefault, getVersionHomePath, syncResourcesToVersion, getAvailableResources, getActuallySyncedResources, getNewResources, hasNewResources, promptNewResourceSelection, promptResourceSelection, resolveConfiguredAgentTargets, } from '../lib/versions.js';
-import { listCliStatus, installCli, describeMethod, selectInstallMethod, } from '../lib/cli-resources.js';
+import { installVersion, listInstalledVersions, getGlobalDefault, setGlobalDefault, getVersionHomePath, syncResourcesToVersion, getAvailableResources, getActuallySyncedResources, getNewResources, getProjectOnlyResources, hasNewResources, promptNewResourceSelection, promptResourceSelection, resolveConfiguredAgentTargets, } from '../lib/versions.js';
+import { listCliStatus, installCli, describeMethod, describeCheck, selectInstallMethod, } from '../lib/cli-resources.js';
 import { ensureShimCurrent, isShimsInPath, addShimsToPath, getPathSetupInstructions, switchConfigSymlink, switchHomeFileSymlinks, } from '../lib/shims.js';
 import { parseHookManifest, registerHooksToSettings } from '../lib/hooks.js';
 import { setHelpSections } from '../lib/help.js';
@@ -219,7 +219,7 @@ export function registerPullCommand(program) {
                 if (!defaultVer)
                     continue;
                 const actuallySynced = getActuallySyncedResources(agentId, defaultVer);
-                const newResources = getNewResources(available, actuallySynced);
+                const newResources = getNewResources(available, actuallySynced, getProjectOnlyResources());
                 const hasAnySynced = actuallySynced.commands.length > 0 ||
                     actuallySynced.skills.length > 0 ||
                     actuallySynced.hooks.length > 0 ||
@@ -401,7 +401,7 @@ export function registerPullCommand(program) {
                                     }
                                 }
                                 else {
-                                    console.log(chalk.yellow(`  install ran but \`${s.manifest.check}\` still fails`));
+                                    console.log(chalk.yellow(`  install ran but \`${describeCheck(s.manifest.check)}\` still fails`));
                                 }
                             }
                         }

package/dist/commands/routines.js

@@ -11,7 +11,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
 import { isDaemonRunning, signalDaemonReload, startDaemon, stopDaemon, readDaemonPid, readDaemonLog, } from '../lib/daemon.js';
-import { humanizeCron, humanizeNextRun, formatRepoLink } from '../lib/routines-format.js';
+import { humanizeCron, humanizeNextRun, formatRepoLink, REPO_DISPLAY_MAX } from '../lib/routines-format.js';
 import { listJobs as listAllJobs, deleteJob, readJob, validateJob, writeJob, setJobEnabled, listRuns, getLatestRun, getRunDir, getJobPath, parseAtTime, } from '../lib/routines.js';
 import { getRoutinesDir } from '../lib/state.js';
 import { safeJoin } from '../lib/paths.js';
@@ -133,13 +133,13 @@ export function registerRoutinesCommands(program) {
         }
         console.log(chalk.bold('Scheduled Jobs\n'));
         // OSC 8 hyperlink helper — renders as a clickable link in supporting terminals.
-        // In terminals that do not support OSC 8 the escape sequences are ignored and
-        // the label is displayed as plain text.
-        const link = (label, url) => url ? `\x1b]8;;${url}\x07${label}\x1b]8;;\x07` : label;
+        // Guarded on process.stdout.isTTY so that piped/redirected output never
+        // contains raw ESC ] 8 ;; ... BEL escape sequences.
+        const link = (label, url) => url && process.stdout.isTTY ? `\x1b]8;;${url}\x07${label}\x1b]8;;\x07` : label;
         const now = new Date();
         const NAME_W = 24;
         const AGENT_W = 10;
-        const REPO_W = 24;
+        const REPO_W = REPO_DISPLAY_MAX;
         const SCHED_W = 22;
         const ENABLED_W = 10;
         const NEXT_W = 22;
@@ -184,7 +184,7 @@ export function registerRoutinesCommands(program) {
         .option('-a, --agent <agent>', 'Which agent runs this routine: claude, codex, gemini, cursor, or opencode')
         .option('--workflow <name>', 'Run an installed workflow (~/.agents/workflows/<name>) via `agents run`. Mutually exclusive with --agent.')
         .option('-p, --prompt <prompt>', 'Task instruction for the agent')
-        .option('-m, --mode <mode>', 'Execution mode: plan (read-only) or edit (can write files)', 'plan')
+        .option('-m, --mode <mode>', "Execution mode: plan (read-only), edit (can write files), auto (smart classifier), or skip (bypass all permission prompts). 'full' accepted as alias for skip.", 'plan')
         .option('-e, --effort <effort>', 'Reasoning effort: low | medium | high | xhigh | max | auto', 'auto')
         .option('-t, --timeout <timeout>', 'Kill the agent if it runs longer than this (e.g., 10m, 2h, 3d, 1w; max 1w)', '10m')
         .option('--timezone <tz>', 'Interpret schedule in this timezone (e.g., America/Los_Angeles)')

package/dist/commands/rules.js

@@ -7,11 +7,11 @@ import { select, checkbox } from '@inquirer/prompts';
 import { AGENTS, ALL_AGENT_IDS, resolveAgentName, formatAgentError, agentLabel, } from '../lib/agents.js';
 import { cloneRepo } from '../lib/git.js';
 import { discoverInstructionsFromRepo, discoverRuleFilesFromRepo, installInstructionsCentrally, uninstallInstructions, listInstalledInstructionsWithScope, instructionsExists, getInstructionsContent, listCentralRules, } from '../lib/rules/rules.js';
-import { listInstalledVersions, getGlobalDefault, resolveVersionAlias, syncResourcesToVersion, promptAgentVersionSelection, getVersionHomePath, resolveAgentVersionTargets, } from '../lib/versions.js';
+import { listInstalledVersions, getGlobalDefault, resolveVersionAlias, syncResourcesToVersion, promptAgentVersionSelection, getVersionHomePath, } from '../lib/versions.js';
 import { recordVersionResources, getActiveRulesPreset, setActiveRulesPreset } from '../lib/state.js';
 import { discoverRulesLayers } from '../lib/rules/compose.js';
 import * as yaml from 'yaml';
-import { isPromptCancelled, formatPath, isInteractiveTerminal, parseCommaSeparatedList, printWithPager, requireInteractiveSelection, requireDestructiveArg, } from './utils.js';
+import { isPromptCancelled, formatPath, isInteractiveTerminal, parseCommaSeparatedList, printWithPager, requireInteractiveSelection, requireDestructiveArg, resolveAgentTargetsAutoInstalling, } from './utils.js';
 /** Register the `agents rules` command tree (list, add, view, remove). */
 export function registerRulesCommands(program) {
     const rulesCmd = program
@@ -317,13 +317,17 @@ Examples:
             let selectedAgents;
             let versionSelections;
             if (options.agents) {
-                const result = resolveAgentVersionTargets(options.agents, ALL_AGENT_IDS);
+                const result = await resolveAgentTargetsAutoInstalling(options.agents, ALL_AGENT_IDS, { yes: options.yes });
+                if (!result) {
+                    console.log(chalk.gray('Cancelled.'));
+                    return;
+                }
                 selectedAgents = result.selectedAgents;
                 versionSelections = result.versionSelections;
             }
             else {
                 const result = await promptAgentVersionSelection(ALL_AGENT_IDS, {
-                    skipPrompts: options.yes || !isInteractiveTerminal(),
+                    skipPrompts: options.yes,
                 });
                 selectedAgents = result.selectedAgents;
                 versionSelections = result.versionSelections;

package/dist/commands/secrets-migrate.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `agents secrets migrate-acl` — refresh existing keychain items so they pick
+ * up the new SecAccess ACL written by the signed Agents CLI.app helper.
+ *
+ * Items created before 1.19.2 (or by `security add-generic-password` directly)
+ * may carry the legacy "this-app-only" ACL that prompts the user for a
+ * password on every read. Re-writing them through the helper bakes in the
+ * empty trusted-app ACL that suppresses the prompt and lets the helper read
+ * them under LocalAuthentication instead.
+ *
+ * Sequence per item:
+ *   1. Read the current value (no auth prompt path — uses the unauthenticated
+ *      `security` CLI for non-sync items, helper `get` for sync items).
+ *   2. Append (item, value, sync) to an encrypted backup before any writes.
+ *   3. Delete + rewrite via the helper so macOS hands us a fresh ACL on the
+ *      new item.
+ *   4. Read back via the helper to verify the value round-trips.
+ *
+ * `--dry-run` (default) reports the planned actions. `--commit` performs the
+ * writes and produces the backup.
+ */
+import type { Command } from 'commander';
+/** Register `agents secrets migrate-acl` on the parent secrets Command. */
+export declare function registerSecretsMigrateAclCommand(secrets: Command): void;

package/dist/commands/secrets-migrate.js

@@ -0,0 +1,198 @@
+/**
+ * `agents secrets migrate-acl` — refresh existing keychain items so they pick
+ * up the new SecAccess ACL written by the signed Agents CLI.app helper.
+ *
+ * Items created before 1.19.2 (or by `security add-generic-password` directly)
+ * may carry the legacy "this-app-only" ACL that prompts the user for a
+ * password on every read. Re-writing them through the helper bakes in the
+ * empty trusted-app ACL that suppresses the prompt and lets the helper read
+ * them under LocalAuthentication instead.
+ *
+ * Sequence per item:
+ *   1. Read the current value (no auth prompt path — uses the unauthenticated
+ *      `security` CLI for non-sync items, helper `get` for sync items).
+ *   2. Append (item, value, sync) to an encrypted backup before any writes.
+ *   3. Delete + rewrite via the helper so macOS hands us a fresh ACL on the
+ *      new item.
+ *   4. Read back via the helper to verify the value round-trips.
+ *
+ * `--dry-run` (default) reports the planned actions. `--commit` performs the
+ * writes and produces the backup.
+ */
+import chalk from 'chalk';
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+import { deleteKeychainToken, getKeychainToken, hasKeychainToken, listKeychainItems, setKeychainToken, } from '../lib/secrets/index.js';
+import { getBackupsDir } from '../lib/state.js';
+import { encryptBlob, MIN_PASSPHRASE_LEN } from '../lib/secrets/sync.js';
+import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
+const ITEM_PREFIX = 'agents-cli.';
+function enumerateItems() {
+    const seen = new Map();
+    for (const item of listKeychainItems(ITEM_PREFIX)) {
+        // hasKeychainToken with sync=false probes the non-synced keychain; the
+        // helper's list returns both. We don't try to distinguish — re-write with
+        // sync=false by default and only flip to sync=true if the value is only
+        // readable via the synced-only probe.
+        const localExists = hasKeychainToken(item);
+        seen.set(item, { item, sync: !localExists });
+    }
+    return [...seen.values()];
+}
+function writeEncryptedBackup(records, passphrase) {
+    const dir = getBackupsDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const iso = new Date().toISOString().replace(/[:.]/g, '-');
+    const file = path.join(dir, `keychain-pre-migrate-${iso}.json.enc`);
+    const envelope = encryptBlob(JSON.stringify({ v: 1, records }), passphrase);
+    fs.writeFileSync(file, JSON.stringify(envelope), { mode: 0o600 });
+    return file;
+}
+async function promptPassphrase() {
+    if (!isInteractiveTerminal()) {
+        throw new Error('A backup passphrase is required. Run from a TTY or set AGENTS_BACKUP_PASSPHRASE.');
+    }
+    const { password } = await import('@inquirer/prompts');
+    const first = await password({ message: 'Backup passphrase (used to encrypt the pre-migration snapshot)', mask: true });
+    if (first.length < MIN_PASSPHRASE_LEN)
+        throw new Error(`Passphrase must be at least ${MIN_PASSPHRASE_LEN} characters.`);
+    const second = await password({ message: 'Confirm passphrase', mask: true });
+    if (first !== second)
+        throw new Error('Passphrases do not match.');
+    return first;
+}
+function migrateOne(record) {
+    const { item, value } = record;
+    // Delete + re-add to force macOS to bind a fresh ACL on the new item.
+    // SecItemUpdate preserves the existing ACL, so an in-place rewrite would
+    // not fix the legacy "enter password" prompt.
+    try {
+        deleteKeychainToken(item);
+    }
+    catch (err) {
+        return { item, status: 'write-failed', detail: `delete: ${err.message}` };
+    }
+    try {
+        setKeychainToken(item, value);
+    }
+    catch (err) {
+        // Try to restore the old value so we don't lose data on a write failure.
+        // The backup is the durable safety net; this is best-effort UX.
+        try {
+            setKeychainToken(item, value);
+        }
+        catch { /* swallow */ }
+        return { item, status: 'write-failed', detail: `set: ${err.message}` };
+    }
+    let readBack;
+    try {
+        readBack = getKeychainToken(item);
+    }
+    catch (err) {
+        return { item, status: 'verify-failed', detail: `read-back: ${err.message}` };
+    }
+    if (readBack !== value) {
+        return { item, status: 'verify-failed', detail: 'value mismatch after rewrite' };
+    }
+    return { item, status: 'ok' };
+}
+/** Register `agents secrets migrate-acl` on the parent secrets Command. */
+export function registerSecretsMigrateAclCommand(secrets) {
+    secrets
+        .command('migrate-acl')
+        .description('Refresh existing keychain ACLs to use the signed Agents CLI helper. Dry-run by default.')
+        .option('--commit', 'Perform writes (default is dry-run reporting only)')
+        .option('--prefix <p>', `Restrict to items beginning with PREFIX (default ${ITEM_PREFIX})`, ITEM_PREFIX)
+        .option('--passphrase-env <var>', 'Read the backup passphrase from this env var instead of prompting')
+        .action(async (opts) => {
+        try {
+            if (process.platform !== 'darwin') {
+                throw new Error('migrate-acl is macOS-only. Linux items already use the keyring-native ACL model.');
+            }
+            const prefix = opts.prefix ?? ITEM_PREFIX;
+            if (!prefix.startsWith(ITEM_PREFIX)) {
+                throw new Error(`--prefix must start with '${ITEM_PREFIX}' to avoid touching unrelated Keychain items (got '${prefix}').`);
+            }
+            const items = listKeychainItems(prefix).map((item) => {
+                const localExists = hasKeychainToken(item);
+                return { item, sync: !localExists };
+            });
+            if (items.length === 0) {
+                console.log(chalk.gray(`No keychain items with prefix '${prefix}'.`));
+                return;
+            }
+            console.log(chalk.bold(`Found ${items.length} item(s) under '${prefix}'.`));
+            if (!opts.commit) {
+                for (const { item, sync } of items) {
+                    console.log(`  ${chalk.cyan(item)} ${chalk.gray(sync ? '(synced)' : '(local)')}`);
+                }
+                console.log();
+                console.log(chalk.gray('Dry-run — pass --commit to perform the migration.'));
+                return;
+            }
+            // Commit phase. Snapshot every value first, encrypt, then mutate.
+            const records = [];
+            for (const { item, sync } of items) {
+                try {
+                    const value = getKeychainToken(item);
+                    records.push({ item, sync, value });
+                }
+                catch (err) {
+                    console.error(chalk.red(`Skipping '${item}': read failed (${err.message}).`));
+                }
+            }
+            if (records.length === 0) {
+                console.error(chalk.red('No items could be read. Aborting before any writes.'));
+                process.exit(1);
+            }
+            const passphrase = opts.passphraseEnv
+                ? (() => {
+                    const v = process.env[opts.passphraseEnv];
+                    if (!v)
+                        throw new Error(`Env var '${opts.passphraseEnv}' not set.`);
+                    if (v.length < MIN_PASSPHRASE_LEN)
+                        throw new Error(`Passphrase must be at least ${MIN_PASSPHRASE_LEN} characters.`);
+                    return v;
+                })()
+                : await promptPassphrase();
+            const backupPath = writeEncryptedBackup(records, passphrase);
+            // Compute a quick fingerprint so the user can sanity-check recovery without
+            // decrypting. Hash of (count, sorted item names).
+            const fingerprint = crypto
+                .createHash('sha256')
+                .update(records.length + '\n' + records.map((r) => r.item).sort().join('\n'))
+                .digest('hex')
+                .slice(0, 12);
+            console.log(chalk.green(`Encrypted backup written to ${backupPath} (sha256-12: ${fingerprint}).`));
+            const results = [];
+            for (const record of records) {
+                const r = migrateOne(record);
+                results.push(r);
+                if (r.status === 'ok') {
+                    console.log(`  ${chalk.green('ok')}     ${record.item}`);
+                }
+                else {
+                    console.log(`  ${chalk.red(r.status)} ${record.item} ${chalk.gray(r.detail ?? '')}`);
+                }
+            }
+            const okCount = results.filter((r) => r.status === 'ok').length;
+            const failCount = results.length - okCount;
+            console.log();
+            if (failCount === 0) {
+                console.log(chalk.green(`Migrated ${okCount}/${results.length} item(s).`));
+            }
+            else {
+                console.error(chalk.yellow(`Migrated ${okCount}/${results.length} item(s); ${failCount} failed.`));
+                console.error(chalk.gray(`Restore from ${backupPath} using the backup passphrase if needed.`));
+                process.exit(1);
+            }
+        }
+        catch (err) {
+            if (isPromptCancelled(err))
+                return;
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/secrets-sync.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `agents secrets push|pull` subcommands.
+ *
+ * Replaces iCloud Keychain as the cross-device sync mechanism with explicit
+ * encrypted-at-rest sync against api.prix.dev. Plaintext never leaves the
+ * machine — bundle contents are sealed with AES-256-GCM under a user-supplied
+ * passphrase before upload.
+ */
+import type { Command } from 'commander';
+/** Register `agents secrets push|pull|remote-list` on the parent secrets Command. */
+export declare function registerSecretsSyncCommands(secrets: Command): void;

package/dist/commands/secrets-sync.js

@@ -0,0 +1,155 @@
+/**
+ * `agents secrets push|pull` subcommands.
+ *
+ * Replaces iCloud Keychain as the cross-device sync mechanism with explicit
+ * encrypted-at-rest sync against api.prix.dev. Plaintext never leaves the
+ * machine — bundle contents are sealed with AES-256-GCM under a user-supplied
+ * passphrase before upload.
+ */
+import chalk from 'chalk';
+import { listRemoteBundles, MIN_PASSPHRASE_LEN, pullBundle, pushBundle, } from '../lib/secrets/sync.js';
+import { bundleExists, listBundles } from '../lib/secrets/bundles.js';
+import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
+async function promptPassphrase(message, confirm = false) {
+    if (!isInteractiveTerminal()) {
+        throw new Error('A sync passphrase is required. Run from a TTY, or set AGENTS_SECRETS_PASSPHRASE.');
+    }
+    const { password } = await import('@inquirer/prompts');
+    const first = await password({ message, mask: true });
+    if (first.length < MIN_PASSPHRASE_LEN)
+        throw new Error(`Passphrase must be at least ${MIN_PASSPHRASE_LEN} characters.`);
+    if (!confirm)
+        return first;
+    const second = await password({ message: 'Confirm passphrase', mask: true });
+    if (first !== second)
+        throw new Error('Passphrases do not match.');
+    return first;
+}
+// Print the env-var-source warning at most once per process so a `--all` push
+// over many bundles doesn't flood stderr with the same notice.
+let envPassphraseWarned = false;
+function passphraseFromEnvOrPrompt(confirm) {
+    const fromEnv = process.env.AGENTS_SECRETS_PASSPHRASE;
+    if (fromEnv) {
+        if (fromEnv.length < MIN_PASSPHRASE_LEN) {
+            return Promise.reject(new Error(`Passphrase must be at least ${MIN_PASSPHRASE_LEN} characters.`));
+        }
+        if (!envPassphraseWarned) {
+            envPassphraseWarned = true;
+            process.stderr.write(chalk.yellow('warn: using AGENTS_SECRETS_PASSPHRASE. Env vars are readable by other same-user processes ' +
+                '(/proc, ps, crash dumps, CI logs) — rotate the passphrase after CI use.\n'));
+        }
+        return Promise.resolve(fromEnv);
+    }
+    return promptPassphrase('Sync passphrase', confirm);
+}
+/** Strip C0/C1 control bytes from server-supplied strings before terminal print. */
+function safePrint(s) {
+    return s.replace(/[\x00-\x08\x0B-\x1F\x7F-\x9F]/g, '');
+}
+/** Register `agents secrets push|pull|remote-list` on the parent secrets Command. */
+export function registerSecretsSyncCommands(secrets) {
+    secrets
+        .command('push [name]')
+        .description('Encrypt a local bundle and upload it to api.prix.dev (replaces iCloud Keychain sync).')
+        .option('--all', 'Push every local bundle (each prompts independently if no passphrase env var is set)')
+        .action(async (name, opts) => {
+        try {
+            if (opts.all) {
+                const bundles = listBundles();
+                if (bundles.length === 0) {
+                    console.log(chalk.gray('No local bundles to push.'));
+                    return;
+                }
+                const passphrase = await passphraseFromEnvOrPrompt(true);
+                for (const b of bundles) {
+                    try {
+                        const { updated_at } = await pushBundle(b.name, { passphrase });
+                        console.log(chalk.green(`Pushed '${b.name}' (updated_at=${updated_at}).`));
+                    }
+                    catch (err) {
+                        console.error(chalk.red(`Failed to push '${b.name}': ${err.message}`));
+                    }
+                }
+                return;
+            }
+            if (!name) {
+                throw new Error('Bundle name required. Try: agents secrets push <name> | agents secrets push --all');
+            }
+            if (!bundleExists(name)) {
+                throw new Error(`Bundle '${name}' not found locally.`);
+            }
+            const passphrase = await passphraseFromEnvOrPrompt(true);
+            const { updated_at } = await pushBundle(name, { passphrase });
+            console.log(chalk.green(`Pushed '${name}' to api.prix.dev (updated_at=${updated_at}).`));
+            console.log(chalk.gray('Remember the passphrase — it is required to pull this bundle on another machine.'));
+        }
+        catch (err) {
+            if (isPromptCancelled(err))
+                return;
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+    secrets
+        .command('pull [name]')
+        .description('Decrypt a remote bundle from api.prix.dev and restore it into the local keychain.')
+        .option('--all', 'Pull every bundle visible on the remote')
+        .option('--force', 'Overwrite a local bundle with the same name')
+        .action(async (name, opts) => {
+        try {
+            if (opts.all) {
+                const remote = await listRemoteBundles();
+                if (remote.length === 0) {
+                    console.log(chalk.gray('No remote bundles found.'));
+                    return;
+                }
+                const passphrase = await passphraseFromEnvOrPrompt(false);
+                for (const r of remote) {
+                    try {
+                        await pullBundle(r.name, { passphrase, force: opts.force });
+                        console.log(chalk.green(`Pulled '${r.name}'.`));
+                    }
+                    catch (err) {
+                        console.error(chalk.red(`Failed to pull '${r.name}': ${err.message}`));
+                    }
+                }
+                return;
+            }
+            if (!name) {
+                throw new Error('Bundle name required. Try: agents secrets pull <name> | agents secrets pull --all');
+            }
+            const passphrase = await passphraseFromEnvOrPrompt(false);
+            const bundle = await pullBundle(name, { passphrase, force: opts.force });
+            const keyCount = Object.keys(bundle.vars).length;
+            console.log(chalk.green(`Pulled '${name}' (${keyCount} key${keyCount === 1 ? '' : 's'}) into local keychain.`));
+        }
+        catch (err) {
+            if (isPromptCancelled(err))
+                return;
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+    secrets
+        .command('remote-list')
+        .alias('remote-ls')
+        .description('List bundles currently stored on api.prix.dev for this account.')
+        .action(async () => {
+        try {
+            const remote = await listRemoteBundles();
+            if (remote.length === 0) {
+                console.log(chalk.gray('No remote bundles found.'));
+                return;
+            }
+            console.log(chalk.bold(`${'NAME'.padEnd(24)} UPDATED_AT`));
+            for (const r of remote) {
+                console.log(`${chalk.cyan(safePrint(r.name).padEnd(24))} ${chalk.gray(safePrint(r.updated_at))}`);
+            }
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+}