@runtypelabs/cli 2.59.1 → 2.59.2

package/dist/chunk-DJQ47WYZ.js

@@ -0,0 +1,664 @@
+#!/usr/bin/env node
+import { D as runSkillsInstall, t as isTTY } from "./index.js";
+import { a as printJson } from "./chunk-CcFCyqbB.js";
+import { t as promptSelect } from "./chunk-BrhgdnM3.js";
+import { Command } from "commander";
+import chalk from "chalk";
+import { copyFileSync, existsSync, realpathSync, unlinkSync } from "fs";
+import { delimiter, join } from "path";
+import { spawn } from "child_process";
+import { tmpdir } from "os";
+// src/lib/mcp-install.ts
+const RUNTYPE_MCP_NAME = "runtype";
+const RUNTYPE_MCP_URL = "https://api.runtype.com/v1/mcp/protocol";
+const SUPPORTED_MCP_AGENTS = [
+	"claude-code",
+	"codex",
+	"cursor",
+	"gemini-cli",
+	"opencode",
+	"vscode"
+];
+function resolveVscodeCli(options = {}) {
+	const platform = options.platform ?? process.platform;
+	const pathValue = options.pathValue ?? process.env.PATH;
+	const pathExists = options.exists ?? existsSync;
+	const resolveRealpath = options.realpath ?? realpathSync;
+	const macosCli = "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code";
+	if (platform === "darwin" && pathExists(macosCli)) return { executable: macosCli };
+	if (platform !== "win32") {
+		const codePath = pathValue?.split(delimiter).map((directory) => join(directory, "code")).find((candidate) => pathExists(candidate));
+		if (codePath) {
+			const resolvedPath = resolveRealpath(codePath);
+			if (/(?:^|[\\/])cursor(?:\.app)?(?:[\\/]|$)/i.test(resolvedPath)) return { error: "The `code` command on PATH belongs to Cursor, not VS Code. Install the VS Code shell command and retry." };
+		}
+	}
+	return { executable: "code" };
+}
+const vscodeCli = resolveVscodeCli();
+const MCP_AGENT_DEFINITIONS = {
+	"claude-code": {
+		displayName: "Claude Code",
+		executable: "claude",
+		inspectArgs: [
+			"mcp",
+			"get",
+			RUNTYPE_MCP_NAME
+		],
+		addArgs: [
+			"mcp",
+			"add",
+			"--transport",
+			"http",
+			"--scope",
+			"user",
+			RUNTYPE_MCP_NAME,
+			RUNTYPE_MCP_URL
+		],
+		forceFallbackWriter: true,
+		authExecutable: "claude",
+		authArgs: [
+			"mcp",
+			"login",
+			RUNTYPE_MCP_NAME
+		],
+		restartInstruction: "Start a new Claude Code session (or reload MCP servers).",
+		skillsAgentId: "claude"
+	},
+	codex: {
+		displayName: "Codex",
+		executable: "codex",
+		inspectArgs: [
+			"mcp",
+			"get",
+			RUNTYPE_MCP_NAME,
+			"--json"
+		],
+		addArgs: [
+			"mcp",
+			"add",
+			RUNTYPE_MCP_NAME,
+			"--url",
+			RUNTYPE_MCP_URL
+		],
+		forceFallbackWriter: true,
+		authExecutable: "codex",
+		authArgs: [
+			"mcp",
+			"login",
+			RUNTYPE_MCP_NAME
+		],
+		restartInstruction: "Restart Codex or start a new Codex task.",
+		skillsAgentId: "codex"
+	},
+	cursor: {
+		displayName: "Cursor",
+		effectiveInspectExecutable: "cursor-agent",
+		effectiveInspectArgs: ["mcp", "list"],
+		authExecutable: "cursor-agent",
+		authArgs: [
+			"mcp",
+			"login",
+			RUNTYPE_MCP_NAME
+		],
+		fallbackWriter: true,
+		restartInstruction: "Restart Cursor or start a new Cursor agent session.",
+		skillsAgentId: "cursor"
+	},
+	"gemini-cli": {
+		displayName: "Gemini CLI",
+		executable: "gemini",
+		inspectArgs: ["mcp", "list"],
+		addArgs: [
+			"mcp",
+			"add",
+			"--scope",
+			"user",
+			"--transport",
+			"http",
+			RUNTYPE_MCP_NAME,
+			RUNTYPE_MCP_URL
+		],
+		forceFallbackWriter: true,
+		restartInstruction: "Run `/mcp reload` or start a new Gemini CLI session.",
+		manualAuthInstruction: "In Gemini CLI, run `/mcp auth runtype`, then `/mcp reload`.",
+		skillsAgentId: "gemini-cli"
+	},
+	opencode: {
+		displayName: "OpenCode",
+		executable: "opencode",
+		inspectArgs: ["mcp", "list"],
+		addArgs: [
+			"mcp",
+			"add",
+			RUNTYPE_MCP_NAME,
+			"--url",
+			RUNTYPE_MCP_URL
+		],
+		forceFallbackWriter: true,
+		authExecutable: "opencode",
+		authArgs: [
+			"mcp",
+			"auth",
+			RUNTYPE_MCP_NAME
+		],
+		restartInstruction: "Restart OpenCode or start a new OpenCode session.",
+		skillsAgentId: "opencode"
+	},
+	vscode: {
+		displayName: "VS Code",
+		executable: vscodeCli.executable,
+		executableError: vscodeCli.error,
+		addArgs: ["--add-mcp", JSON.stringify({
+			name: RUNTYPE_MCP_NAME,
+			type: "http",
+			url: RUNTYPE_MCP_URL
+		})],
+		restartInstruction: "Reload the VS Code window, then start a new chat.",
+		manualAuthInstruction: "Approve the browser OAuth prompt when Runtype is first used.",
+		skillsAgentId: "copilot"
+	}
+};
+function envFlag(value) {
+	return value !== void 0 && value !== "" && value !== "false" && value !== "0";
+}
+/**
+* Prefer a strong signal from the running harness over filesystem detection.
+* A user may have several agent config directories even though only one agent
+* can pick up the new MCP connection after this command returns.
+*/
+function detectActiveMcpAgent(env = process.env) {
+	if (envFlag(env.CODEX_SHELL) || envFlag(env.CODEX_THREAD_ID) || env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE?.toLowerCase().includes("codex")) return "codex";
+	if (envFlag(env.CLAUDECODE) || envFlag(env.CLAUDE_CODE_SESSION_ID) || envFlag(env.CLAUDE_CODE_ENTRYPOINT)) return "claude-code";
+	if (envFlag(env.CURSOR_AGENT) || envFlag(env.CURSOR_TRACE_ID)) return "cursor";
+	if (envFlag(env.GEMINI_CLI) || envFlag(env.GEMINI_CLI_NO_RELAUNCH)) return "gemini-cli";
+	if (envFlag(env.OPENCODE) || envFlag(env.OPENCODE_CLIENT)) return "opencode";
+	if (env.TERM_PROGRAM?.toLowerCase() === "vscode" && envFlag(env.VSCODE_PID)) return "vscode";
+}
+const AGENT_ALIASES = {
+	claude: "claude-code",
+	"claude-code": "claude-code",
+	codex: "codex",
+	cursor: "cursor",
+	gemini: "gemini-cli",
+	"gemini-cli": "gemini-cli",
+	opencode: "opencode",
+	"open-code": "opencode",
+	vscode: "vscode",
+	"vs-code": "vscode"
+};
+function normalizeMcpAgent(value) {
+	return AGENT_ALIASES[value.trim().toLowerCase()];
+}
+async function loadAddMcpAdapter() {
+	const addMcp = await import("add-mcp");
+	return {
+		detectGlobalAgents: async () => addMcp.detectGlobalAgents(),
+		inspect: async (agent) => {
+			const [result] = await addMcp.listInstalledServers({
+				global: true,
+				agents: [agent]
+			});
+			if (!result) throw new Error(`add-mcp did not return a global ${MCP_AGENT_DEFINITIONS[agent].displayName} configuration path.`);
+			return {
+				configPath: result.configPath,
+				server: result.servers.find((server) => server.serverName === RUNTYPE_MCP_NAME)
+			};
+		},
+		upsert: (agent) => addMcp.upsertServer(agent, RUNTYPE_MCP_NAME, {
+			type: "http",
+			url: RUNTYPE_MCP_URL
+		})
+	};
+}
+async function detectInstalledMcpAgents(adapter) {
+	const detected = await adapter.detectGlobalAgents();
+	return SUPPORTED_MCP_AGENTS.filter((agent) => detected.includes(agent));
+}
+const runCommand = async (executable, args, options = {}) => {
+	return new Promise((resolve) => {
+		const interactive = options.interactive === true;
+		const child = spawn(executable, args, {
+			stdio: interactive ? "inherit" : [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: process.env,
+			cwd: options.cwd
+		});
+		let stdout = "";
+		let stderr = "";
+		if (!interactive) {
+			child.stdout?.on("data", (chunk) => {
+				stdout += chunk.toString();
+			});
+			child.stderr?.on("data", (chunk) => {
+				stderr += chunk.toString();
+			});
+		}
+		child.on("error", (error) => {
+			resolve({
+				exitCode: null,
+				stdout,
+				stderr,
+				error: error.message
+			});
+		});
+		child.on("close", (exitCode) => {
+			resolve({
+				exitCode,
+				stdout,
+				stderr
+			});
+		});
+	});
+};
+function stripAnsi(value) {
+	return value.replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, "");
+}
+function inspectNativeOutput(agent, result) {
+	const output = stripAnsi(`${result.stdout}\n${result.stderr}`);
+	if (agent === "codex" && result.exitCode === 0) try {
+		const parsed = JSON.parse(result.stdout);
+		if (parsed.transport?.url === "https://api.runtype.com/v1/mcp/protocol") return "matching";
+		if (typeof parsed.transport?.url === "string") return "conflict";
+	} catch {}
+	if (nativeOutputHasMatchingServer(agent, output)) return "matching";
+	if (result.exitCode !== 0 && /(?:not found|does not exist|no mcp server|unknown mcp server)/i.test(output)) return "missing";
+	if (nativeOutputMentionsServerName(output)) return "conflict";
+	return "missing";
+}
+function nativeOutputHasMatchingServer(agent, output) {
+	if (![
+		"cursor",
+		"gemini-cli",
+		"opencode"
+	].includes(agent)) return output.includes(RUNTYPE_MCP_URL);
+	const lines = output.split(/\r?\n/);
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (!nativeOutputMentionsServerName(line)) continue;
+		if (line.includes("https://api.runtype.com/v1/mcp/protocol")) return true;
+		const nextLine = lines[index + 1];
+		const urlIndex = nextLine?.indexOf("https://api.runtype.com/v1/mcp/protocol") ?? -1;
+		if (urlIndex >= 0) {
+			const prefix = nextLine.slice(0, urlIndex);
+			if (!/[a-z0-9_-]/i.test(prefix)) return true;
+		}
+	}
+	return false;
+}
+function nativeOutputMentionsServerName(output) {
+	const withoutUrls = output.replace(/https?:\/\/\S+/gi, "");
+	return /\bruntype\b/i.test(withoutUrls);
+}
+async function configureWithNativeCli(agent, options) {
+	const definition = MCP_AGENT_DEFINITIONS[agent];
+	if (!definition.executable || !definition.addArgs) return {
+		configured: false,
+		changed: false,
+		error: definition.executableError ?? "Native MCP command is unavailable."
+	};
+	if (options.dryRun) return {
+		configured: true,
+		changed: true
+	};
+	let existing = "missing";
+	if (definition.inspectArgs) {
+		const inspection = await options.runner(definition.executable, definition.inspectArgs, { cwd: tmpdir() });
+		if (inspection.error?.includes("ENOENT")) {
+			if (agent === "codex") {
+				const adapter = options.adapter ?? await loadAddMcpAdapter();
+				return configureWithFallbackWriter(agent, {
+					force: options.force,
+					adapter
+				});
+			}
+			return {
+				configured: false,
+				changed: false,
+				error: `${definition.displayName}'s CLI (${definition.executable}) is not on PATH.`
+			};
+		}
+		existing = inspectNativeOutput(agent, inspection);
+	}
+	if (existing === "matching") return {
+		configured: true,
+		changed: false
+	};
+	if (existing === "conflict" && !options.force) return {
+		configured: false,
+		changed: false,
+		error: `An MCP server named "${RUNTYPE_MCP_NAME}" already points somewhere else. Re-run with --force to replace it.`
+	};
+	if (existing === "conflict" && definition.forceFallbackWriter) return configureWithFallbackWriter(agent, {
+		force: true,
+		adapter: options.adapter ?? await loadAddMcpAdapter()
+	});
+	const installation = await options.runner(definition.executable, definition.addArgs, { cwd: tmpdir() });
+	if (installation.error?.includes("ENOENT")) {
+		if (agent === "codex") {
+			const adapter = options.adapter ?? await loadAddMcpAdapter();
+			return configureWithFallbackWriter(agent, {
+				force: options.force,
+				adapter
+			});
+		}
+		return {
+			configured: false,
+			changed: false,
+			error: `${definition.displayName}'s CLI (${definition.executable}) is not on PATH.`
+		};
+	}
+	if (installation.exitCode !== 0) return {
+		configured: false,
+		changed: false,
+		error: stripAnsi(installation.stderr || installation.stdout).trim() || `Could not configure ${definition.displayName}.`
+	};
+	return {
+		configured: true,
+		changed: true
+	};
+}
+async function configureWithFallbackWriter(agent, options) {
+	let inspected;
+	try {
+		inspected = await options.adapter.inspect(agent);
+	} catch (error) {
+		return {
+			configured: false,
+			changed: false,
+			error: `Could not inspect ${MCP_AGENT_DEFINITIONS[agent].displayName}'s MCP configuration: ${getErrorMessage(error)}`
+		};
+	}
+	if (inspected.server?.identity === "https://api.runtype.com/v1/mcp/protocol") return {
+		configured: true,
+		changed: false,
+		configPath: inspected.configPath
+	};
+	if (inspected.server && !options.force) return {
+		configured: false,
+		changed: false,
+		configPath: inspected.configPath,
+		error: `An MCP server named "${RUNTYPE_MCP_NAME}" already points somewhere else. Re-run with --force to replace it.`
+	};
+	if (options.dryRun) return {
+		configured: true,
+		changed: true,
+		configPath: inspected.configPath
+	};
+	const backupPath = existsSync(inspected.configPath) ? `${inspected.configPath}.runtype.bak` : void 0;
+	if (backupPath) copyFileSync(inspected.configPath, backupPath);
+	let installation;
+	try {
+		installation = options.adapter.upsert(agent);
+	} catch (error) {
+		restoreFallbackConfig(inspected.configPath, backupPath);
+		return {
+			configured: false,
+			changed: false,
+			configPath: inspected.configPath,
+			backupPath,
+			error: `Could not update ${MCP_AGENT_DEFINITIONS[agent].displayName}'s MCP configuration: ${getErrorMessage(error)}`
+		};
+	}
+	if (!installation.success) {
+		restoreFallbackConfig(inspected.configPath, backupPath);
+		return {
+			configured: false,
+			changed: false,
+			configPath: installation.path,
+			backupPath,
+			error: installation.error ?? `Could not configure ${MCP_AGENT_DEFINITIONS[agent].displayName}.`
+		};
+	}
+	let verified;
+	try {
+		verified = await options.adapter.inspect(agent);
+	} catch (error) {
+		restoreFallbackConfig(inspected.configPath, backupPath);
+		return {
+			configured: false,
+			changed: false,
+			configPath: installation.path,
+			backupPath,
+			error: `The MCP config could not be verified, so the previous config was restored: ${getErrorMessage(error)}`
+		};
+	}
+	if (verified.server?.identity !== "https://api.runtype.com/v1/mcp/protocol") {
+		restoreFallbackConfig(inspected.configPath, backupPath);
+		return {
+			configured: false,
+			changed: false,
+			configPath: installation.path,
+			backupPath,
+			error: "The MCP config could not be verified, so the previous config was restored."
+		};
+	}
+	return {
+		configured: true,
+		changed: true,
+		configPath: installation.path,
+		backupPath
+	};
+}
+function getErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function restoreFallbackConfig(configPath, backupPath) {
+	if (backupPath) copyFileSync(backupPath, configPath);
+	else if (existsSync(configPath)) unlinkSync(configPath);
+}
+async function configureMcpAgent(agent, options = {}) {
+	try {
+		if (MCP_AGENT_DEFINITIONS[agent].fallbackWriter) {
+			const adapter = options.adapter ?? await loadAddMcpAdapter();
+			return configureWithFallbackWriter(agent, {
+				...options,
+				adapter
+			});
+		}
+		return configureWithNativeCli(agent, {
+			...options,
+			runner: options.runner ?? runCommand
+		});
+	} catch (error) {
+		return {
+			configured: false,
+			changed: false,
+			error: `Could not configure ${MCP_AGENT_DEFINITIONS[agent].displayName}: ${getErrorMessage(error)}`
+		};
+	}
+}
+async function authenticateMcpAgent(agent, options = {}) {
+	const definition = MCP_AGENT_DEFINITIONS[agent];
+	if (options.dryRun || options.login === false) return {
+		authenticated: false,
+		attempted: false,
+		instruction: definition.manualAuthInstruction ?? `Run \`${definition.authExecutable} ${definition.authArgs?.join(" ")}\` to complete OAuth.`
+	};
+	const effectiveError = await getEffectiveConfigurationError(agent, options.runner ?? runCommand);
+	if (effectiveError) return {
+		authenticated: false,
+		attempted: false,
+		error: effectiveError
+	};
+	if (!definition.authExecutable || !definition.authArgs) return {
+		authenticated: false,
+		attempted: false,
+		instruction: definition.manualAuthInstruction
+	};
+	const result = await (options.runner ?? runCommand)(definition.authExecutable, definition.authArgs, { interactive: true });
+	if (result.error?.includes("ENOENT")) return {
+		authenticated: false,
+		attempted: false,
+		instruction: `Run \`${definition.authExecutable} ${definition.authArgs.join(" ")}\` when that CLI is available.`
+	};
+	if (result.exitCode !== 0) return {
+		authenticated: false,
+		attempted: true,
+		error: `OAuth did not complete for ${definition.displayName}.`,
+		instruction: `Retry with \`${definition.authExecutable} ${definition.authArgs.join(" ")}\`.`
+	};
+	return {
+		authenticated: true,
+		attempted: true
+	};
+}
+async function getEffectiveConfigurationError(agent, runner) {
+	const definition = MCP_AGENT_DEFINITIONS[agent];
+	const executable = definition.effectiveInspectExecutable ?? definition.executable;
+	const args = definition.effectiveInspectArgs ?? definition.inspectArgs;
+	if (!executable || !args) return void 0;
+	const inspection = await runner(executable, args);
+	if (inspection.error?.includes("ENOENT")) return void 0;
+	if (inspectNativeOutput(agent, inspection) === "matching") return void 0;
+	return `The current project resolves an MCP server named "${RUNTYPE_MCP_NAME}" somewhere other than ${RUNTYPE_MCP_URL}. Remove or rename the project/local entry before completing OAuth.`;
+}
+function getMcpRestartInstruction(agent) {
+	return MCP_AGENT_DEFINITIONS[agent].restartInstruction;
+}
+function getMcpSkillsAgentId(agent) {
+	return MCP_AGENT_DEFINITIONS[agent].skillsAgentId;
+}
+async function selectAgent(options, tty) {
+	if (options.agent) {
+		const explicit = normalizeMcpAgent(options.agent);
+		if (!explicit) throw new Error(`Unsupported agent "${options.agent}". Use claude, codex, cursor, gemini, opencode, or vscode.`);
+		return explicit;
+	}
+	const active = detectActiveMcpAgent();
+	if (active) return active;
+	const detected = await detectInstalledMcpAgents(await loadAddMcpAdapter());
+	if (detected.length === 1) return detected[0];
+	if (detected.length === 0) throw new Error("Could not detect the current coding agent. Re-run with --agent <claude|codex|cursor|gemini|opencode|vscode>.");
+	if (!tty || !process.stdin.isTTY || !process.stdout.isTTY || options.json) throw new Error(`Several coding agents were detected (${detected.join(", ")}). Re-run with --agent <id> so only the current harness is changed.`);
+	return promptSelect("Which coding agent should Runtype configure?", detected.map((agent) => ({
+		value: agent,
+		label: MCP_AGENT_DEFINITIONS[agent].displayName,
+		description: "user-level MCP configuration"
+	})), { promptLabel: "Agent" });
+}
+// src/commands/install-mcp.ts
+async function installSkillsForAgent(agent, jsonMode) {
+	const rosieId = getMcpSkillsAgentId(agent);
+	try {
+		const result = await runSkillsInstall([{
+			name: MCP_AGENT_DEFINITIONS[agent].displayName,
+			rosieId
+		}], {
+			accepted: true,
+			quiet: jsonMode
+		});
+		if (!result) return {
+			status: "error",
+			installedAgents: [],
+			failedAgents: [rosieId],
+			error: "The Runtype skill installer did not complete."
+		};
+		return {
+			status: result.failedAgents.length > 0 ? "error" : "installed",
+			...result
+		};
+	} catch (error) {
+		return {
+			status: "error",
+			installedAgents: [],
+			failedAgents: [rosieId],
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+const installMcpCommand = new Command("install-mcp").description("Install Runtype skills and the OAuth MCP server for this coding agent").option("--agent <id>", "Coding agent to configure (auto-detected by default)").option("--force", "Replace a conflicting MCP server named \"runtype\"").option("--dry-run", "Show the selected agent and planned changes without writing them").option("--no-login", "Configure MCP without starting browser OAuth").option("--no-skills", "Configure MCP without installing Runtype agent skills").option("--json", "Structured JSON output; implies --no-login").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options, cmd) => {
+	const globals = cmd.optsWithGlobals();
+	const jsonMode = !!(options.json ?? globals.json);
+	const tty = isTTY(options);
+	let agent;
+	try {
+		agent = await selectAgent({
+			...options,
+			json: jsonMode
+		}, tty);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (jsonMode) printJson({
+			status: "error",
+			code: "AGENT_DETECTION_FAILED",
+			error: message
+		});
+		else console.error(chalk.red(message));
+		process.exitCode = 1;
+		return;
+	}
+	const definition = MCP_AGENT_DEFINITIONS[agent];
+	if (!jsonMode) console.log(chalk.cyan(`\nSetting up Runtype for ${definition.displayName}…`));
+	const configuration = await configureMcpAgent(agent, {
+		force: options.force,
+		dryRun: options.dryRun
+	});
+	if (!configuration.configured) {
+		if (jsonMode) printJson({
+			status: "error",
+			code: "MCP_CONFIG_FAILED",
+			agent,
+			configuration
+		});
+		else console.error(chalk.red(configuration.error ?? "Could not configure Runtype MCP."));
+		process.exitCode = 1;
+		return;
+	}
+	if (!jsonMode) {
+		if (options.dryRun) console.log(chalk.green("✓ Would install the user-level Runtype MCP connection."));
+		else if (configuration.changed) console.log(chalk.green("✓ Installed the user-level Runtype MCP connection."));
+		else console.log(chalk.green("✓ Runtype MCP is already configured at the correct URL."));
+		if (configuration.configPath) console.log(chalk.dim(`  ${configuration.configPath}`));
+		if (configuration.backupPath) console.log(chalk.dim(`  Backup: ${configuration.backupPath}`));
+	}
+	const authentication = await authenticateMcpAgent(agent, {
+		login: !jsonMode && tty && options.login !== false,
+		dryRun: options.dryRun
+	});
+	if (!jsonMode && !options.dryRun) {
+		if (authentication.authenticated) console.log(chalk.green("✓ MCP OAuth completed."));
+		else if (authentication.error) console.log(chalk.yellow(`! ${authentication.error}`));
+		else if (authentication.instruction) console.log(chalk.yellow(`! OAuth action required: ${authentication.instruction}`));
+	}
+	const skills = options.skills === false || options.dryRun ? {
+		status: options.dryRun ? "planned" : "skipped",
+		installedAgents: [],
+		failedAgents: []
+	} : await installSkillsForAgent(agent, jsonMode);
+	if (!jsonMode && !options.dryRun && skills.status === "error") console.log(chalk.yellow(`! Runtype MCP is configured, but skill installation failed: ${skills.error ?? "unknown error"}`));
+	const restartInstruction = getMcpRestartInstruction(agent);
+	const nextSteps = [];
+	if (options.dryRun) nextSteps.push(`Re-run \`runtype install-mcp --agent ${agent}\` without --dry-run to install skills and MCP.`);
+	else {
+		if (authentication.instruction) nextSteps.push(authentication.instruction);
+		if (authentication.error && !authentication.instruction) nextSteps.push(`Resolve the OAuth blocker reported above, then re-run this command.`);
+		if (skills.status === "error") nextSteps.push(`Retry skill installation with \`runtype install-mcp --agent ${agent} --no-login\`.`);
+		else if (skills.status === "skipped") nextSteps.push(`Install the Runtype skills with \`runtype skills install --agent ${getMcpSkillsAgentId(agent)}\`.`);
+		nextSteps.push("Continue this first session with the Runtype CLI; this running agent may not see the new MCP connection yet.");
+		if (authentication.authenticated && skills.status === "installed") nextSteps.push(`Tell the user that Runtype skills and OAuth MCP are installed, then ask them to restart or reload ${definition.displayName}.`);
+		else nextSteps.push(`Tell the user that the MCP configuration was installed but setup still has the action(s) above; do not call setup complete yet.`);
+		nextSteps.push(`After completing any action above, ${restartInstruction} Then use Runtype MCP first and call get_build_instructions before building.`);
+	}
+	const partial = Boolean(authentication.error) || skills.status === "error";
+	if (jsonMode) printJson({
+		status: options.dryRun ? "planned" : partial ? "partial" : authentication.authenticated ? "ok" : "action-required",
+		agent,
+		configuration,
+		authentication,
+		skills,
+		activation: options.dryRun ? "not-configured" : "restart-required",
+		nextSteps
+	});
+	else {
+		console.log(chalk.bold("\nDo exactly this next:"));
+		nextSteps.forEach((step, index) => console.log(`  ${index + 1}. ${step}`));
+		console.log("");
+	}
+	if (partial) process.exitCode = 1;
+});
+export { getMcpSkillsAgentId as a, getMcpRestartInstruction as i, installMcpCommand, installSkillsForAgent, authenticateMcpAgent as n, selectAgent as o, configureMcpAgent as r, MCP_AGENT_DEFINITIONS as t };
+