@phnx-labs/agents-cli 1.20.0 → 1.20.3

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 = [];

package/dist/commands/packages.js

@@ -14,10 +14,13 @@ import { cloneRepo } from '../lib/git.js';
 import { discoverCommands, resolveCommandSource, installCommand, installCommandCentrally, } from '../lib/commands.js';
 import { discoverSkillsFromRepo, installSkill, installSkillCentrally, } from '../lib/skills.js';
 import { discoverHooksFromRepo, installHooks, installHooksCentrally, } from '../lib/hooks.js';
-import { listInstalledVersions, resolveInstalledAgentTargets, resolveConfiguredAgentTargets, syncResourcesToVersion, } from '../lib/versions.js';
-import { isInteractiveTerminal, isPromptCancelled, requireDestructiveArg, requireInteractiveSelection, } from './utils.js';
+import { discoverWorkflowsFromRepo, installWorkflowCentrally, } from '../lib/workflows.js';
+import { discoverSubagentsFromRepo, installSubagentCentrally, } from '../lib/subagents.js';
+import { discoverPermissionsFromRepo, installPermissionSet, } from '../lib/permissions.js';
+import { listInstalledVersions, resolveConfiguredAgentTargets, syncResourcesToVersion, } from '../lib/versions.js';
+import { isInteractiveTerminal, isPromptCancelled, parseCommaSeparatedList, requireDestructiveArg, requireInteractiveSelection, resolveInstalledAgentTargetsAutoInstalling, } from './utils.js';
 import { itemPicker } from '../lib/picker.js';
-import { registerMcpCommandToTargets } from '../lib/mcp.js';
+import { registerMcpCommandToTargets, discoverMcpConfigsFromRepo, installMcpConfigCentrally, } from '../lib/mcp.js';
 export function buildMcpPackageCommand(pkg) {
     const packageName = pkg.name || pkg.registry_name;
     if (pkg.runtime === 'node') {
@@ -326,6 +329,9 @@ When to use:
         .command('install <identifier>')
         .description('Install a package by registry name (mcp:notion), GitHub URL (gh:user/repo), or skill identifier')
         .option('-a, --agents <list>', 'Targets: claude, codex@0.116.0, or gemini@default')
+        .option('--types <list>', 'When source is a repo: comma-separated resource types to install (skills,workflows,commands,hooks,permissions,subagents,mcp)')
+        .option('--names <list>', 'When source is a repo: comma-separated resource names within the selected types')
+        .option('-y, --yes', 'Auto-install any missing agent versions without prompting')
         .addHelpText('after', `
 Install resolves the package type (MCP server, skill, command, hook) and installs to the specified agents. Packages can come from registries (mcp:, skill:), GitHub (gh:user/repo), or direct URLs.
 
@@ -339,6 +345,12 @@ Examples:
   # Install using GitHub shorthand
   agents install gh:user/repo --agents claude@2.1.112
 
+  # Install only specific resource types from a multi-resource repo
+  agents install gh:phnx-labs/.agents-system --types skills,workflows --agents claude@all
+
+  # Install specific resources by name
+  agents install gh:phnx-labs/.agents-system --types skills --names animator,composer --agents claude@all
+
   # Install to all installed agents (uses defaults or prompts)
   agents install mcp:postgres
 
@@ -399,9 +411,18 @@ When to use:
                 }
                 const cliStates = await getAllCliStates();
                 const installedAgents = MCP_CAPABLE_AGENTS.filter((id) => cliStates[id]?.installed || listInstalledVersions(id).length > 0);
-                const targets = options.agents
-                    ? resolveInstalledAgentTargets(options.agents, MCP_CAPABLE_AGENTS)
-                    : resolveConfiguredAgentTargets(installedAgents, undefined, 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.'));
+                        return;
+                    }
+                    targets = resolved;
+                }
+                else {
+                    targets = resolveConfiguredAgentTargets(installedAgents, undefined, MCP_CAPABLE_AGENTS);
+                }
                 if (targets.selectedAgents.length === 0) {
                     console.log(chalk.yellow('\nNo MCP-capable agents installed.'));
                     process.exit(1);
@@ -420,38 +441,95 @@ When to use:
                 console.log(chalk.green('\nMCP server installed.'));
             }
             else if (resolved.type === 'git' || resolved.type === 'skill') {
-                // Install from git source (skills/commands/hooks)
+                // Install from git source: sniff every resource type the repo
+                // contains. Optional --types narrows which kinds get installed;
+                // --names narrows which specific resources within those kinds.
                 console.log(chalk.bold(`\nInstalling from ${resolved.source}`));
                 const { localPath } = await cloneRepo(resolved.source);
-                // Discover what's in the repo
-                const commands = discoverCommands(localPath);
-                const skills = discoverSkillsFromRepo(localPath);
-                const hooks = discoverHooksFromRepo(localPath);
-                const hasCommands = commands.length > 0;
-                const hasSkills = skills.length > 0;
-                const hasHooks = hooks.length > 0;
-                if (!hasCommands && !hasSkills && !hasHooks) {
+                const requestedTypes = new Set(parseCommaSeparatedList(options.types));
+                const includeType = (type) => requestedTypes.size === 0 || requestedTypes.has(type);
+                const requestedNames = new Set(parseCommaSeparatedList(options.names));
+                const nameFilter = (items) => {
+                    if (requestedNames.size === 0)
+                        return items;
+                    return items.filter((item) => requestedNames.has(item.name));
+                };
+                // Discover everything; filter to requested types up front so the
+                // summary table reflects what will actually be installed.
+                let commands = includeType('commands') ? discoverCommands(localPath) : [];
+                let skills = includeType('skills') ? discoverSkillsFromRepo(localPath) : [];
+                let hooks = includeType('hooks') ? discoverHooksFromRepo(localPath) : [];
+                let workflows = includeType('workflows') ? discoverWorkflowsFromRepo(localPath) : [];
+                let subagents = includeType('subagents') ? discoverSubagentsFromRepo(localPath) : [];
+                let permissions = includeType('permissions') ? discoverPermissionsFromRepo(localPath) : [];
+                let mcpServers = includeType('mcp') ? discoverMcpConfigsFromRepo(localPath) : [];
+                // --names filter applies across every discovered type. If the user
+                // typed a name that matched nothing, fail loud so they can fix the
+                // typo rather than silently install zero items.
+                if (requestedNames.size > 0) {
+                    const allNames = new Set([
+                        ...commands.map((c) => c.name),
+                        ...skills.map((s) => s.name),
+                        ...hooks,
+                        ...workflows.map((w) => w.name),
+                        ...subagents.map((s) => s.name),
+                        ...permissions.map((p) => p.name),
+                        ...mcpServers.map((s) => s.name),
+                    ]);
+                    const missing = [...requestedNames].filter((n) => !allNames.has(n));
+                    if (missing.length > 0) {
+                        console.log(chalk.red(`\nResource(s) not found in repo: ${missing.join(', ')}`));
+                        console.log(chalk.gray(`Available: ${[...allNames].sort().join(', ')}`));
+                        process.exit(1);
+                    }
+                    commands = nameFilter(commands);
+                    skills = nameFilter(skills);
+                    hooks = hooks.filter((h) => requestedNames.has(h));
+                    workflows = nameFilter(workflows);
+                    subagents = nameFilter(subagents);
+                    permissions = nameFilter(permissions);
+                    mcpServers = nameFilter(mcpServers);
+                }
+                const summary = [
+                    { kind: 'commands', count: commands.length },
+                    { kind: 'skills', count: skills.length },
+                    { kind: 'hooks', count: hooks.length },
+                    { kind: 'workflows', count: workflows.length },
+                    { kind: 'subagents', count: subagents.length },
+                    { kind: 'permissions', count: permissions.length },
+                    { kind: 'mcp', count: mcpServers.length },
+                ].filter((s) => s.count > 0);
+                if (summary.length === 0) {
                     console.log(chalk.yellow('No installable content found in repository.'));
+                    if (requestedTypes.size > 0 || requestedNames.size > 0) {
+                        console.log(chalk.gray('Try removing --types/--names to see everything the repo offers.'));
+                    }
                     process.exit(1);
                 }
                 console.log(chalk.bold('\nFound:'));
-                if (hasCommands)
-                    console.log(`  ${commands.length} commands`);
-                if (hasSkills)
-                    console.log(`  ${skills.length} skills`);
-                if (hasHooks)
-                    console.log(`  ${hooks.length} hooks`);
+                for (const { kind, count } of summary) {
+                    console.log(`  ${count} ${kind}`);
+                }
                 const gitCliStates = await getAllCliStates();
                 const installedAgents = ALL_AGENT_IDS.filter((id) => gitCliStates[id]?.installed || listInstalledVersions(id).length > 0);
-                const targets = options.agents
-                    ? resolveInstalledAgentTargets(options.agents, ALL_AGENT_IDS)
-                    : resolveConfiguredAgentTargets(installedAgents, undefined, ALL_AGENT_IDS);
+                let targets;
+                if (options.agents) {
+                    const resolved = await resolveInstalledAgentTargetsAutoInstalling(options.agents, ALL_AGENT_IDS, { yes: options.yes });
+                    if (!resolved) {
+                        console.log(chalk.gray('Cancelled.'));
+                        return;
+                    }
+                    targets = resolved;
+                }
+                else {
+                    targets = resolveConfiguredAgentTargets(installedAgents, undefined, ALL_AGENT_IDS);
+                }
                 if (targets.selectedAgents.length === 0) {
                     console.log(chalk.yellow('\nNo agents selected.'));
                     return;
                 }
                 // Install commands
-                if (hasCommands) {
+                if (commands.length > 0) {
                     console.log(chalk.bold('\nInstalling commands...'));
                     let directInstalled = 0;
                     let syncedVersions = 0;
@@ -495,7 +573,7 @@ When to use:
                     }
                 }
                 // Install skills
-                if (hasSkills) {
+                if (skills.length > 0) {
                     console.log(chalk.bold('\nInstalling skills...'));
                     const directAgents = targets.directAgents.filter((agentId) => AGENTS[agentId].capabilities.skills && gitCliStates[agentId]?.installed);
                     let syncedVersions = 0;
@@ -522,7 +600,7 @@ When to use:
                     console.log(`  Synced skills to ${syncedVersions} managed version(s)`);
                 }
                 // Install hooks
-                if (hasHooks) {
+                if (hooks.length > 0) {
                     console.log(chalk.bold('\nInstalling hooks...'));
                     let syncedVersions = 0;
                     const directHookAgents = targets.directAgents.filter((id) => AGENTS[id].supportsHooks && gitCliStates[id]?.installed);
@@ -543,6 +621,97 @@ When to use:
                     }
                     console.log(`  Synced hooks to ${syncedVersions} managed version(s)`);
                 }
+                // Install workflows
+                if (workflows.length > 0) {
+                    console.log(chalk.bold('\nInstalling workflows...'));
+                    let installed = 0;
+                    for (const w of workflows) {
+                        const result = installWorkflowCentrally(w.path, w.name);
+                        if (result.success) {
+                            installed++;
+                        }
+                        else {
+                            console.log(`  ${chalk.red('x')} ${w.name}: ${result.error}`);
+                        }
+                    }
+                    const workflowNames = workflows.map((w) => w.name);
+                    let syncedVersions = 0;
+                    for (const [agentId, versions] of targets.versionSelections) {
+                        for (const version of versions) {
+                            const result = syncResourcesToVersion(agentId, version, { workflows: workflowNames });
+                            if (result.workflows.length > 0)
+                                syncedVersions++;
+                        }
+                    }
+                    console.log(`  Installed ${installed} workflow(s) to ~/.agents/workflows/`);
+                    console.log(`  Synced workflows to ${syncedVersions} managed version(s)`);
+                }
+                // Install subagents
+                if (subagents.length > 0) {
+                    console.log(chalk.bold('\nInstalling subagents...'));
+                    let installed = 0;
+                    for (const s of subagents) {
+                        const result = installSubagentCentrally(s.path, s.name);
+                        if (result.success) {
+                            installed++;
+                        }
+                        else {
+                            console.log(`  ${chalk.red('x')} ${s.name}: ${result.error}`);
+                        }
+                    }
+                    const subagentNames = subagents.map((s) => s.name);
+                    let syncedVersions = 0;
+                    for (const [agentId, versions] of targets.versionSelections) {
+                        for (const version of versions) {
+                            const result = syncResourcesToVersion(agentId, version, { subagents: subagentNames });
+                            if (result.subagents.length > 0)
+                                syncedVersions++;
+                        }
+                    }
+                    console.log(`  Installed ${installed} subagent(s) to ~/.agents/subagents/`);
+                    console.log(`  Synced subagents to ${syncedVersions} managed version(s)`);
+                }
+                // Install permissions
+                if (permissions.length > 0) {
+                    console.log(chalk.bold('\nInstalling permission sets...'));
+                    let installed = 0;
+                    for (const p of permissions) {
+                        const result = installPermissionSet(p.path, p.name);
+                        if (result.success) {
+                            installed++;
+                        }
+                        else {
+                            console.log(`  ${chalk.red('x')} ${p.name}: ${result.error}`);
+                        }
+                    }
+                    console.log(`  Installed ${installed} permission set(s) to ~/.agents/permissions/`);
+                    console.log(chalk.gray('  Apply with: agents permissions apply <name> --agents <selector>'));
+                }
+                // Install MCP server configs
+                if (mcpServers.length > 0) {
+                    console.log(chalk.bold('\nInstalling MCP server configs...'));
+                    let installed = 0;
+                    for (const s of mcpServers) {
+                        const result = installMcpConfigCentrally(s.path);
+                        if (result.success) {
+                            installed++;
+                        }
+                        else {
+                            console.log(`  ${chalk.red('x')} ${s.name}: ${result.error}`);
+                        }
+                    }
+                    const mcpNames = mcpServers.map((s) => s.name);
+                    let syncedVersions = 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)
+                                syncedVersions++;
+                        }
+                    }
+                    console.log(`  Installed ${installed} MCP config(s) to ~/.agents/mcp/`);
+                    console.log(`  Synced MCP configs to ${syncedVersions} managed version(s)`);
+                }
                 console.log(chalk.green('\nPackage installed.'));
             }
         }

package/dist/commands/permissions.js

@@ -7,9 +7,9 @@ import { confirm, checkbox } from '@inquirer/prompts';
 import { AGENTS, resolveAgentName, formatAgentError, agentLabel, } from '../lib/agents.js';
 import { cloneRepo } from '../lib/git.js';
 import { PERMISSIONS_CAPABLE_AGENTS, listInstalledPermissions, discoverPermissionsFromRepo, installPermissionSet, removePermissionSet, applyPermissionsToVersion, readAgentPermissions, exportPermissionsFromPath, getDefaultPermissionSet, computePermissionsDiff, mergePermissionSets, saveDefaultPermissionSet, containsBroadGrants, } from '../lib/permissions.js';
-import { listInstalledVersions, getGlobalDefault, getVersionHomePath, promptAgentVersionSelection, resolveAgentVersionTargets, resolveVersionAlias, } from '../lib/versions.js';
+import { listInstalledVersions, getGlobalDefault, getVersionHomePath, promptAgentVersionSelection, resolveVersionAlias, } from '../lib/versions.js';
 import { recordVersionResources } from '../lib/state.js';
-import { isPromptCancelled, isInteractiveTerminal, parseCommaSeparatedList, printWithPager, requireInteractiveSelection, } from './utils.js';
+import { isPromptCancelled, isInteractiveTerminal, parseCommaSeparatedList, printWithPager, requireInteractiveSelection, resolveAgentTargetsAutoInstalling, } from './utils.js';
 export function shouldRefuseBroadPermissions(permissions, allowBroadPermissions) {
     return !allowBroadPermissions && permissions.some((perm) => containsBroadGrants(perm.set) !== null);
 }
@@ -279,9 +279,14 @@ Examples:
                 let selectedAgents;
                 let versionSelections;
                 if (options.agents) {
-                    const result = resolveAgentVersionTargets(options.agents, PERMISSIONS_CAPABLE_AGENTS, {
+                    const result = await resolveAgentTargetsAutoInstalling(options.agents, PERMISSIONS_CAPABLE_AGENTS, {
+                        yes: options.yes,
                         allVersions: options.all,
                     });
+                    if (!result) {
+                        console.log(chalk.gray('Cancelled.'));
+                        return;
+                    }
                     selectedAgents = result.selectedAgents;
                     versionSelections = result.versionSelections;
                 }
@@ -296,7 +301,7 @@ Examples:
                     }
                 }
                 else {
-                    const result = await promptAgentVersionSelection(PERMISSIONS_CAPABLE_AGENTS, { skipPrompts });
+                    const result = await promptAgentVersionSelection(PERMISSIONS_CAPABLE_AGENTS, { skipPrompts: options.yes });
                     selectedAgents = result.selectedAgents;
                     versionSelections = result.versionSelections;
                 }
@@ -412,9 +417,14 @@ Examples:
                 let selectedAgents;
                 let versionSelections;
                 if (options.agents) {
-                    const result = resolveAgentVersionTargets(options.agents, PERMISSIONS_CAPABLE_AGENTS, {
+                    const result = await resolveAgentTargetsAutoInstalling(options.agents, PERMISSIONS_CAPABLE_AGENTS, {
+                        yes: options.yes,
                         allVersions: options.all,
                     });
+                    if (!result) {
+                        console.log(chalk.gray('Cancelled.'));
+                        return;
+                    }
                     selectedAgents = result.selectedAgents;
                     versionSelections = result.versionSelections;
                 }
@@ -537,9 +547,14 @@ Examples:
                 let selectedAgents;
                 let versionSelections;
                 if (options.agents) {
-                    const result = resolveAgentVersionTargets(options.agents, PERMISSIONS_CAPABLE_AGENTS, {
+                    const result = await resolveAgentTargetsAutoInstalling(options.agents, PERMISSIONS_CAPABLE_AGENTS, {
+                        yes: options.yes,
                         allVersions: options.all,
                     });
+                    if (!result) {
+                        console.log(chalk.gray('Cancelled.'));
+                        return;
+                    }
                     selectedAgents = result.selectedAgents;
                     versionSelections = result.versionSelections;
                 }

package/dist/commands/profiles.d.ts

@@ -7,5 +7,13 @@
  * through a standard agent CLI with no local proxy.
  */
 import type { Command } from 'commander';
+import { type Profile } from '../lib/profiles.js';
+import { type Preset } from '../lib/profiles-presets.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 declare function buildProfileFromCollection(name: string, preset: Preset, collected: Record<string, string>, version?: string): Profile;
 /** Register the `agents profiles` command tree. */
 export declare function registerProfilesCommands(program: Command): void;