@swarmify/agents-cli 1.13.4 → 1.14.0

package/dist/lib/agents.js

@@ -1,1159 +0,0 @@
-/**
- * Core agent configuration and detection module.
- *
- * Defines the canonical registry of all supported AI coding agents (Claude, Codex,
- * Gemini, Cursor, OpenCode, OpenClaw, Copilot, Amp, Kiro, Goose, Roo) with their
- * CLI commands, config paths, capability flags, and MCP integration points.
- *
- * Provides functions for detecting installed CLIs, resolving version-managed binaries,
- * reading account/auth info, and managing MCP server registrations across agents.
- */
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import * as TOML from 'smol-toml';
-import chalk from 'chalk';
-import { walkForFiles } from './session/discover.js';
-import { getVersionsDir, getShimsDir } from './state.js';
-import { resolveVersion, getVersionHomePath, getBinaryPath } from './versions.js';
-import { loadClaudeOauth } from './usage.js';
-const execAsync = promisify(exec);
-const HOME = os.homedir();
-/** Minimum Codex CLI version that supports hooks. */
-export const CODEX_HOOKS_MIN_VERSION = '0.116.0';
-const CLI_VERSION_CACHE_PATH = path.join(HOME, '.agents', '.cli-version-cache.json');
-let cliVersionCache = null;
-function loadCliVersionCache() {
-    if (cliVersionCache)
-        return cliVersionCache;
-    try {
-        cliVersionCache = JSON.parse(fs.readFileSync(CLI_VERSION_CACHE_PATH, 'utf-8'));
-    }
-    catch {
-        /* missing or corrupt cache, rebuild */
-        cliVersionCache = {};
-    }
-    return cliVersionCache;
-}
-function saveCliVersionCache() {
-    if (!cliVersionCache)
-        return;
-    try {
-        const dir = path.dirname(CLI_VERSION_CACHE_PATH);
-        if (!fs.existsSync(dir))
-            fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(CLI_VERSION_CACHE_PATH, JSON.stringify(cliVersionCache));
-    }
-    catch {
-        /* best-effort cache persist */
-    }
-}
-/** Synchronous PATH search -- no subprocess. Returns first matching binary path. */
-function findInPath(command) {
-    const pathEnv = process.env.PATH || '';
-    const pathExt = process.platform === 'win32' ? (process.env.PATHEXT || '').split(';') : [''];
-    for (const dir of pathEnv.split(path.delimiter)) {
-        if (!dir)
-            continue;
-        for (const ext of pathExt) {
-            const full = path.join(dir, command + ext);
-            try {
-                const stat = fs.statSync(full);
-                if (stat.isFile())
-                    return full;
-            }
-            catch {
-                /* not in this dir */
-            }
-        }
-    }
-    return null;
-}
-/**
- * Master registry of all supported agents keyed by AgentId.
- *
- * Each entry defines the agent's CLI command, npm package, config directory layout,
- * instructions file name, slash-command format, and capability flags. This is the
- * single source of truth for agent metadata consumed throughout the codebase.
- */
-export const AGENTS = {
-    claude: {
-        id: 'claude',
-        name: 'Claude',
-        color: 'magenta',
-        cliCommand: 'claude',
-        npmPackage: '@anthropic-ai/claude-code',
-        configDir: path.join(HOME, '.claude'),
-        homeFiles: ['.claude.json'],
-        commandsDir: path.join(HOME, '.claude', 'commands'),
-        commandsSubdir: 'commands',
-        skillsDir: path.join(HOME, '.claude', 'skills'),
-        hooksDir: 'hooks',
-        instructionsFile: 'CLAUDE.md',
-        format: 'markdown',
-        variableSyntax: '$ARGUMENTS',
-        supportsHooks: true,
-        capabilities: { hooks: true, mcp: true, allowlist: true, skills: true, commands: true, plugins: true, memoryImports: true },
-    },
-    codex: {
-        id: 'codex',
-        name: 'Codex',
-        color: 'green',
-        cliCommand: 'codex',
-        npmPackage: '@openai/codex',
-        configDir: path.join(HOME, '.codex'),
-        commandsDir: path.join(HOME, '.codex', 'prompts'),
-        commandsSubdir: 'prompts',
-        skillsDir: path.join(HOME, '.codex', 'skills'),
-        hooksDir: 'hooks',
-        instructionsFile: 'AGENTS.md',
-        format: 'markdown',
-        variableSyntax: '$ARGUMENTS',
-        supportsHooks: true,
-        capabilities: { hooks: true, mcp: true, allowlist: false, skills: true, commands: true, plugins: false },
-    },
-    gemini: {
-        id: 'gemini',
-        name: 'Gemini',
-        color: 'blue',
-        cliCommand: 'gemini',
-        npmPackage: '@google/gemini-cli',
-        configDir: path.join(HOME, '.gemini'),
-        commandsDir: path.join(HOME, '.gemini', 'commands'),
-        commandsSubdir: 'commands',
-        skillsDir: path.join(HOME, '.gemini', 'skills'),
-        hooksDir: 'hooks',
-        instructionsFile: 'GEMINI.md',
-        format: 'toml',
-        variableSyntax: '{{args}}',
-        supportsHooks: true,
-        nativeAgentsSkillsDir: true,
-        capabilities: { hooks: true, mcp: true, allowlist: false, skills: true, commands: true, plugins: false, memoryImports: true },
-    },
-    cursor: {
-        id: 'cursor',
-        name: 'Cursor',
-        color: 'cyan',
-        cliCommand: 'cursor-agent',
-        npmPackage: '',
-        installScript: 'curl https://cursor.com/install -fsS | bash && mv ~/.local/bin/agent ~/.local/bin/cursor-agent && grep -q "/.local/bin" ~/.zshrc || echo \'export PATH="$HOME/.local/bin:$PATH"\' >> ~/.zshrc',
-        configDir: path.join(HOME, '.cursor'),
-        commandsDir: path.join(HOME, '.cursor', 'commands'),
-        commandsSubdir: 'commands',
-        skillsDir: path.join(HOME, '.cursor', 'skills'),
-        hooksDir: 'hooks',
-        instructionsFile: '.cursorrules',
-        format: 'markdown',
-        variableSyntax: '$ARGUMENTS',
-        supportsHooks: false,
-        capabilities: { hooks: false, mcp: true, allowlist: false, skills: true, commands: true, plugins: false },
-    },
-    opencode: {
-        id: 'opencode',
-        name: 'OpenCode',
-        color: 'yellowBright',
-        cliCommand: 'opencode',
-        npmPackage: 'opencode-ai',
-        configDir: path.join(HOME, '.opencode'),
-        commandsDir: path.join(HOME, '.opencode', 'commands'),
-        commandsSubdir: 'commands',
-        skillsDir: path.join(HOME, '.opencode', 'skills'),
-        hooksDir: 'hooks',
-        instructionsFile: 'AGENTS.md',
-        format: 'markdown',
-        variableSyntax: '$ARGUMENTS',
-        supportsHooks: false,
-        capabilities: { hooks: false, mcp: true, allowlist: false, skills: true, commands: true, plugins: false },
-    },
-    openclaw: {
-        id: 'openclaw',
-        name: 'OpenClaw',
-        color: 'redBright',
-        cliCommand: 'openclaw',
-        npmPackage: 'openclaw',
-        configDir: path.join(HOME, '.openclaw'),
-        commandsDir: '', // OpenClaw uses Gateway-based slash commands, not file-based
-        commandsSubdir: '',
-        skillsDir: path.join(HOME, '.openclaw', 'skills'),
-        hooksDir: 'hooks',
-        instructionsFile: 'workspace/AGENTS.md', // Primary memory file (also has SOUL.md, IDENTITY.md, etc.)
-        format: 'markdown',
-        variableSyntax: '{{ARGUMENTS}}',
-        supportsHooks: true,
-        capabilities: { hooks: true, mcp: true, allowlist: false, skills: true, commands: false, plugins: true },
-    },
-    copilot: {
-        id: 'copilot',
-        name: 'Copilot',
-        color: 'whiteBright',
-        cliCommand: 'copilot',
-        npmPackage: '@github/copilot',
-        configDir: path.join(HOME, '.copilot'),
-        commandsDir: path.join(HOME, '.copilot', 'commands'),
-        commandsSubdir: 'commands',
-        skillsDir: path.join(HOME, '.copilot', 'skills'),
-        hooksDir: 'hooks',
-        instructionsFile: 'AGENTS.md',
-        format: 'markdown',
-        variableSyntax: '$ARGUMENTS',
-        supportsHooks: false,
-        capabilities: { hooks: false, mcp: true, allowlist: false, skills: true, commands: true, plugins: false },
-    },
-    amp: {
-        id: 'amp',
-        name: 'Amp',
-        color: 'blueBright',
-        cliCommand: 'amp',
-        npmPackage: '@sourcegraph/amp',
-        configDir: path.join(HOME, '.config', 'amp'),
-        commandsDir: path.join(HOME, '.config', 'amp', 'commands'),
-        commandsSubdir: 'commands',
-        skillsDir: path.join(HOME, '.config', 'amp', 'skills'),
-        hooksDir: 'hooks',
-        instructionsFile: 'AGENTS.md',
-        format: 'markdown',
-        variableSyntax: '$ARGUMENTS',
-        supportsHooks: false,
-        capabilities: { hooks: false, mcp: true, allowlist: false, skills: true, commands: true, plugins: false },
-    },
-    kiro: {
-        id: 'kiro',
-        name: 'Kiro',
-        color: 'greenBright',
-        cliCommand: 'kiro-cli',
-        npmPackage: '',
-        installScript: 'brew install --cask kiro-cli',
-        configDir: path.join(HOME, '.kiro'),
-        commandsDir: path.join(HOME, '.kiro', 'commands'),
-        commandsSubdir: 'commands',
-        skillsDir: path.join(HOME, '.kiro', 'skills'),
-        hooksDir: 'hooks',
-        instructionsFile: 'AGENTS.md',
-        format: 'markdown',
-        variableSyntax: '$ARGUMENTS',
-        supportsHooks: false,
-        capabilities: { hooks: false, mcp: true, allowlist: false, skills: true, commands: true, plugins: false },
-    },
-    goose: {
-        id: 'goose',
-        name: 'Goose',
-        color: 'magentaBright',
-        cliCommand: 'goose',
-        npmPackage: '',
-        installScript: 'brew install block-goose-cli',
-        configDir: path.join(HOME, '.config', 'goose'),
-        commandsDir: path.join(HOME, '.config', 'goose', 'commands'),
-        commandsSubdir: 'commands',
-        skillsDir: path.join(HOME, '.config', 'goose', 'skills'),
-        hooksDir: 'hooks',
-        instructionsFile: 'AGENTS.md',
-        format: 'markdown',
-        variableSyntax: '$ARGUMENTS',
-        supportsHooks: false,
-        capabilities: { hooks: false, mcp: true, allowlist: false, skills: false, commands: false, plugins: false },
-    },
-    roo: {
-        id: 'roo',
-        name: 'Roo Code',
-        color: 'cyanBright',
-        cliCommand: 'roo',
-        npmPackage: '',
-        installScript: 'curl -fsSL https://raw.githubusercontent.com/RooCodeInc/Roo-Code/main/apps/cli/install.sh | sh',
-        configDir: path.join(HOME, '.roo'),
-        commandsDir: path.join(HOME, '.roo', 'commands'),
-        commandsSubdir: 'commands',
-        skillsDir: path.join(HOME, '.roo', 'skills'),
-        hooksDir: 'hooks',
-        instructionsFile: 'AGENTS.md',
-        format: 'markdown',
-        variableSyntax: '$ARGUMENTS',
-        supportsHooks: false,
-        capabilities: { hooks: false, mcp: true, allowlist: false, skills: true, commands: true, plugins: false },
-    },
-};
-/** All registered agent IDs derived from the AGENTS registry. */
-export const ALL_AGENT_IDS = Object.keys(AGENTS);
-/** Agents that support MCP (Model Context Protocol) server integration. */
-export const MCP_CAPABLE_AGENTS = ALL_AGENT_IDS.filter((id) => AGENTS[id].capabilities.mcp);
-/** Agents that support skills (SKILL.md + rules/ bundles). */
-export const SKILLS_CAPABLE_AGENTS = ALL_AGENT_IDS.filter((id) => AGENTS[id].capabilities.skills);
-/** Agents that support file-based slash commands. */
-export const COMMANDS_CAPABLE_AGENTS = ALL_AGENT_IDS.filter((id) => AGENTS[id].capabilities.commands);
-/** Agents that support event hooks (pre/post lifecycle callbacks). */
-export const HOOKS_CAPABLE_AGENTS = ['claude', 'codex', 'gemini', 'openclaw'];
-/** Agents that support the plugin system. */
-export const PLUGINS_CAPABLE_AGENTS = ALL_AGENT_IDS.filter((id) => AGENTS[id].capabilities.plugins);
-/** Get the chalk color function for an agent. Works for any AgentId or SessionAgentId. */
-export function colorAgent(agentId) {
-    const agent = AGENTS[agentId];
-    if (!agent)
-        return chalk.white;
-    return chalk[agent.color];
-}
-/** Return the agent's display name, colored. */
-export function agentLabel(agentId) {
-    const agent = AGENTS[agentId];
-    if (!agent)
-        return agentId;
-    return chalk[agent.color](agent.name);
-}
-/** Check whether the given agent's CLI binary is present on PATH. */
-export async function isCliInstalled(agentId) {
-    const agent = AGENTS[agentId];
-    return findInPath(agent.cliCommand) !== null;
-}
-/** Return the installed CLI version for the given agent, or null if not found. */
-export async function getCliVersion(agentId) {
-    const agent = AGENTS[agentId];
-    const binaryPath = findInPath(agent.cliCommand);
-    if (!binaryPath)
-        return null;
-    return getCachedVersionForBinary(agentId, binaryPath);
-}
-/** Return the absolute path to the agent's CLI binary on PATH, or null. */
-export async function getCliPath(agentId) {
-    return findInPath(AGENTS[agentId].cliCommand);
-}
-/** Look up version from cache by (binary, mtime). On miss or stale, spawn `--version` and cache. */
-async function getCachedVersionForBinary(agentId, binaryPath) {
-    let mtime = 0;
-    try {
-        mtime = fs.statSync(binaryPath).mtimeMs;
-    }
-    catch {
-        /* binary vanished between findInPath and statSync */
-        return null;
-    }
-    const cache = loadCliVersionCache();
-    const cached = cache[agentId];
-    if (cached && cached.binaryPath === binaryPath && cached.mtime === mtime) {
-        return cached.version;
-    }
-    const agent = AGENTS[agentId];
-    let version = null;
-    try {
-        const { stdout } = await execAsync(`${agent.cliCommand} --version`, { timeout: 3000 });
-        if (agentId === 'openclaw') {
-            const match = stdout.match(/openclaw\/(\d+\.\d+\.\d+)/);
-            version = match ? match[1] : stdout.trim();
-        }
-        else {
-            const match = stdout.match(/(\d+\.\d+\.\d+)/);
-            version = match ? match[1] : stdout.trim();
-        }
-    }
-    catch {
-        /* version command failed */
-        version = null;
-    }
-    cache[agentId] = { binaryPath, mtime, version };
-    saveCliVersionCache();
-    return version;
-}
-/**
- * Resolve the full CLI state for an agent: whether it is installed, its version,
- * and the path to the binary. Checks version-managed installs first, then falls
- * back to a plain PATH lookup.
- */
-export async function getCliState(agentId) {
-    // Fast path: if version-managed, derive state from filesystem (no subprocesses)
-    const agent = AGENTS[agentId];
-    const agentVersionsDir = path.join(getVersionsDir(), agentId);
-    if (fs.existsSync(agentVersionsDir)) {
-        // Use resolved version (project manifest -> global default)
-        const resolvedVer = resolveVersion(agentId, process.cwd());
-        if (resolvedVer) {
-            const binaryPath = path.join(agentVersionsDir, resolvedVer, 'node_modules', '.bin', agent.cliCommand);
-            if (fs.existsSync(binaryPath)) {
-                const shimPath = path.join(getShimsDir(), agent.cliCommand);
-                return {
-                    installed: true,
-                    version: resolvedVer,
-                    path: fs.existsSync(shimPath) ? shimPath : binaryPath,
-                };
-            }
-        }
-        // Fallback: if no default set or resolved version not installed, return first available
-        const entries = fs.readdirSync(agentVersionsDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                const binaryPath = path.join(agentVersionsDir, entry.name, 'node_modules', '.bin', agent.cliCommand);
-                if (fs.existsSync(binaryPath)) {
-                    const shimPath = path.join(getShimsDir(), agent.cliCommand);
-                    return {
-                        installed: true,
-                        version: entry.name,
-                        path: fs.existsSync(shimPath) ? shimPath : binaryPath,
-                    };
-                }
-            }
-        }
-    }
-    // Non-version-managed: single PATH lookup + cached version read
-    const binaryPath = findInPath(agent.cliCommand);
-    if (!binaryPath) {
-        return { installed: false, version: null, path: null };
-    }
-    return {
-        installed: true,
-        version: await getCachedVersionForBinary(agentId, binaryPath),
-        path: binaryPath,
-    };
-}
-/** Resolve CLI state for all registered agents in parallel. */
-export async function getAllCliStates() {
-    const states = {};
-    const results = await Promise.all(ALL_AGENT_IDS.map(async (agentId) => ({
-        agentId,
-        state: await getCliState(agentId),
-    })));
-    for (const { agentId, state } of results) {
-        states[agentId] = state;
-    }
-    return states;
-}
-/** Check whether the agent's config directory exists on disk. */
-export function isConfigured(agentId) {
-    const agent = AGENTS[agentId];
-    return fs.existsSync(agent.configDir);
-}
-/** Create the agent's slash-commands directory if it does not exist. */
-export function ensureCommandsDir(agentId) {
-    const agent = AGENTS[agentId];
-    if (!fs.existsSync(agent.commandsDir)) {
-        fs.mkdirSync(agent.commandsDir, { recursive: true });
-    }
-}
-/** Create the agent's skills directory if it does not exist. */
-export function ensureSkillsDir(agentId) {
-    const agent = AGENTS[agentId];
-    if (!fs.existsSync(agent.skillsDir)) {
-        fs.mkdirSync(agent.skillsDir, { recursive: true });
-    }
-}
-/** Return the email address associated with the agent's auth config, or null. */
-export async function getAccountEmail(agentId, home) {
-    const info = await getAccountInfo(agentId, home);
-    return info.email;
-}
-/**
- * Extract full account information (identity, plan, usage status, credits) from
- * the agent's local auth/config files. Supports Claude, Codex, and Gemini.
- */
-export async function getAccountInfo(agentId, home) {
-    const base = home || os.homedir();
-    const empty = {
-        accountKey: null,
-        usageKey: null,
-        accountId: null,
-        organizationId: null,
-        userId: null,
-        email: null,
-        plan: null,
-        usageStatus: null,
-        overageCredits: null,
-        lastActive: null,
-    };
-    const configFiles = {
-        claude: path.join(base, '.claude.json'),
-        codex: path.join(base, '.codex', 'auth.json'),
-        gemini: path.join(base, '.gemini', 'google_accounts.json'),
-    };
-    const lastActive = resolveLastActive(agentId, base, configFiles[agentId]);
-    try {
-        switch (agentId) {
-            case 'claude': {
-                // Claude reads/writes config at $CLAUDE_CONFIG_DIR/.claude.json when set,
-                // falling back to $HOME/.claude.json. Our shim sets CLAUDE_CONFIG_DIR to
-                // the per-version .claude dir, so prefer that file; fall back to home-level
-                // for versions ever launched without the shim (IDE extension, direct binary).
-                const configDirFile = path.join(base, '.claude', '.claude.json');
-                const homeLevelFile = path.join(base, '.claude.json');
-                const activeFile = fs.existsSync(configDirFile) ? configDirFile : homeLevelFile;
-                const data = JSON.parse(await fs.promises.readFile(activeFile, 'utf-8'));
-                const oa = data.oauthAccount;
-                const accountId = normalizeIdentityPart(oa?.accountUuid);
-                const organizationId = normalizeIdentityPart(oa?.organizationUuid);
-                const email = oa?.emailAddress || null;
-                const accountKey = buildIdentityKey(agentId, [
-                    ['account', accountId],
-                    ['org', organizationId],
-                ]);
-                const usageKey = buildIdentityKey(agentId, [['org', organizationId]]);
-                let plan = null;
-                const keychainOauth = await loadClaudeOauth(home);
-                if (keychainOauth?.subscriptionType) {
-                    plan = keychainOauth.subscriptionType.charAt(0).toUpperCase()
-                        + keychainOauth.subscriptionType.slice(1);
-                }
-                else if (oa?.billingType === 'stripe_subscription') {
-                    plan = 'Pro';
-                }
-                else if (oa?.billingType) {
-                    plan = oa.billingType;
-                }
-                let usageStatus = null;
-                const reason = data.cachedExtraUsageDisabledReason;
-                if (reason === 'out_of_credits')
-                    usageStatus = 'out_of_credits';
-                else if (reason)
-                    usageStatus = 'rate_limited';
-                else
-                    usageStatus = 'available';
-                let overageCredits = null;
-                const orgId = oa?.organizationUuid;
-                const creditCache = orgId && data.overageCreditGrantCache?.[orgId];
-                if (creditCache?.info?.available && creditCache.info.amount_minor_units) {
-                    overageCredits = {
-                        amount: creditCache.info.amount_minor_units / 100,
-                        currency: creditCache.info.currency || 'USD',
-                    };
-                }
-                return {
-                    accountKey,
-                    usageKey,
-                    accountId,
-                    organizationId,
-                    userId: null,
-                    email,
-                    plan,
-                    usageStatus,
-                    overageCredits,
-                    lastActive,
-                };
-            }
-            case 'codex': {
-                const data = JSON.parse(await fs.promises.readFile(path.join(base, '.codex', 'auth.json'), 'utf-8'));
-                const token = data.tokens?.id_token || data.tokens?.access_token;
-                if (!token)
-                    return { ...empty, lastActive };
-                const decoded = decodeJwtPayload(token);
-                if (!decoded)
-                    return { ...empty, lastActive };
-                const email = decoded.email || null;
-                // Plan and subscription from OpenAI auth claim
-                const authClaim = decoded['https://api.openai.com/auth'] || {};
-                const accountId = normalizeIdentityPart(authClaim.chatgpt_account_id);
-                const userId = normalizeIdentityPart(authClaim.chatgpt_user_id || authClaim.user_id);
-                const organizationId = normalizeIdentityPart(getCodexDefaultOrgId(authClaim));
-                const accountKey = buildIdentityKey(agentId, [
-                    ['account', accountId],
-                    ['user', userId],
-                    ['org', organizationId],
-                ]);
-                const rawPlan = authClaim.chatgpt_plan_type;
-                const plan = rawPlan ? rawPlan.charAt(0).toUpperCase() + rawPlan.slice(1) : null;
-                // Subscription status: expired = out_of_credits
-                let usageStatus = null;
-                const activeUntil = authClaim.chatgpt_subscription_active_until;
-                if (activeUntil) {
-                    const expired = new Date(activeUntil).getTime() < Date.now();
-                    usageStatus = expired ? 'out_of_credits' : 'available';
-                }
-                return {
-                    accountKey,
-                    usageKey: accountKey,
-                    accountId,
-                    organizationId,
-                    userId,
-                    email,
-                    plan,
-                    usageStatus,
-                    overageCredits: null,
-                    lastActive,
-                };
-            }
-            case 'gemini': {
-                const data = JSON.parse(await fs.promises.readFile(path.join(base, '.gemini', 'google_accounts.json'), 'utf-8'));
-                return { ...empty, email: data.active || null, lastActive };
-            }
-            default:
-                return { ...empty, lastActive };
-        }
-    }
-    catch {
-        /* auth/config file missing or unreadable */
-        return { ...empty, lastActive };
-    }
-}
-/** Determine when the agent was last used by checking session file mtimes, falling back to config mtime. */
-function resolveLastActive(agentId, base, configPath) {
-    const sessionDir = getSessionDir(agentId, base);
-    const sessionExt = getSessionExtension(agentId);
-    if (sessionDir && sessionExt) {
-        const latestSession = getLatestFileMtime(sessionDir, sessionExt);
-        if (latestSession) {
-            return latestSession;
-        }
-    }
-    if (!configPath)
-        return null;
-    try {
-        return fs.statSync(configPath).mtime;
-    }
-    catch {
-        return null;
-    }
-}
-/** Return the root directory where the agent stores session files, or null if unknown. */
-function getSessionDir(agentId, base) {
-    switch (agentId) {
-        case 'claude':
-            return path.join(base, '.claude', 'projects');
-        case 'codex':
-            return path.join(base, '.codex', 'sessions');
-        case 'gemini':
-            return path.join(base, '.gemini', 'tmp');
-        default:
-            return null;
-    }
-}
-/** Return the file extension used for session files by the given agent. */
-function getSessionExtension(agentId) {
-    switch (agentId) {
-        case 'claude':
-        case 'codex':
-            return '.jsonl';
-        case 'gemini':
-            return '.json';
-        default:
-            return null;
-    }
-}
-/** Walk a directory for files matching the extension and return the mtime of the most recent one. */
-function getLatestFileMtime(dir, ext) {
-    if (!fs.existsSync(dir))
-        return null;
-    const [latest] = walkForFiles(dir, ext, 1);
-    if (!latest)
-        return null;
-    try {
-        return fs.statSync(latest).mtime;
-    }
-    catch {
-        return null;
-    }
-}
-/** Decode the payload section of a JWT token without verifying its signature. */
-function decodeJwtPayload(token) {
-    const payload = token.split('.')[1];
-    if (!payload)
-        return null;
-    try {
-        return JSON.parse(Buffer.from(payload, 'base64url').toString());
-    }
-    catch {
-        return null;
-    }
-}
-/** Extract the default organization ID from a Codex/OpenAI auth claim. */
-function getCodexDefaultOrgId(authClaim) {
-    const organizations = authClaim?.organizations;
-    if (!Array.isArray(organizations))
-        return null;
-    const first = organizations[0];
-    return typeof first?.id === 'string' ? first.id : null;
-}
-/** Trim and normalize an identity string, returning null for empty or non-string values. */
-function normalizeIdentityPart(value) {
-    if (typeof value !== 'string')
-        return null;
-    const trimmed = value.trim();
-    return trimmed || null;
-}
-/** Build a composite identity key like "claude:account=abc:org=xyz" from labeled parts. */
-function buildIdentityKey(agentId, parts) {
-    const encoded = parts
-        .filter(([, value]) => value)
-        .map(([label, value]) => `${label}=${value}`);
-    if (encoded.length === 0)
-        return null;
-    return `${agentId}:${encoded.join(':')}`;
-}
-/** Check whether a named MCP server is registered with the agent's CLI. */
-export async function isMcpRegistered(agentId, mcpName) {
-    const agent = AGENTS[agentId];
-    if (!agent.capabilities.mcp || !(await isCliInstalled(agentId))) {
-        return false;
-    }
-    try {
-        const { stdout } = await execAsync(`${agent.cliCommand} mcp list`);
-        return stdout.toLowerCase().includes(mcpName.toLowerCase());
-    }
-    catch {
-        /* mcp list command failed */
-        return false;
-    }
-}
-/** Register an MCP server with an agent's CLI via `mcp add`. */
-export async function registerMcp(agentId, name, command, scope = 'user', transport = 'stdio', options) {
-    const agent = AGENTS[agentId];
-    if (!agent.capabilities.mcp) {
-        return { success: false, error: 'Agent does not support MCP' };
-    }
-    if (!options?.binary && !(await isCliInstalled(agentId))) {
-        return { success: false, error: 'CLI not installed' };
-    }
-    try {
-        // Use explicit binary path when provided (bypasses shim for version-managed agents)
-        const bin = options?.binary || agent.cliCommand;
-        let cmd;
-        if (agentId === 'claude') {
-            cmd = `${bin} mcp add --transport ${transport} --scope ${scope} "${name}" -- ${command}`;
-        }
-        else {
-            cmd = `${bin} mcp add "${name}" -- ${command}`;
-        }
-        // When home is specified, override HOME so MCP config writes to the version's config dir
-        const env = options?.home ? { ...process.env, HOME: options.home } : undefined;
-        await execAsync(cmd, env ? { env } : undefined);
-        return { success: true };
-    }
-    catch (err) {
-        return { success: false, error: err.message };
-    }
-}
-/** Unregister (remove) a named MCP server from an agent's CLI config. */
-export async function unregisterMcp(agentId, name, options) {
-    const agent = AGENTS[agentId];
-    if (!agent.capabilities.mcp) {
-        return { success: false, error: 'Agent does not support MCP' };
-    }
-    if (!options?.binary && !(await isCliInstalled(agentId))) {
-        return { success: false, error: 'CLI not installed' };
-    }
-    try {
-        const bin = options?.binary || agent.cliCommand;
-        const env = options?.home ? { ...process.env, HOME: options.home } : undefined;
-        await execAsync(`${bin} mcp remove "${name}"`, env ? { env } : undefined);
-        return { success: true };
-    }
-    catch (err) {
-        return { success: false, error: err.message };
-    }
-}
-/**
- * Register an MCP server across multiple agent targets, including both direct
- * (non-version-managed) agents and specific version-managed installs.
- */
-export async function registerMcpToTargets(targets, name, command, scope = 'user', transport = 'stdio') {
-    const results = [];
-    for (const agentId of targets.directAgents) {
-        const result = await registerMcp(agentId, name, command, scope, transport);
-        results.push({ agentId, success: result.success, error: result.error });
-    }
-    for (const [agentId, versions] of targets.versionSelections) {
-        for (const version of versions) {
-            const result = await registerMcp(agentId, name, command, scope, transport, {
-                home: getVersionHomePath(agentId, version),
-                binary: getBinaryPath(agentId, version),
-            });
-            results.push({ agentId, version, success: result.success, error: result.error });
-        }
-    }
-    return results;
-}
-/**
- * Unregister an MCP server from multiple agent targets, including both direct
- * agents and specific version-managed installs.
- */
-export async function unregisterMcpFromTargets(targets, name) {
-    const results = [];
-    for (const agentId of targets.directAgents) {
-        const result = await unregisterMcp(agentId, name);
-        results.push({ agentId, success: result.success, error: result.error });
-    }
-    for (const [agentId, versions] of targets.versionSelections) {
-        for (const version of versions) {
-            const result = await unregisterMcp(agentId, name, {
-                home: getVersionHomePath(agentId, version),
-                binary: getBinaryPath(agentId, version),
-            });
-            results.push({ agentId, version, success: result.success, error: result.error });
-        }
-    }
-    return results;
-}
-/**
- * Extract version from npm package specification.
- * Examples: @swarmify/agents-mcp@latest -> latest
- *           @swarmify/agents-mcp@1.2.3 -> 1.2.3
- *           some-package -> undefined
- */
-function extractNpmVersion(args) {
-    // Find npm package argument (looks like @scope/package@version or package@version)
-    for (const arg of args) {
-        // Match @scope/package@version or package@version
-        const match = arg.match(/@([^@]+)$|^([^@]+)@(.+)$/);
-        if (match) {
-            // @scope/package@version pattern
-            const versionMatch = arg.match(/@([^@/]+)$/);
-            if (versionMatch) {
-                return versionMatch[1];
-            }
-        }
-    }
-    return undefined;
-}
-/**
- * Strip JSON comments for JSONC parsing.
- * Only removes comments outside of strings.
- */
-function stripJsonComments(content) {
-    let result = '';
-    let inString = false;
-    let escape = false;
-    let i = 0;
-    while (i < content.length) {
-        const char = content[i];
-        const next = content[i + 1];
-        if (escape) {
-            result += char;
-            escape = false;
-            i++;
-            continue;
-        }
-        if (char === '\\' && inString) {
-            result += char;
-            escape = true;
-            i++;
-            continue;
-        }
-        if (char === '"') {
-            inString = !inString;
-            result += char;
-            i++;
-            continue;
-        }
-        if (!inString) {
-            // Check for single-line comment
-            if (char === '/' && next === '/') {
-                // Skip until end of line
-                while (i < content.length && content[i] !== '\n') {
-                    i++;
-                }
-                continue;
-            }
-            // Check for multi-line comment
-            if (char === '/' && next === '*') {
-                i += 2;
-                while (i < content.length && !(content[i] === '*' && content[i + 1] === '/')) {
-                    i++;
-                }
-                i += 2; // Skip */
-                continue;
-            }
-        }
-        result += char;
-        i++;
-    }
-    return result;
-}
-/**
- * Parse MCP servers from a JSON/JSONC config file.
- */
-function parseMcpFromJsonConfig(configPath) {
-    if (!fs.existsSync(configPath)) {
-        return {};
-    }
-    try {
-        let content = fs.readFileSync(configPath, 'utf-8');
-        // Handle JSONC (JSON with comments)
-        if (configPath.endsWith('.jsonc')) {
-            content = stripJsonComments(content);
-        }
-        const config = JSON.parse(content);
-        // Claude uses mcpServers, others may use mcp_servers or mcp
-        return config.mcpServers || config.mcp_servers || config.mcp || {};
-    }
-    catch {
-        /* JSON config corrupt or unreadable */
-        return {};
-    }
-}
-/**
- * Parse MCP servers from a TOML config file (Codex).
- * Codex stores MCPs as [mcp_servers.ServerName] sections.
- */
-function parseMcpFromTomlConfig(configPath) {
-    if (!fs.existsSync(configPath)) {
-        return {};
-    }
-    try {
-        const content = fs.readFileSync(configPath, 'utf-8');
-        const config = TOML.parse(content);
-        // Codex uses mcp_servers as a table with server names as keys
-        const mcpServers = config.mcp_servers;
-        return mcpServers || {};
-    }
-    catch {
-        /* TOML config corrupt or unreadable */
-        return {};
-    }
-}
-/**
- * Parse MCP servers from OpenCode's JSONC config.
- * OpenCode stores MCPs in the "mcp" object with different structure.
- */
-function parseMcpFromOpenCodeConfig(configPath) {
-    if (!fs.existsSync(configPath)) {
-        return {};
-    }
-    try {
-        const content = stripJsonComments(fs.readFileSync(configPath, 'utf-8'));
-        const config = JSON.parse(content);
-        const mcpConfig = config.mcp;
-        if (!mcpConfig)
-            return {};
-        // Convert OpenCode format to our McpConfigEntry format
-        const result = {};
-        for (const [name, entry] of Object.entries(mcpConfig)) {
-            if (entry.type === 'local' && entry.command) {
-                // Local MCP: command is an array like ["npx", "-y", "@pkg@version"]
-                result[name] = {
-                    command: entry.command[0],
-                    args: entry.command.slice(1),
-                };
-            }
-            else if (entry.type === 'remote' && entry.url) {
-                // Remote MCP: HTTP URL
-                result[name] = {
-                    url: entry.url,
-                };
-            }
-        }
-        return result;
-    }
-    catch {
-        /* OpenCode JSONC config corrupt or unreadable */
-        return {};
-    }
-}
-/**
- * Get user-scoped MCP config path for an agent.
- */
-function getUserMcpConfigPath(agentId) {
-    const agent = AGENTS[agentId];
-    switch (agentId) {
-        case 'claude':
-            // Claude user-scoped MCPs are in ~/.claude.json (global user config)
-            return path.join(HOME, '.claude.json');
-        case 'codex':
-            // Codex uses TOML config
-            return path.join(agent.configDir, 'config.toml');
-        case 'opencode':
-            // OpenCode uses JSONC config
-            return path.join(agent.configDir, 'opencode.jsonc');
-        case 'cursor':
-            // Cursor uses mcp.json
-            return path.join(agent.configDir, 'mcp.json');
-        case 'openclaw':
-            // OpenClaw uses openclaw.json
-            return path.join(agent.configDir, 'openclaw.json');
-        default:
-            // Gemini and others use settings.json
-            return path.join(agent.configDir, 'settings.json');
-    }
-}
-/**
- * Get MCP config path for a specific HOME directory (used for version-managed agents).
- */
-export function getMcpConfigPathForHome(agentId, home) {
-    switch (agentId) {
-        case 'claude':
-            return path.join(home, '.claude.json');
-        case 'codex':
-            return path.join(home, '.codex', 'config.toml');
-        case 'opencode':
-            return path.join(home, '.opencode', 'opencode.jsonc');
-        case 'cursor':
-            return path.join(home, '.cursor', 'mcp.json');
-        case 'openclaw':
-            return path.join(home, '.openclaw', 'openclaw.json');
-        case 'copilot':
-            return path.join(home, '.copilot', 'mcp-config.json');
-        case 'amp':
-            return path.join(home, '.config', 'amp', 'settings.json');
-        case 'kiro':
-            return path.join(home, '.kiro', 'settings', 'mcp.json');
-        case 'goose':
-            return path.join(home, '.config', 'goose', 'config.yaml');
-        case 'roo':
-            return path.join(home, '.roo', 'mcp.json');
-        default:
-            return path.join(home, `.${agentId}`, 'settings.json');
-    }
-}
-/**
- * Get project-scoped MCP config path for an agent.
- */
-function getProjectMcpConfigPath(agentId, cwd = process.cwd()) {
-    switch (agentId) {
-        case 'claude':
-            // Claude uses .mcp.json at project root for project-scoped MCPs
-            return path.join(cwd, '.mcp.json');
-        case 'codex':
-            return path.join(cwd, `.${agentId}`, 'config.toml');
-        case 'opencode':
-            return path.join(cwd, `.${agentId}`, 'opencode.jsonc');
-        case 'cursor':
-            return path.join(cwd, `.${agentId}`, 'mcp.json');
-        case 'openclaw':
-            return path.join(cwd, `.${agentId}`, 'openclaw.json');
-        case 'gemini':
-            return path.join(cwd, `.${agentId}`, 'settings.json');
-        case 'copilot':
-            return path.join(cwd, '.copilot', 'mcp-config.json');
-        case 'amp':
-            return path.join(cwd, '.amp', 'settings.json');
-        case 'kiro':
-            return path.join(cwd, '.kiro', 'settings', 'mcp.json');
-        case 'goose':
-            return path.join(cwd, '.goose', 'config.yaml');
-        case 'roo':
-            return path.join(cwd, '.roo', 'mcp.json');
-        default:
-            return path.join(cwd, `.${agentId}`, 'settings.json');
-    }
-}
-/**
- * Parse MCP servers from OpenClaw's JSON config.
- * OpenClaw stores MCPs under mcp.servers with a similar structure to other agents.
- */
-function parseMcpFromOpenClawConfig(configPath) {
-    if (!fs.existsSync(configPath)) {
-        return {};
-    }
-    try {
-        const content = fs.readFileSync(configPath, 'utf-8');
-        const config = JSON.parse(content);
-        // OpenClaw uses mcp.servers for MCP configuration
-        const mcpServers = config.mcp?.servers;
-        if (!mcpServers)
-            return {};
-        const result = {};
-        for (const [name, entry] of Object.entries(mcpServers)) {
-            if (entry.command) {
-                result[name] = {
-                    command: entry.command,
-                    args: entry.args,
-                    env: entry.env,
-                };
-            }
-            else if (entry.url) {
-                result[name] = {
-                    url: entry.url,
-                    type: entry.transport || 'sse',
-                };
-            }
-        }
-        return result;
-    }
-    catch {
-        /* OpenClaw JSON config corrupt or unreadable */
-        return {};
-    }
-}
-/**
- * Parse MCP config based on agent type.
- */
-export function parseMcpConfig(agentId, configPath) {
-    switch (agentId) {
-        case 'codex':
-            return parseMcpFromTomlConfig(configPath);
-        case 'opencode':
-            return parseMcpFromOpenCodeConfig(configPath);
-        case 'openclaw':
-            return parseMcpFromOpenClawConfig(configPath);
-        default:
-            return parseMcpFromJsonConfig(configPath);
-    }
-}
-/**
- * List installed MCP servers with scope information.
- * Pass options.home to read from a version-managed agent's home directory.
- */
-export function listInstalledMcpsWithScope(agentId, cwd = process.cwd(), options) {
-    const results = [];
-    // Helper to build full command string
-    const buildCommand = (config) => {
-        if (config.command && config.args?.length) {
-            return `${config.command} ${config.args.join(' ')}`;
-        }
-        return config.command || (config.args ? config.args.join(' ') : undefined);
-    };
-    // User-scoped MCPs (version-aware when home is provided)
-    const userConfigPath = options?.home
-        ? getMcpConfigPathForHome(agentId, options.home)
-        : getUserMcpConfigPath(agentId);
-    const userMcps = parseMcpConfig(agentId, userConfigPath);
-    for (const [name, config] of Object.entries(userMcps)) {
-        results.push({
-            name,
-            scope: 'user',
-            command: buildCommand(config),
-            version: config.args ? extractNpmVersion(config.args) : undefined,
-        });
-    }
-    // Project-scoped MCPs
-    const projectConfigPath = getProjectMcpConfigPath(agentId, cwd);
-    const projectMcps = parseMcpConfig(agentId, projectConfigPath);
-    for (const [name, config] of Object.entries(projectMcps)) {
-        // Skip if already in user scope (project can override, but we show both)
-        results.push({
-            name,
-            scope: 'project',
-            command: buildCommand(config),
-            version: config.args ? extractNpmVersion(config.args) : undefined,
-        });
-    }
-    return results;
-}
-/** Map of agent name aliases and shorthand identifiers to canonical AgentId values. */
-export const AGENT_NAME_ALIASES = {
-    claude: 'claude',
-    'claude-code': 'claude',
-    cc: 'claude',
-    codex: 'codex',
-    'openai-codex': 'codex',
-    cx: 'codex',
-    gemini: 'gemini',
-    'gemini-cli': 'gemini',
-    gx: 'gemini',
-    cursor: 'cursor',
-    'cursor-agent': 'cursor',
-    cr: 'cursor',
-    opencode: 'opencode',
-    oc: 'opencode',
-    openclaw: 'openclaw',
-    claw: 'openclaw',
-    ocl: 'openclaw',
-    copilot: 'copilot',
-    'copilot-cli': 'copilot',
-    'github-copilot': 'copilot',
-    gh: 'copilot',
-    amp: 'amp',
-    sourcegraph: 'amp',
-    kiro: 'kiro',
-    'kiro-cli': 'kiro',
-    goose: 'goose',
-    'block-goose': 'goose',
-    roo: 'roo',
-    'roo-code': 'roo',
-    roocode: 'roo',
-};
-/** Resolve a user-provided agent name (alias, shorthand, or canonical) to its AgentId. */
-export function resolveAgentName(input) {
-    return AGENT_NAME_ALIASES[input.toLowerCase()] || null;
-}
-/** Check whether the input string matches any known agent name or alias. */
-export function isAgentName(input) {
-    return resolveAgentName(input) !== null;
-}
-/** Format an error message for an unrecognized agent name, listing valid options. */
-export function formatAgentError(agentName, validAgents = ALL_AGENT_IDS) {
-    return `Unknown agent '${agentName}'. Valid agents: ${validAgents.join(', ')}`;
-}
-//# sourceMappingURL=agents.js.map