@controllerai/cli 0.2.14 → 0.2.16

package/dist/commands/agentSetup.js

@@ -0,0 +1,627 @@
+import { createInterface } from 'node:readline/promises';
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { stdin, stderr } from 'node:process';
+import { ASSISTANT_DOCS, CLAUDE_PLUGIN_ID, CLAUDE_PLUGIN_MARKETPLACE_SOURCE, CLAUDE_REPOSITORY_PLUGIN_ID, CODEX_PLUGIN_ID, CODEX_PLUGIN_MARKETPLACE_SOURCE, CONTROLLERAI_MCP_URL, commandAlreadySatisfied, commandDisplay, detectAssistants, parsePluginInstallation, runExternalCommand, } from '../assistantHosts.js';
+import { userError } from '../errors.js';
+import { emit, printKeyValues, printTable, warn } from '../output.js';
+import { authenticationStatus, ensureAuthentication } from './connect.js';
+import { PUBLIC_SKILLS, installSkills, installedSkillStatus, } from './skills.js';
+const manualSetup = () => [
+    { client: 'claude', url: ASSISTANT_DOCS.claude },
+    { client: 'cowork', url: ASSISTANT_DOCS.cowork },
+    { client: 'chatgpt', url: ASSISTANT_DOCS.chatgpt },
+];
+export const CURSOR_MCP_CONFIG = {
+    mcpServers: {
+        controllerai: { type: 'http', url: CONTROLLERAI_MCP_URL },
+    },
+};
+const selected = (client, detection) => client === 'all' || client === detection.client;
+const targetFor = (client, scope) => scope === 'project' ? 'project' : client === 'claude-code' ? 'claude' : client;
+const summarizeSkills = (target, rows) => {
+    const present = rows.filter(row => row.status !== 'missing');
+    const statuses = rows.reduce((counts, row) => {
+        counts[row.status] = (counts[row.status] ?? 0) + 1;
+        return counts;
+    }, {});
+    return {
+        target,
+        installed: present.length,
+        total: PUBLIC_SKILLS.length,
+        current: rows.length === PUBLIC_SKILLS.length && rows.every(row => row.status === 'current'),
+        versions: [
+            ...new Set(present
+                .map(row => row.skillSetVersion)
+                .filter((version) => typeof version === 'string')),
+        ],
+        statuses,
+    };
+};
+const urlsIn = (value) => (value.match(/https?:\/\/[^\s"'`<>]+/g) ?? []).map(url => url.replace(/[),.;\]}]+$/g, ''));
+const mcpInstalled = (result) => result.exitCode === 0 &&
+    urlsIn(`${result.stdout}\n${result.stderr}`).includes(CONTROLLERAI_MCP_URL);
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const codexMcpServer = (result) => {
+    if (result.exitCode !== 0)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(result.stdout);
+    }
+    catch {
+        return undefined;
+    }
+    if (!Array.isArray(parsed))
+        return undefined;
+    const server = parsed.find(row => isRecord(row) && row.name === 'controllerai');
+    return isRecord(server) ? server : undefined;
+};
+const codexMcpInstalled = (result) => {
+    const server = codexMcpServer(result);
+    if (!server || !isRecord(server.transport))
+        return false;
+    return (server.transport.type === 'streamable_http' && server.transport.url === CONTROLLERAI_MCP_URL);
+};
+export const parseCodexMcpAuthentication = (result) => {
+    const server = codexMcpServer(result);
+    if (!server || typeof server.auth_status !== 'string')
+        return 'unknown';
+    if (['oauth', 'bearer_token'].includes(server.auth_status))
+        return 'authenticated';
+    if (server.auth_status === 'not_logged_in')
+        return 'unauthenticated';
+    return 'unknown';
+};
+const cursorConfigHasControllerAi = (path) => {
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        if (!isRecord(parsed) || !isRecord(parsed.mcpServers))
+            return false;
+        const server = parsed.mcpServers.controllerai;
+        return isRecord(server) && server.type === 'http' && server.url === CONTROLLERAI_MCP_URL;
+    }
+    catch {
+        return false;
+    }
+};
+export const cursorMcpConfigured = (scope, options = {}) => {
+    const root = scope === 'project' ? (options.projectDir ?? process.cwd()) : (options.homeDir ?? homedir());
+    return cursorConfigHasControllerAi(join(root, '.cursor', 'mcp.json'));
+};
+const probePlugin = async (client, runner, codexMarketplaceSource) => {
+    const command = client === 'claude-code' ? 'claude' : 'codex';
+    const ids = client === 'claude-code' ? [CLAUDE_PLUGIN_ID, CLAUDE_REPOSITORY_PLUGIN_ID] : [CODEX_PLUGIN_ID];
+    const listing = await runner(command, ['plugin', 'list', '--json'], {
+        echoCommand: true,
+        echoOutput: false,
+    });
+    const installation = listing.exitCode === 0
+        ? parsePluginInstallation(listing.stdout, ids)
+        : { installed: false };
+    if (installation.installed)
+        return { ...installation, supported: true };
+    const help = await runner(command, ['plugin', '--help'], {
+        echoCommand: true,
+        echoOutput: false,
+    });
+    return {
+        ...installation,
+        supported: help.exitCode === 0 && (client === 'claude-code' || Boolean(codexMarketplaceSource)),
+    };
+};
+export const inventoryAgentSetup = async (options, dependencies = {}) => {
+    const requestedClient = options.client ?? 'all';
+    const scope = options.skillsScope ?? 'global';
+    const detected = typeof dependencies.detections === 'function'
+        ? dependencies.detections()
+        : (dependencies.detections ?? detectAssistants());
+    const runner = dependencies.runCommand ?? runExternalCommand;
+    const skillStatus = dependencies.skillStatus ?? (target => installedSkillStatus({ target }));
+    const codexMarketplaceSource = dependencies.codexMarketplaceSource ?? CODEX_PLUGIN_MARKETPLACE_SOURCE;
+    const states = [];
+    for (const detection of detected.filter(row => selected(requestedClient, row))) {
+        const target = targetFor(detection.client, scope);
+        const skills = summarizeSkills(target, skillStatus(target));
+        if (!detection.detected) {
+            states.push({
+                ...detection,
+                plugin: { installed: false, supported: false },
+                mcp: { installed: false },
+                skills,
+                current: false,
+                note: 'assistant is not installed',
+            });
+            continue;
+        }
+        if (detection.client === 'cursor') {
+            const mcp = (dependencies.cursorMcpConfigured ?? cursorMcpConfigured)(scope);
+            states.push({
+                ...detection,
+                plugin: { installed: false, supported: false },
+                mcp: { installed: mcp },
+                skills,
+                current: mcp && skills.current,
+                ...(!mcp || !skills.current
+                    ? {
+                        note: mcp
+                            ? 'skills need installation'
+                            : skills.current
+                                ? 'paste the printed MCP configuration'
+                                : 'skills and MCP config needed',
+                    }
+                    : {}),
+            });
+            continue;
+        }
+        const plugin = await probePlugin(detection.client, runner, codexMarketplaceSource);
+        const command = detection.client === 'claude-code' ? 'claude' : 'codex';
+        const mcpArgs = detection.client === 'claude-code'
+            ? ['mcp', 'get', 'controllerai']
+            : ['mcp', 'list', '--json'];
+        const mcpResult = await runner(command, mcpArgs, {
+            echoCommand: true,
+            echoOutput: false,
+        });
+        const mcp = detection.client === 'codex' ? codexMcpInstalled(mcpResult) : mcpInstalled(mcpResult);
+        const mcpAuthentication = detection.client === 'codex' ? parseCodexMcpAuthentication(mcpResult) : undefined;
+        const current = (plugin.installed || (mcp && skills.current)) &&
+            (detection.client !== 'codex' || mcpAuthentication === 'authenticated');
+        states.push({
+            ...detection,
+            plugin,
+            mcp: {
+                installed: mcp,
+                ...(mcpAuthentication ? { authentication: mcpAuthentication } : {}),
+            },
+            skills,
+            current,
+        });
+    }
+    return states;
+};
+const action = (client, kind, argv, condition, reason) => ({
+    id: `${client}:${kind}`,
+    client,
+    kind,
+    ...(argv ? { command: commandDisplay(argv[0], argv.slice(1)), argv } : {}),
+    condition,
+    reason,
+});
+export const buildAgentSetupPlan = (input) => {
+    const plannedActions = [];
+    const detectedClients = input.assistants.filter(row => row.detected).map(row => row.client);
+    if (input.authentication.status === 'missing') {
+        plannedActions.push(action('account', 'connect', ['cai', 'connect'], 'required', 'authorize this machine'));
+    }
+    const addSkillAction = (client, condition, reason) => {
+        const target = targetFor(client, input.skillsScope);
+        const argv = ['cai', 'skills', 'install', '--target', target];
+        const command = commandDisplay(argv[0], argv.slice(1));
+        const existing = plannedActions.find(row => row.kind === 'skills-install' && row.command === command);
+        if (existing) {
+            if (condition === 'required' && existing.condition !== 'required') {
+                existing.condition = 'required';
+                existing.reason = reason;
+            }
+            return;
+        }
+        plannedActions.push(action(input.skillsScope === 'project' ? 'shared' : client, 'skills-install', argv, condition, reason));
+    };
+    for (const assistant of input.assistants) {
+        if (!assistant.detected)
+            continue;
+        if (assistant.client === 'cursor') {
+            if (assistant.current)
+                continue;
+            if (!assistant.skills.current) {
+                addSkillAction('cursor', 'required', 'install Controller AI skills for Cursor');
+            }
+            if (!assistant.mcp.installed) {
+                plannedActions.push(action('cursor', 'print-mcp-config', undefined, 'required', 'Cursor MCP configuration must be pasted manually'));
+            }
+            continue;
+        }
+        const pluginPreferred = !assistant.plugin.installed &&
+            assistant.plugin.supported &&
+            (assistant.client === 'claude-code' || Boolean(input.codexMarketplaceSource));
+        const codexLoginRequired = assistant.client === 'codex' && assistant.mcp.authentication !== 'authenticated';
+        if (assistant.current && !pluginPreferred && !codexLoginRequired)
+            continue;
+        if (pluginPreferred) {
+            if (assistant.client === 'claude-code') {
+                plannedActions.push(action(assistant.client, 'plugin-marketplace-add', ['claude', 'plugin', 'marketplace', 'add', CLAUDE_PLUGIN_MARKETPLACE_SOURCE], 'required', 'add the Controller AI Claude marketplace'), action(assistant.client, 'plugin-install', ['claude', 'plugin', 'install', CLAUDE_REPOSITORY_PLUGIN_ID], 'required', 'install the Controller AI plugin'));
+            }
+            else if (input.codexMarketplaceSource) {
+                plannedActions.push(action(assistant.client, 'plugin-marketplace-add', ['codex', 'plugin', 'marketplace', 'add', input.codexMarketplaceSource], 'required', 'add the Controller AI Codex marketplace'), action(assistant.client, 'plugin-install', ['codex', 'plugin', 'add', CODEX_PLUGIN_ID], 'required', 'install the Controller AI plugin'));
+            }
+        }
+        const fallbackCondition = assistant.plugin.supported
+            ? 'if-plugin-fails'
+            : 'required';
+        if (!assistant.mcp.installed) {
+            const argv = assistant.client === 'claude-code'
+                ? ['claude', 'mcp', 'add', '--transport', 'http', 'controllerai', CONTROLLERAI_MCP_URL]
+                : ['codex', 'mcp', 'add', 'controllerai', '--url', CONTROLLERAI_MCP_URL];
+            plannedActions.push(action(assistant.client, 'mcp-add', argv, fallbackCondition, 'plugin unavailable; configure Controller AI MCP directly'));
+        }
+        if (!assistant.skills.current) {
+            addSkillAction(assistant.client, fallbackCondition, 'plugin unavailable; install the bundled Controller AI skills');
+        }
+        if (codexLoginRequired) {
+            const authenticationKnown = assistant.mcp.authentication === 'unauthenticated';
+            plannedActions.push(action('codex', 'mcp-login', ['codex', 'mcp', 'login', 'controllerai'], 'required', authenticationKnown
+                ? 'Controller AI MCP is not authenticated in Codex'
+                : 'Codex could not determine Controller AI MCP authentication; run login to verify it'));
+        }
+    }
+    const nextSteps = [];
+    if (plannedActions.some(row => row.client === 'claude-code' && ['plugin-install', 'mcp-add'].includes(row.kind))) {
+        nextSteps.push({
+            client: 'claude-code',
+            text: 'In Claude Code, open /mcp, select controllerai, then choose Authenticate.',
+        });
+    }
+    if (plannedActions.some(row => row.client === 'cursor' && row.kind === 'print-mcp-config')) {
+        nextSteps.push({
+            client: 'cursor',
+            text: "Paste the printed MCP configuration into Cursor, then sign in from Cursor's MCP settings.",
+        });
+    }
+    return {
+        statusOnly: input.statusOnly,
+        requestedClient: input.requestedClient,
+        skillsScope: input.skillsScope,
+        authentication: input.authentication,
+        detectedClients,
+        assistants: input.assistants,
+        plannedActions,
+        nextSteps,
+        manualSetup: manualSetup(),
+        cursorMcpConfig: CURSOR_MCP_CONFIG,
+    };
+};
+const defaultConfirm = async (question) => {
+    if (!stdin.isTTY)
+        return false;
+    const prompt = createInterface({ input: stdin, output: stderr });
+    try {
+        const answer = (await prompt.question(`${question} [y/N] `)).trim().toLowerCase();
+        return answer === 'y' || answer === 'yes';
+    }
+    finally {
+        prompt.close();
+    }
+};
+const failedCommandMessage = (result) => [result.error, result.stderr.trim(), result.stdout.trim()].filter(Boolean).join('; ') ||
+    `exit ${result.exitCode}`;
+const commandResult = (planned, result) => {
+    // Only marketplace registration has a safe idempotent "already added"
+    // outcome. A similarly worded MCP/plugin error can mean an unhealthy plugin
+    // or a same-name MCP entry pointing at the wrong URL, which must fall back or
+    // fail visibly instead of being reported as repaired.
+    const succeeded = result.exitCode === 0;
+    const alreadySatisfied = result.exitCode !== 0 &&
+        planned.kind === 'plugin-marketplace-add' &&
+        commandAlreadySatisfied(result);
+    return {
+        ...planned,
+        status: succeeded ? 'succeeded' : alreadySatisfied ? 'skipped' : 'failed',
+        exitCode: result.exitCode,
+        ...(alreadySatisfied
+            ? { detail: 'marketplace was already configured' }
+            : !succeeded
+                ? { detail: failedCommandMessage(result) }
+                : {}),
+    };
+};
+const findAction = (plan, client, kind) => plan.plannedActions.find(row => row.kind === kind && (row.client === client || row.client === 'shared'));
+const printApprovalPlan = (plan) => {
+    process.stderr.write('Setup plan:\n');
+    for (const planned of plan.plannedActions) {
+        const description = planned.command ?? 'print the Cursor MCP configuration';
+        process.stderr.write(`  [${planned.condition}] ${description}\n`);
+    }
+};
+export const runAgentSetup = async (options, dependencies = {}) => {
+    const requestedClient = options.client ?? 'all';
+    const skillsScope = options.skillsScope ?? 'global';
+    const codexMarketplaceSource = dependencies.codexMarketplaceSource ?? CODEX_PLUGIN_MARKETPLACE_SOURCE;
+    const authentication = dependencies.authentication
+        ? await dependencies.authentication()
+        : { status: 'missing' };
+    const assistants = await inventoryAgentSetup(options, dependencies);
+    const plan = buildAgentSetupPlan({
+        statusOnly: options.status === true,
+        requestedClient,
+        skillsScope,
+        authentication,
+        assistants,
+        ...(codexMarketplaceSource ? { codexMarketplaceSource } : {}),
+    });
+    if (options.status)
+        return { ...plan, results: [], changed: false };
+    if (authentication.status === 'unavailable') {
+        throw userError(`Could not verify Controller AI authentication: ${authentication.detail ?? 'unavailable'}`, 'AUTH_STATUS_UNAVAILABLE');
+    }
+    if (plan.plannedActions.length > 0 && !options.yes) {
+        printApprovalPlan(plan);
+        const confirmed = await (dependencies.confirm ?? defaultConfirm)(`Approve ${plan.plannedActions.length} planned setup action(s)?`);
+        if (!confirmed) {
+            throw userError('Setup was not changed. Rerun with --yes to approve the printed plan.', 'SETUP_CONFIRMATION_REQUIRED');
+        }
+    }
+    const results = [];
+    const runner = dependencies.runCommand ?? runExternalCommand;
+    const skillInstall = dependencies.skillInstall ??
+        ((target) => installSkills({
+            target,
+            ...(target === 'project' ? { projectDir: process.cwd() } : {}),
+        }));
+    const installedSkillCommands = new Set();
+    const installedSkillResults = new Map();
+    let connected = false;
+    const connect = findAction(plan, 'account', 'connect');
+    if (connect) {
+        process.stderr.write(`$ ${connect.command}\n`);
+        if (!dependencies.ensureAuthenticated) {
+            throw userError('Setup authentication handler is unavailable.', 'SETUP_AUTH_UNAVAILABLE');
+        }
+        await dependencies.ensureAuthenticated();
+        connected = true;
+        results.push({ ...connect, status: 'succeeded' });
+    }
+    for (const assistant of assistants) {
+        if (!assistant.detected)
+            continue;
+        if (assistant.client === 'cursor') {
+            if (assistant.current)
+                continue;
+            const skill = findAction(plan, 'cursor', 'skills-install');
+            if (skill?.command && !installedSkillCommands.has(skill.command)) {
+                process.stderr.write(`$ ${skill.command}\n`);
+                const skillResult = await skillInstall(assistant.skills.target);
+                for (const message of [...skillResult.migrationWarnings, ...skillResult.cleanupWarnings]) {
+                    warn(message);
+                }
+                installedSkillCommands.add(skill.command);
+                installedSkillResults.set(assistant.skills.target, skillResult);
+                results.push({ ...skill, status: 'succeeded' });
+            }
+            const config = findAction(plan, 'cursor', 'print-mcp-config');
+            if (config)
+                results.push({ ...config, status: 'instructions' });
+            continue;
+        }
+        const pluginPreferred = !assistant.plugin.installed &&
+            assistant.plugin.supported &&
+            (assistant.client === 'claude-code' || Boolean(codexMarketplaceSource));
+        if (assistant.current && !pluginPreferred)
+            continue;
+        let pluginReady = assistant.plugin.installed;
+        const marketplace = findAction(plan, assistant.client, 'plugin-marketplace-add');
+        const plugin = findAction(plan, assistant.client, 'plugin-install');
+        if (!pluginReady && marketplace && plugin && marketplace.argv && plugin.argv) {
+            const marketplaceResult = await runner(marketplace.argv[0], marketplace.argv.slice(1), {
+                echoCommand: true,
+                echoOutput: true,
+            });
+            const recordedMarketplace = commandResult(marketplace, marketplaceResult);
+            results.push(recordedMarketplace);
+            if (recordedMarketplace.status !== 'failed') {
+                const pluginResult = await runner(plugin.argv[0], plugin.argv.slice(1), {
+                    echoCommand: true,
+                    echoOutput: true,
+                });
+                const recordedPlugin = commandResult(plugin, pluginResult);
+                results.push(recordedPlugin);
+                pluginReady = recordedPlugin.status === 'succeeded';
+            }
+        }
+        if (!pluginReady) {
+            const mcp = findAction(plan, assistant.client, 'mcp-add');
+            if (mcp?.argv) {
+                const result = await runner(mcp.argv[0], mcp.argv.slice(1), {
+                    echoCommand: true,
+                    echoOutput: true,
+                });
+                const recorded = commandResult(mcp, result);
+                results.push(recorded);
+                if (recorded.status === 'failed') {
+                    throw userError(`${assistant.client} MCP setup failed: ${recorded.detail ?? 'unknown error'}`, 'ASSISTANT_MCP_SETUP_FAILED');
+                }
+            }
+            const skill = findAction(plan, assistant.client, 'skills-install');
+            if (skill?.command && !installedSkillCommands.has(skill.command)) {
+                process.stderr.write(`$ ${skill.command}\n`);
+                const skillResult = await skillInstall(assistant.skills.target);
+                for (const message of [...skillResult.migrationWarnings, ...skillResult.cleanupWarnings]) {
+                    warn(message);
+                }
+                installedSkillCommands.add(skill.command);
+                installedSkillResults.set(assistant.skills.target, skillResult);
+                results.push({ ...skill, status: 'succeeded' });
+            }
+        }
+        const login = findAction(plan, assistant.client, 'mcp-login');
+        if (login?.argv) {
+            const loginResult = await runner(login.argv[0], login.argv.slice(1), {
+                echoCommand: true,
+                inheritStdio: true,
+            });
+            results.push(commandResult(login, loginResult));
+        }
+    }
+    const completedActionIds = new Set(results.map(row => row.id));
+    for (const planned of plan.plannedActions) {
+        if (completedActionIds.has(planned.id))
+            continue;
+        results.push({
+            ...planned,
+            status: 'skipped',
+            detail: planned.condition === 'if-plugin-fails'
+                ? 'plugin setup succeeded; fallback was not needed'
+                : 'an earlier prerequisite did not complete',
+        });
+    }
+    const updatedAssistants = assistants.map(assistant => {
+        const clientResults = results.filter(row => row.client === assistant.client || row.client === 'shared');
+        const pluginInstalled = clientResults.some(row => row.kind === 'plugin-install' && row.status === 'succeeded');
+        const mcpConfigured = clientResults.some(row => row.kind === 'mcp-add' && row.status === 'succeeded');
+        const mcpAuthenticated = clientResults.some(row => row.kind === 'mcp-login' && row.status === 'succeeded');
+        const skillResult = installedSkillResults.get(assistant.skills.target);
+        const plugin = pluginInstalled
+            ? {
+                installed: true,
+                supported: true,
+                id: assistant.client === 'claude-code' ? CLAUDE_REPOSITORY_PLUGIN_ID : CODEX_PLUGIN_ID,
+            }
+            : assistant.plugin;
+        const mcp = {
+            installed: assistant.mcp.installed || mcpConfigured,
+            ...(assistant.client === 'codex'
+                ? {
+                    authentication: mcpAuthenticated
+                        ? 'authenticated'
+                        : (assistant.mcp.authentication ?? 'unknown'),
+                }
+                : {}),
+        };
+        const installedVersions = skillResult?.availableSkillSetVersions?.length
+            ? skillResult.availableSkillSetVersions
+            : skillResult?.updateSkillSetVersion
+                ? [skillResult.updateSkillSetVersion]
+                : assistant.skills.versions;
+        const skills = skillResult
+            ? {
+                ...assistant.skills,
+                installed: assistant.skills.total,
+                current: true,
+                versions: installedVersions,
+                statuses: { current: assistant.skills.total },
+            }
+            : assistant.skills;
+        const current = (plugin.installed || (mcp.installed && skills.current)) &&
+            (assistant.client !== 'codex' || mcp.authentication === 'authenticated');
+        return {
+            ...assistant,
+            plugin,
+            mcp,
+            skills,
+            current,
+            ...(current ? { note: undefined } : {}),
+        };
+    });
+    return {
+        ...plan,
+        authentication: connected ? { status: 'authenticated' } : plan.authentication,
+        assistants: updatedAssistants,
+        results,
+        changed: results.some(row => [
+            'connect',
+            'plugin-marketplace-add',
+            'plugin-install',
+            'mcp-add',
+            'mcp-login',
+            'skills-install',
+        ].includes(row.kind) && row.status === 'succeeded'),
+    };
+};
+const humanSetup = (result) => {
+    printKeyValues([
+        ['mode', result.statusOnly ? 'status (no changes)' : 'setup'],
+        ['requested client', result.requestedClient],
+        ['skills scope', result.skillsScope],
+        ['authentication', result.authentication.status],
+        ['changed', result.changed ? 'yes' : 'no'],
+    ]);
+    process.stdout.write('\nAssistants\n');
+    printTable(['client', 'detected', 'plugin', 'MCP', 'skills', 'current'], result.assistants.map(row => [
+        row.client,
+        row.detected ? 'yes' : 'no',
+        row.plugin.installed
+            ? `${row.plugin.id ?? 'installed'}${row.plugin.version ? ` ${row.plugin.version}` : ''}`
+            : row.plugin.supported
+                ? 'available'
+                : 'unavailable',
+        row.mcp.installed ? 'configured' : 'not configured',
+        `${row.skills.installed}/${row.skills.total} (${row.skills.versions.join(', ') || '-'})`,
+        row.current ? 'yes' : (row.note ?? 'no'),
+    ]));
+    process.stdout.write('\nPlanned actions\n');
+    printTable(['condition', 'client', 'action', 'command'], result.plannedActions.map(row => [
+        row.condition,
+        row.client,
+        row.kind,
+        row.command ?? 'print the MCP configuration below',
+    ]));
+    if (result.results.length > 0) {
+        process.stdout.write('\nResults\n');
+        printTable(['client', 'action', 'status', 'detail'], result.results.map(row => [row.client, row.kind, row.status, row.detail]));
+    }
+    if (result.assistants.some(row => row.client === 'cursor' && row.detected)) {
+        process.stdout.write(`\nCursor MCP config\n${JSON.stringify(result.cursorMcpConfig, null, 2)}\n`);
+    }
+    process.stdout.write('\nManual setup\n');
+    printTable(['client', 'docs'], result.manualSetup.map(row => [row.client, row.url]));
+    if (!result.statusOnly && result.nextSteps.length > 0) {
+        process.stdout.write('\nNext\n');
+        for (const step of result.nextSteps) {
+            process.stdout.write(`- ${step.client}: ${step.text}\n`);
+        }
+    }
+};
+const assertClient = (value) => {
+    if (!['claude-code', 'codex', 'cursor', 'all'].includes(value)) {
+        throw userError('--client must be claude-code, codex, cursor, or all.', 'BAD_SETUP_CLIENT');
+    }
+    return value;
+};
+const assertSkillsScope = (value) => {
+    if (!['global', 'project'].includes(value)) {
+        throw userError('--skills-scope must be global or project.', 'BAD_SKILLS_SCOPE');
+    }
+    return value;
+};
+export const probeSetupAuthentication = async (statusOnly, probe) => {
+    try {
+        return { status: (await probe()) ? 'authenticated' : 'missing' };
+    }
+    catch (error) {
+        if (!statusOnly)
+            throw error;
+        return {
+            status: 'unavailable',
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+};
+export const registerAgentSetup = (agent) => {
+    agent
+        .command('setup')
+        .description('Set up Controller AI end to end for installed coding assistants')
+        .option('--client <client>', 'claude-code, codex, cursor, or all', 'all')
+        .option('--status', 'show installed state and the action plan without changing anything', false)
+        .option('--yes', 'approve setup actions without prompting', false)
+        .option('--skills-scope <scope>', 'global or project', 'global')
+        .action(async (opts, command) => {
+        const statusProbe = () => probeSetupAuthentication(opts.status, async () => {
+            const result = await authenticationStatus(command);
+            return result.authenticated;
+        });
+        const result = await runAgentSetup({
+            client: assertClient(opts.client),
+            status: opts.status,
+            yes: opts.yes,
+            skillsScope: assertSkillsScope(opts.skillsScope),
+        }, {
+            authentication: statusProbe,
+            ensureAuthenticated: async () => {
+                await ensureAuthentication(command);
+            },
+        });
+        emit(result, () => humanSetup(result));
+    });
+};
+//# sourceMappingURL=agentSetup.js.map