@phnx-labs/agents-cli 1.20.0 → 1.20.4

package/dist/commands/hooks.js

@@ -8,9 +8,9 @@ import { AGENTS, HOOKS_CAPABLE_AGENTS, resolveAgentName, formatAgentError, agent
 import { supports } from '../lib/capabilities.js';
 import { cloneRepo } from '../lib/git.js';
 import { discoverHooksFromRepo, installHooksCentrally, listCentralHooks, listInstalledHooksWithScope, getHookInfo, parseHookManifest, iterHooksCapableVersions, removeHookFromVersion, } from '../lib/hooks.js';
-import { listInstalledVersions, getGlobalDefault, resolveVersionAlias, syncResourcesToVersion, promptAgentVersionSelection, getVersionHomePath, resolveAgentVersionTargets, } from '../lib/versions.js';
+import { listInstalledVersions, getGlobalDefault, resolveVersionAlias, syncResourcesToVersion, promptAgentVersionSelection, getVersionHomePath, resolveInstalledAgentTargets, } from '../lib/versions.js';
 import { recordVersionResources } from '../lib/state.js';
-import { isPromptCancelled, isInteractiveTerminal, parseCommaSeparatedList, printWithPager, requireInteractiveSelection, promptRemovalTargets, } from './utils.js';
+import { isPromptCancelled, isInteractiveTerminal, parseCommaSeparatedList, printWithPager, requireInteractiveSelection, promptRemovalTargets, resolveAgentTargetsAutoInstalling, } from './utils.js';
 /** Register the `agents hooks` command tree (list, add, remove, sync, prune, view). */
 export function registerHooksCommands(program) {
     const hooksCmd = program.command('hooks')
@@ -340,13 +340,17 @@ Examples:
             let versionSelections;
             const hooksCapableAgents = Array.from(HOOKS_CAPABLE_AGENTS);
             if (options.agents) {
-                const result = resolveAgentVersionTargets(options.agents, hooksCapableAgents);
+                const result = await resolveAgentTargetsAutoInstalling(options.agents, hooksCapableAgents, { yes: options.yes });
+                if (!result) {
+                    console.log(chalk.gray('Cancelled.'));
+                    return;
+                }
                 selectedAgents = result.selectedAgents;
                 versionSelections = result.versionSelections;
             }
             else {
                 const result = await promptAgentVersionSelection(hooksCapableAgents, {
-                    skipPrompts: options.yes || !isInteractiveTerminal(),
+                    skipPrompts: options.yes,
                 });
                 selectedAgents = result.selectedAgents;
                 versionSelections = result.versionSelections;
@@ -459,11 +463,24 @@ Examples:
                 console.log(chalk.yellow(`  Hook '${hookName}' not found in any version.`));
                 continue;
             }
-            // Filter by --agents if specified
+            // Filter by --agents if specified. Routes through resolveInstalledAgentTargets
+            // so the same selector syntax used everywhere else (agent, agent@default,
+            // agent@x.y.z, agent@all, literal all) works here too.
             let availableTargets = hookInfo.targets;
             if (options?.agents) {
-                const requestedAgents = new Set(options.agents.split(','));
-                availableTargets = availableTargets.filter((t) => requestedAgents.has(t.agent));
+                const requestedTargets = resolveInstalledAgentTargets(options.agents, [...HOOKS_CAPABLE_AGENTS]);
+                const requested = new Set();
+                for (const aid of requestedTargets.directAgents) {
+                    for (const ver of listInstalledVersions(aid)) {
+                        requested.add(`${aid}@${ver}`);
+                    }
+                }
+                for (const [aid, versions] of requestedTargets.versionSelections) {
+                    for (const ver of versions) {
+                        requested.add(`${aid}@${ver}`);
+                    }
+                }
+                availableTargets = availableTargets.filter((t) => requested.has(`${t.agent}@${t.version}`));
             }
             if (availableTargets.length === 0) {
                 console.log(chalk.yellow(`  Hook '${hookName}' not found in specified agents.`));
@@ -579,4 +596,66 @@ Examples:
             printWithPager(output, contentLines.length);
         }
     });
+    hooksCmd
+        .command('profile')
+        .description('Per-hook timing + cache stats from recent invocations')
+        .option('--days <n>', 'Number of days of logs to read', '7')
+        .option('--warn-ms <n>', 'p99 threshold above which a hook is flagged as slow', '2000')
+        .option('--json', 'Emit raw JSON rows instead of the table')
+        .addHelpText('after', `
+Shows aggregated stats for every hook that emitted a hook.fire event into
+~/.agents/.cache/logs/events-YYYY-MM-DD.jsonl. Only hooks with \`cache:\` in
+their manifest are instrumented today — the generated shim writes the events.
+
+Examples:
+  agents hooks profile                # last 7 days, table form
+  agents hooks profile --days 30      # roll up the full month
+  agents hooks profile --json | jq    # pipe somewhere
+
+A hook whose p99 exceeds --warn-ms gets flagged in the cache column. Add
+'cache: 5m' or 'cache: 5m-bg' to its hooks.yaml entry to fix it.
+`)
+        .action(async (options) => {
+        const { aggregateHookProfile, loadHookFireEvents, formatMs, formatCacheColumn, DEFAULT_SLOW_HOOK_WARN_MS } = await import('../lib/hooks/profile.js');
+        const days = Math.max(1, parseInt(options.days, 10) || 7);
+        const warnMs = Math.max(0, parseInt(options.warnMs, 10) || DEFAULT_SLOW_HOOK_WARN_MS);
+        const rows = aggregateHookProfile(loadHookFireEvents(days));
+        if (options.json) {
+            console.log(JSON.stringify(rows, null, 2));
+            return;
+        }
+        if (rows.length === 0) {
+            console.log(chalk.gray(`No hook.fire events in the last ${days} day${days === 1 ? '' : 's'}.`));
+            console.log(chalk.gray('Add \'cache: 5m\' to a hook in hooks.yaml to start collecting stats.'));
+            return;
+        }
+        const widths = { hook: 36, n: 5, p50: 7, p99: 7, mean: 7, max: 7, cache: 30 };
+        const pad = (s, w) => (s.length >= w ? s.slice(0, w) : s + ' '.repeat(w - s.length));
+        const header = [
+            pad('HOOK', widths.hook),
+            pad('N', widths.n),
+            pad('P50', widths.p50),
+            pad('P99', widths.p99),
+            pad('MEAN', widths.mean),
+            pad('MAX', widths.max),
+            pad('CACHE', widths.cache),
+        ].join(' ');
+        console.log(chalk.bold(header));
+        console.log(chalk.gray('─'.repeat(header.length)));
+        for (const r of rows) {
+            const slow = r.p99Ms > warnMs;
+            const cacheCol = formatCacheColumn(r);
+            const warning = slow && r.cacheHitPct + r.cacheStalePct === 0 ? '  ← add cache: 5m' : '';
+            const line = [
+                pad(r.hook, widths.hook),
+                pad(String(r.n), widths.n),
+                pad(formatMs(r.p50Ms), widths.p50),
+                pad(formatMs(r.p99Ms), widths.p99),
+                pad(formatMs(r.meanMs), widths.mean),
+                pad(formatMs(r.maxMs), widths.max),
+                pad(cacheCol, widths.cache),
+            ].join(' ') + warning;
+            console.log(slow ? chalk.yellow(line) : line);
+        }
+    });
 }

package/dist/commands/import.js

@@ -23,12 +23,13 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import { confirm } from '@inquirer/prompts';
 import { ALL_AGENT_IDS } from '../lib/agents.js';
 import { AGENTS, getCliPath, getCliVersion, agentLabel } from '../lib/agents.js';
 import { getVersionDir } from '../lib/versions.js';
-import { finalizeImport, importAgentBinary, importAgentConfig, isValidImportVersion, resolvePackageDirFromBinary, } from '../lib/import.js';
+import { finalizeImport, importAgentBinary, importAgentConfig, importInstallScriptBinary, isValidImportVersion, resolvePackageDirFromBinary, } from '../lib/import.js';
 import { isPromptCancelled, isInteractiveTerminal } from './utils.js';
 function isValidAgentId(value) {
     return ALL_AGENT_IDS.includes(value);
@@ -41,54 +42,94 @@ async function runImport(agentArg, opts) {
     }
     const agentId = agentArg;
     const agent = AGENTS[agentId];
-    // Reject agents that don't ship via npm before we spin up PATH lookups and
-    // prompts. cursor/kiro/goose/roo all have npmPackage='' and use custom
-    // install scripts — the symlink-farm import doesn't apply to them.
-    if (!agent.npmPackage) {
-        console.error(chalk.red(`${agentLabel(agentId)} doesn't install via npm — \`agents import\` only handles npm-style packages.`));
-        console.error(chalk.gray(`Use \`agents add ${agentId}\` to install via its native script.`));
-        process.exit(1);
-    }
+    // installScript-based agents (Grok, Antigravity, Cursor, Kiro, Goose, Roo)
+    // don't have an npm package; their binary lives wherever the curl/brew
+    // installer dropped it. We adopt by symlinking that PATH binary directly
+    // into the version's `node_modules/.bin/`. No package.json walk.
+    const isInstallScriptAgent = !agent.npmPackage;
     let globalPath = null;
+    let installScriptBinary = null;
     if (opts.fromPath) {
         globalPath = path.resolve(opts.fromPath);
         if (!fs.existsSync(globalPath)) {
             console.error(chalk.red(`Path does not exist: ${globalPath}`));
             process.exit(1);
         }
+        if (isInstallScriptAgent) {
+            // With --from-path on an installScript agent, the path is the binary
+            // itself (or a directory containing it). Accept either.
+            if (fs.statSync(globalPath).isDirectory()) {
+                const candidate = path.join(globalPath, agent.cliCommand);
+                if (!fs.existsSync(candidate)) {
+                    console.error(chalk.red(`No "${agent.cliCommand}" in ${globalPath}`));
+                    process.exit(1);
+                }
+                installScriptBinary = candidate;
+            }
+            else {
+                installScriptBinary = globalPath;
+            }
+        }
     }
     else {
         const binary = await getCliPath(agentId);
         if (!binary) {
-            // Use || (not ??) so empty-string npmPackage falls back to cliCommand.
-            // Defensive: agents with empty npmPackage are rejected above, but keep
-            // the operator correct in case that early check is ever relaxed.
-            const installName = agent.npmPackage || agent.cliCommand;
+            const installHint = isInstallScriptAgent
+                ? `Run \`agents add ${agentId}\` to install via the official script, or pass --from-path.`
+                : `Install it first (e.g. \`npm i -g ${agent.npmPackage || agent.cliCommand}\`) or pass --from-path.`;
             console.error(chalk.red(`No "${agent.cliCommand}" found on PATH.`));
-            console.error(chalk.gray(`Install it first (e.g. \`npm i -g ${installName}\`) or pass --from-path.`));
+            console.error(chalk.gray(installHint));
             process.exit(1);
         }
-        globalPath = resolvePackageDirFromBinary(binary);
-        if (!globalPath) {
-            console.error(chalk.red(`Could not resolve npm package for binary: ${binary}`));
-            console.error(chalk.gray('Pass --from-path <dir> with the package directory explicitly.'));
-            process.exit(1);
+        if (isInstallScriptAgent) {
+            installScriptBinary = binary;
+        }
+        else {
+            globalPath = resolvePackageDirFromBinary(binary);
+            if (!globalPath) {
+                console.error(chalk.red(`Could not resolve npm package for binary: ${binary}`));
+                console.error(chalk.gray('Pass --from-path <dir> with the package directory explicitly.'));
+                process.exit(1);
+            }
+        }
+    }
+    // For Grok, the binary on PATH is typically `~/.grok/bin/grok` (a moving
+    // pointer to the latest install). Prefer the exact versioned file in
+    // `~/.grok/downloads/` so the v<x.y.z> alias is pinned to that file and
+    // doesn't drift when the user upgrades externally.
+    if (isInstallScriptAgent && agentId === 'grok' && !opts.fromPath) {
+        const detected = await getCliVersion(agentId);
+        if (detected) {
+            const downloads = path.join(os.homedir(), '.grok', 'downloads');
+            try {
+                const entries = fs.readdirSync(downloads);
+                const exact = entries.find((e) => e.startsWith('grok-') && e.includes(detected));
+                if (exact) {
+                    installScriptBinary = path.join(downloads, exact);
+                }
+            }
+            catch {
+                /* fall back to PATH binary already set above */
+            }
         }
     }
     let version = opts.version;
     if (!version) {
-        try {
-            const pkg = JSON.parse(fs.readFileSync(path.join(globalPath, 'package.json'), 'utf8'));
-            version = typeof pkg.version === 'string' ? pkg.version : undefined;
-        }
-        catch {
-            /* fall through */
+        if (!isInstallScriptAgent && globalPath) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(path.join(globalPath, 'package.json'), 'utf8'));
+                version = typeof pkg.version === 'string' ? pkg.version : undefined;
+            }
+            catch {
+                /* fall through */
+            }
         }
         // Only fall back to running the PATH binary's --version when we're
-        // auto-detecting. With --from-path, the PATH binary may belong to a
-        // different install entirely; reporting its version here would silently
-        // mis-attribute the imported version.
-        if (!version && !opts.fromPath) {
+        // auto-detecting. With --from-path on an npm agent, the PATH binary may
+        // belong to a different install entirely; reporting its version here
+        // would silently mis-attribute the imported version. installScript agents
+        // always use `<bin> --version` since they have no package.json to read.
+        if (!version && (isInstallScriptAgent || !opts.fromPath)) {
             const detected = await getCliVersion(agentId);
             version = detected ?? undefined;
         }
@@ -104,8 +145,9 @@ async function runImport(agentArg, opts) {
         process.exit(1);
     }
     const versionDir = getVersionDir(agentId, version);
+    const fromLabel = isInstallScriptAgent ? installScriptBinary : globalPath;
     console.log(chalk.bold(`\nImport ${agentLabel(agentId)} v${version}`));
-    console.log(`  from: ${chalk.gray(globalPath)}`);
+    console.log(`  from: ${chalk.gray(fromLabel)}`);
     console.log(`  into: ${chalk.gray(versionDir)}`);
     const configDirExists = fs.existsSync(agent.configDir);
     let configAlreadyManaged = false;
@@ -146,7 +188,8 @@ async function runImport(agentArg, opts) {
         const cfgSpinner = ora(`Importing config dir for ${agentLabel(agentId)} v${version}...`).start();
         const cfgResult = await importAgentConfig(agentId, version);
         if (cfgResult.success) {
-            cfgSpinner.succeed(`Config imported (${agent.configDir} -> ${versionDir}/home/.${agentId})`);
+            const relConfig = path.relative(os.homedir(), agent.configDir);
+            cfgSpinner.succeed(`Config imported (${agent.configDir} -> ${versionDir}/home/${relConfig})`);
         }
         else if (cfgResult.skipped) {
             cfgSpinner.warn(`Config: ${cfgResult.error}`);
@@ -157,9 +200,11 @@ async function runImport(agentArg, opts) {
         }
     }
     const binSpinner = ora(`Registering ${agentLabel(agentId)} v${version} binary...`).start();
-    const binResult = importAgentBinary({ agentId, npmPackage: agent.npmPackage, cliCommand: agent.cliCommand }, version, globalPath, versionDir);
+    const binResult = isInstallScriptAgent
+        ? importInstallScriptBinary({ agentId, npmPackage: agent.npmPackage, cliCommand: agent.cliCommand }, version, installScriptBinary, versionDir)
+        : importAgentBinary({ agentId, npmPackage: agent.npmPackage, cliCommand: agent.cliCommand }, version, globalPath, versionDir);
     if (binResult.success) {
-        binSpinner.succeed(`Binary registered (${agent.cliCommand} -> ${globalPath})`);
+        binSpinner.succeed(`Binary registered (${agent.cliCommand} -> ${binResult.resolvedFromPath})`);
     }
     else if (binResult.skipped) {
         binSpinner.warn(`Binary: ${binResult.error}`);
@@ -198,11 +243,19 @@ Examples:
   $ agents import openclaw --version 2026.3.8       Pin a version label
   $ agents import openclaw --from-path /opt/homebrew/lib/node_modules/openclaw
 
+  # installScript-based agents (curl/brew installers, no npm package):
+  $ agents import grok                              Adopt ~/.grok/downloads/grok-<ver>
+  $ agents import antigravity                       Adopt ~/.local/bin/agy
+  $ agents import cursor                            Adopt ~/.local/bin/cursor-agent
+  $ agents import antigravity --from-path ~/.local/bin/agy
+
 When to use:
-  When an agent CLI is already installed globally via npm or homebrew and you
-  want to bring it under agents-cli management without reinstalling. Creates a
-  symlink farm pointing at the existing install — nothing is copied or moved
-  (except the agent's config dir, which is moved into the version's home).
+  When an agent CLI is already installed globally and you want to bring it
+  under agents-cli management without reinstalling. Creates a symlink farm
+  pointing at the existing install — nothing is copied or moved (except the
+  agent's config dir, which is moved into the version's home). Works for both
+  npm-style packages (claude, codex, gemini, opencode, openclaw) and
+  installScript-based agents (grok, antigravity, cursor, kiro, goose, roo).
 `)
         .action(runImport);
 }

package/dist/commands/mcp.js

@@ -3,20 +3,49 @@ import ora from 'ora';
 import { checkbox } from '@inquirer/prompts';
 import { AGENTS, MCP_CAPABLE_AGENTS, getAllCliStates, resolveAgentName, formatAgentError, registerMcpToTargets, unregisterMcpFromTargets, listInstalledMcpsWithScope, parseMcpConfig, getMcpConfigPathForHome, agentLabel, } from '../lib/agents.js';
 import { readManifest, writeManifest, createDefaultManifest } from '../lib/manifest.js';
-import { listMcpServerConfigs } from '../lib/mcp.js';
+import { listMcpServerConfigs, discoverMcpConfigsFromRepo, installMcpConfigCentrally, } from '../lib/mcp.js';
+import { cloneRepo } from '../lib/git.js';
 import { getMcpDir } from '../lib/state.js';
-import { getEffectiveHome, getGlobalDefault, listInstalledVersions, getVersionHomePath, resolveInstalledAgentTargets, resolveConfiguredAgentTargets, resolveVersionAlias, } from '../lib/versions.js';
+import { getEffectiveHome, getGlobalDefault, listInstalledVersions, getVersionHomePath, resolveInstalledAgentTargets, resolveConfiguredAgentTargets, resolveVersionAlias, syncResourcesToVersion, } from '../lib/versions.js';
 import { getUserAgentsDir } from '../lib/state.js';
-import { isPromptCancelled, isInteractiveTerminal, requireInteractiveSelection, promptRemovalTargets } from './utils.js';
+import { isPromptCancelled, isInteractiveTerminal, requireInteractiveSelection, promptRemovalTargets, parseCommaSeparatedList, ensureAgentVersionsInstalled, resolveAgentTargetsAutoInstalling, resolveInstalledAgentTargetsAutoInstalling, VersionNotInstalledError, } from './utils.js';
 import { showResourceList, buildTargetsSection, } from './resource-view.js';
-/** Parse a comma-separated --agents string into validated agent IDs and optional version targets. */
+/**
+ * Parse a comma-separated --agents string into validated agent IDs and
+ * optional version targets in the manifest shape.
+ *
+ * Supports the same selector syntax as resolveAgentVersionTargets:
+ *   - bare `agent`        → manifest agents:[agent] (no version pin)
+ *   - `agent@default`     → manifest agents:[agent] (no version pin)
+ *   - `agent@x.y.z`       → manifest agentVersions[agent] = ['x.y.z']
+ *   - `agent@all`         → manifest agentVersions[agent] = every installed version
+ *   - literal `all`       → expand to all MCP-capable agents (each as `@all`)
+ *
+ * Throws VersionNotInstalledError for unknown specific versions so callers
+ * can prompt-and-install before retrying.
+ */
 function parseMcpAgentTargets(value) {
     const agents = [];
     const agentVersions = {};
-    const targets = value
+    const rawTargets = value
         .split(',')
         .map((item) => item.trim())
         .filter(Boolean);
+    // Expand literal `all` / `all@all` into per-agent @all. Skip agents with no
+    // installed versions so `all` is lenient — mirrors resolveAgentVersionTargets.
+    const targets = [];
+    for (const t of rawTargets) {
+        if (t === 'all' || t === 'all@all') {
+            for (const a of MCP_CAPABLE_AGENTS) {
+                if (listInstalledVersions(a).length > 0) {
+                    targets.push(`${a}@all`);
+                }
+            }
+        }
+        else {
+            targets.push(t);
+        }
+    }
     for (const target of targets) {
         const atIndex = target.indexOf('@');
         const agentToken = (atIndex === -1 ? target : target.slice(0, atIndex)).trim();
@@ -25,7 +54,7 @@ function parseMcpAgentTargets(value) {
             continue;
         }
         if (atIndex !== -1 && !versionToken) {
-            throw new Error(`Missing version in --agents entry '${target}'. Use agent@x.y.z or agent@default.`);
+            throw new Error(`Missing version in --agents entry '${target}'. Use agent@x.y.z, agent@default, or agent@all.`);
         }
         const agentId = resolveAgentName(agentToken);
         if (!agentId || !MCP_CAPABLE_AGENTS.includes(agentId)) {
@@ -50,11 +79,23 @@ function parseMcpAgentTargets(value) {
         if (installedVersions.length === 0) {
             throw new Error(`No managed versions are installed for ${AGENTS[agentId].name}. Run: agents add ${agentId}@latest`);
         }
+        if (versionToken === 'all') {
+            const versions = agentVersions[agentId] || [];
+            for (const ver of installedVersions) {
+                if (!versions.includes(ver))
+                    versions.push(ver);
+            }
+            agentVersions[agentId] = versions;
+            if (!agents.includes(agentId)) {
+                agents.push(agentId);
+            }
+            continue;
+        }
         const resolvedVersion = versionToken === 'latest'
             ? installedVersions[installedVersions.length - 1]
             : versionToken;
         if (!installedVersions.includes(resolvedVersion)) {
-            throw new Error(`Version ${resolvedVersion} is not installed for ${AGENTS[agentId].name}. Installed versions: ${installedVersions.join(', ')}`);
+            throw new VersionNotInstalledError(agentId, resolvedVersion, installedVersions);
         }
         const versions = agentVersions[agentId] || [];
         if (!versions.includes(resolvedVersion)) {
@@ -140,6 +181,8 @@ When to use:
         .option('-a, --agents <list>', 'Targets: claude, codex@0.116.0', MCP_CAPABLE_AGENTS.join(','))
         .option('-s, --scope <scope>', 'user (global) or project (repo-specific)', 'user')
         .option('-t, --transport <type>', 'stdio (default) or http', 'stdio')
+        .option('--names <list>', 'When source is a repo: MCP server names to install (comma-separated)')
+        .option('-y, --yes', 'Auto-install any missing agent versions without prompting')
         .option('-H, --header <header>', 'HTTP header as name:value (repeatable)', (val, acc) => {
         acc.push(val);
         return acc;
@@ -154,8 +197,22 @@ Examples:
 
   # Add to manifest only (register later)
   agents mcp add db-server -- uvx postgres-mcp
+
+  # Install all MCP server configs from a repo's mcp/*.yaml
+  agents mcp add gh:user/repo --agents claude@all
+
+  # Install specific servers by name
+  agents mcp add gh:phnx-labs/.agents-system --names notion,figma --agents claude
 `)
         .action(async (name, commandOrUrl, options) => {
+        // Repo-source form: `agents mcp add gh:user/repo [--names a,b] [--agents …]`
+        // Mirrors `agents skills add gh:…`. Discovers <repoPath>/mcp/*.yaml,
+        // copies to ~/.agents/mcp/, and syncs to selected agent versions.
+        const isRepoSource = /^(gh:|git:|ssh:|https?:\/\/)/.test(name);
+        if (isRepoSource && commandOrUrl.length === 0) {
+            await installMcpsFromRepoSource(name, options);
+            return;
+        }
         // Registry resolution: if the user just typed `agents mcp add <name>`,
         // try looking up `<name>` in any configured MCP registry (by default the
         // official MCP Registry at registry.modelcontextprotocol.io) and derive
@@ -195,6 +252,13 @@ Examples:
         const localPath = getUserAgentsDir();
         const manifest = readManifest(localPath) || createDefaultManifest();
         manifest.mcp = manifest.mcp || {};
+        // Pre-flight: prompt-and-install any requested agent@version that isn't
+        // installed yet, before parseMcpAgentTargets validates the selector.
+        const okInstall = await ensureAgentVersionsInstalled(options.agents, MCP_CAPABLE_AGENTS, { yes: options.yes });
+        if (!okInstall) {
+            console.log(chalk.gray('Cancelled.'));
+            return;
+        }
         const targetConfig = parseMcpAgentTargets(options.agents);
         if (transport === 'http') {
             const url = commandOrUrl[0];
@@ -459,6 +523,7 @@ Examples:
         .command('register [name]')
         .description('Apply MCP servers from manifest to agent config files')
         .option('-a, --agents <list>', 'Override manifest targets: claude, codex@0.116.0')
+        .option('-y, --yes', 'Auto-install any missing agent versions without prompting')
         .addHelpText('after', `
 Examples:
   # Register all servers from manifest
@@ -495,9 +560,18 @@ Examples:
                 continue;
             }
             console.log(`\n  ${chalk.cyan(mcpName)}:`);
-            const targets = options.agents
-                ? resolveInstalledAgentTargets(options.agents, MCP_CAPABLE_AGENTS)
-                : resolveConfiguredAgentTargets(config.agents, config.agentVersions, MCP_CAPABLE_AGENTS);
+            let targets;
+            if (options.agents) {
+                const resolved = await resolveInstalledAgentTargetsAutoInstalling(options.agents, MCP_CAPABLE_AGENTS, { yes: options.yes });
+                if (!resolved) {
+                    console.log(chalk.gray('  Cancelled.'));
+                    continue;
+                }
+                targets = resolved;
+            }
+            else {
+                targets = resolveConfiguredAgentTargets(config.agents, config.agentVersions, MCP_CAPABLE_AGENTS);
+            }
             const results = await registerMcpToTargets(targets, mcpName, commandOrUrl, config.scope || 'user', transport, { headers: config.headers });
             for (const result of results) {
                 if (result.success) {
@@ -513,6 +587,88 @@ Examples:
         }
     });
 }
+async function installMcpsFromRepoSource(source, options) {
+    const spinner = ora('Cloning repository...').start();
+    let localPath;
+    try {
+        const cloneResult = await cloneRepo(source);
+        localPath = cloneResult.localPath;
+    }
+    catch (err) {
+        spinner.fail(`Failed to clone: ${err.message}`);
+        process.exit(1);
+    }
+    spinner.succeed('Repository cloned');
+    let discovered = discoverMcpConfigsFromRepo(localPath);
+    if (discovered.length === 0) {
+        console.log(chalk.yellow('No MCP server configs found (looking for mcp/*.yaml)'));
+        return;
+    }
+    const requestedNames = parseCommaSeparatedList(options.names);
+    if (requestedNames.length > 0) {
+        const discoveredNames = new Set(discovered.map((s) => s.name));
+        const missing = requestedNames.filter((n) => !discoveredNames.has(n));
+        if (missing.length > 0) {
+            console.log(chalk.red(`\nMCP server(s) not found in source: ${missing.join(', ')}`));
+            console.log(chalk.gray(`Available: ${[...discoveredNames].join(', ')}`));
+            process.exit(1);
+        }
+        discovered = discovered.filter((s) => requestedNames.includes(s.name));
+    }
+    console.log(chalk.bold(`\nFound ${discovered.length} MCP server config(s):`));
+    for (const s of discovered) {
+        const summary = s.config.transport === 'stdio'
+            ? `${s.config.command}${s.config.args?.length ? ' ' + s.config.args.join(' ') : ''}`
+            : s.config.url ?? '';
+        console.log(`  ${chalk.cyan(s.name)}: ${chalk.gray(summary)}`);
+    }
+    const installSpinner = ora('Installing MCP configs to ~/.agents/mcp/...').start();
+    let installed = 0;
+    for (const s of discovered) {
+        const result = installMcpConfigCentrally(s.path);
+        if (result.success) {
+            installed++;
+        }
+        else {
+            installSpinner.stop();
+            console.log(chalk.red(`  Failed to install ${s.name}: ${result.error}`));
+            installSpinner.start();
+        }
+    }
+    installSpinner.succeed(`Installed ${installed} MCP config(s) to ~/.agents/mcp/`);
+    // Agent/version selection — same default as the non-repo form: every
+    // MCP-capable agent. Routes through resolveAgentTargetsAutoInstalling so
+    // a typo'd `claude@2.1.999` prompts to install (and --yes auto-installs).
+    const agentsValue = options.agents ?? MCP_CAPABLE_AGENTS.join(',');
+    let targets;
+    try {
+        const resolved = await resolveAgentTargetsAutoInstalling(agentsValue, MCP_CAPABLE_AGENTS, { yes: options.yes });
+        if (!resolved) {
+            console.log(chalk.gray('\nCancelled.'));
+            return;
+        }
+        targets = resolved;
+    }
+    catch (err) {
+        console.log(chalk.red(err.message));
+        process.exit(1);
+    }
+    if (targets.versionSelections.size === 0) {
+        console.log(chalk.gray('\nStored centrally; no agent versions selected for sync.'));
+        return;
+    }
+    const syncSpinner = ora('Syncing to agent versions...').start();
+    const mcpNames = discovered.map((s) => s.name);
+    let synced = 0;
+    for (const [agentId, versions] of targets.versionSelections) {
+        for (const version of versions) {
+            const result = syncResourcesToVersion(agentId, version, { mcp: mcpNames });
+            if (result.mcp.length > 0)
+                synced++;
+        }
+    }
+    syncSpinner.succeed(`Synced MCP configs to ${synced} agent version(s).`);
+}
 /** Enumerate (agent, version) pairs that support MCP and have a version home. */
 function iterMcpCapableVersions(filter) {
     const out = [];