@runtypelabs/cli 2.59.0 → 2.59.2

package/dist/chunk-Dz7cEtxl.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import { r as createCliClient } from "./chunk-BW2fg46T.js";
+import { n as ensureAuth } from "./chunk-CJraEBVd.js";
+import { a as printJson } from "./chunk-CcFCyqbB.js";
+import { Command } from "commander";
+import chalk from "chalk";
+import { readFile } from "node:fs/promises";
+// src/commands/signals.ts
+const signalsCommand = new Command("signals").description("Configure trace signals: typed fields read out of every bound agent turn");
+async function run(action) {
+	try {
+		const apiKey = await ensureAuth();
+		if (!apiKey) return;
+		printJson(await action(createCliClient(apiKey)));
+	} catch (error) {
+		console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+		process.exitCode = 1;
+	}
+}
+async function readDefinition(path) {
+	return JSON.parse(await readFile(path, "utf8"));
+}
+function positiveNumber(value) {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed <= 0) throw new Error(`Expected a positive number, got "${value}"`);
+	return parsed;
+}
+signalsCommand.command("list").description("List signal sets, newest first").option("--presets", "List the presets `create --preset` accepts instead").action((options) => run((client) => options.presets ? client.signals.listPresets() : client.signals.listSets()));
+signalsCommand.command("get <signalSetId>").description("Show a signal set with every version").action((id) => run((client) => client.signals.getSet(id)));
+signalsCommand.command("create <name>").description("Create a signal set from a preset or a definition file; version 1 is current at once").option("--preset <preset>", "Start from a preset: conversation_health or failure_detector").option("-f, --file <path>", "JSON definition: { signals: { <key>: { type, instructions, ... } } }").option("--description <text>", "What the set watches for").action((name, options) => run(async (client) => client.signals.createSet({
+	name,
+	...options.description ? { description: options.description } : {},
+	...options.preset ? { preset: options.preset } : {},
+	...options.file ? { definition: await readDefinition(options.file) } : {}
+})));
+signalsCommand.command("update <signalSetId>").description("Rename or re-describe a signal set").option("--name <name>", "New name").option("--description <text>", "New description").action((id, options) => run((client) => client.signals.updateSet(id, options)));
+signalsCommand.command("delete <signalSetId>").description("Delete a signal set; unbind every binding of it first").action((id) => run((client) => client.signals.deleteSet(id)));
+signalsCommand.command("publish <signalSetId>").description("Publish a new immutable version from a definition file and make it current").requiredOption("-f, --file <path>", "JSON definition").action((id, options) => run(async (client) => client.signals.publishVersion(id, await readDefinition(options.file))));
+signalsCommand.command("preview <signalSetId> <version>").description("Dry-run a version over an agent's recent traces (billed, writes nothing)").requiredOption("--agent <agentId>", "Agent whose recent completed traces to read").option("--limit <n>", "Traces to read (default 20, at most 50)", positiveNumber).option("--acknowledge-external-processing", "Only after a human confirms (PHI organization, model outside Workers AI)").action((id, version, options) => run((client) => client.signals.preview(id, positiveNumber(version), {
+	agentId: options.agent,
+	...options.limit !== void 0 ? { limit: options.limit } : {},
+	...options.acknowledgeExternalProcessing ? { acknowledgeExternalProcessing: true } : {}
+})));
+signalsCommand.command("bindings").description("List signal bindings").option("--agent <agentId>", "Only bindings on this agent").option("--set <signalSetId>", "Only bindings of this set").option("--include-disabled", "Also list unbound bindings").action((options) => run((client) => client.signals.listBindings({
+	...options.agent ? { agentId: options.agent } : {},
+	...options.set ? { signalSetId: options.set } : {},
+	...options.includeDisabled ? { includeDisabled: true } : {}
+})));
+signalsCommand.command("bind <signalSetId>").description("Bind a signal set version to an agent").requiredOption("--agent <agentId>", "Native or external (OTLP) agent id").option("--set-version <n>", "Set version (default: current)", positiveNumber).option("--sample-rate <rate>", "Evaluate this share of matching turns instead of all", positiveNumber).option("--uniform-share <share>", "Share drawn before the filter for unbiased rates (default 0.05)", Number).option("--acknowledge-external-processing", "Only after a human confirms (PHI organization, model outside Workers AI)").action((signalSetId, options) => {
+	const input = {
+		signalSetId,
+		target: {
+			kind: "agent",
+			id: options.agent
+		},
+		...options.setVersion !== void 0 ? { versionNumber: options.setVersion } : {},
+		...options.sampleRate !== void 0 ? { coverage: {
+			mode: "sample",
+			rate: options.sampleRate
+		} } : {},
+		...options.uniformShare !== void 0 ? { uniformShare: options.uniformShare } : {},
+		...options.acknowledgeExternalProcessing ? { acknowledgeExternalProcessing: true } : {}
+	};
+	return run((client) => client.signals.bind(input));
+});
+signalsCommand.command("unbind <bindingId>").description("Disable a signal binding").action((id) => run((client) => client.signals.unbind(id)));
+signalsCommand.command("stats").description("Signal rollups over a window (default: the last 7 days)").option("--agent <agentId>", "Only this agent").option("--binding <bindingId>", "Only this binding").option("--sample <sample>", "uniform (live-traffic rates) or filtered").option("--from <iso>", "Window start").option("--to <iso>", "Window end").action((options) => run((client) => client.signals.stats({
+	...options.agent ? { agentId: options.agent } : {},
+	...options.binding ? { bindingId: options.binding } : {},
+	...options.sample === "uniform" || options.sample === "filtered" ? { sample: options.sample } : {},
+	...options.from ? { from: options.from } : {},
+	...options.to ? { to: options.to } : {}
+})));
+const runsCommand = new Command("runs").description("List agent and flow runs");
+runsCommand.command("list").description("List runs, newest first").option("--agent <agentId>", "Only runs of this agent").option("--status <status>", "running, completed or failed").option("--signal <signal>", "Only runs where a signal fired: key, or key:value").option("--conversation <conversationId>", "Only runs of this conversation").option("--limit <n>", "Page size", positiveNumber).option("--cursor <cursor>", "Continue from a previous page").action((options) => run((client) => client.get("/runs", {
+	...options.agent ? { agentId: options.agent } : {},
+	...options.status ? { status: options.status } : {},
+	...options.signal ? { signal: options.signal } : {},
+	...options.conversation ? { conversationId: options.conversation } : {},
+	...options.limit !== void 0 ? { limit: options.limit } : {},
+	...options.cursor ? { cursor: options.cursor } : {}
+})));
+export { runsCommand, signalsCommand };
+

package/dist/chunk-E_0bgjrS.js

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+import { b as CredentialStore, t as isTTY } from "./index.js";
+import { l as getRuntimeApiKey } from "./chunk-BW2fg46T.js";
+import { n as ensureAuth } from "./chunk-CJraEBVd.js";
+import { a as printJson } from "./chunk-CcFCyqbB.js";
+import { a as getMcpSkillsAgentId, i as getMcpRestartInstruction, installSkillsForAgent, n as authenticateMcpAgent, o as selectAgent, r as configureMcpAgent, t as MCP_AGENT_DEFINITIONS } from "./chunk-DJQ47WYZ.js";
+import { Command } from "commander";
+import chalk from "chalk";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+// ../shared/dist/agent-onboarding-content.mjs
+const AGENT_ONBOARDING_MARKDOWN = `# Runtype for Coding Agents
+
+Use this guide when the user asks to connect their coding harness to Runtype. If they only ask what Runtype does, explain it without installing software or creating an account. During setup, use the CLI until the hosted MCP tools are available.
+
+Signup never requires a browser. Ask only for the email address and emailed 6-digit code during new-account verification. Do not tell the user to open a dashboard, sign-in page, or OAuth window during signup. Existing-account recovery and the harness's MCP OAuth are separate paths below.
+
+## Golden path — do exactly this
+
+If the live Runtype MCP tools are already available in this session, skip setup and go to "After MCP is active" below. Otherwise follow every step in order:
+
+### 1. Install the CLI and check auth
+
+\`\`\`bash
+npm install -g @runtypelabs/cli
+runtype auth status
+\`\`\`
+
+Reuse an installed CLI rather than reinstalling it. If status reports \`authenticated\` with \`accountState: "full"\`, skip to step 3. If it reports a pending signup, follow its \`next\` command instead of registering again. If it reports \`unauthenticated\` with a non-null \`requestedOrgId\`, this directory is linked to an organization (\`.runtype/project.json\`, \`--org\`, or \`RUNTYPE_ORG\`) that has no stored login: do not register a new account. Have the user privately run \`runtype auth login --api-key <key>\` with a key from that organization (or \`runtype login\` in their own terminal), then verify with \`runtype auth whoami --no-tty\`. If the link looks wrong, confirm with the user before \`runtype unlink\`. If \`RUNTYPE_API_KEY\` is configured, verify it with \`runtype auth whoami --no-tty\` and reuse that account before following stored signup state: \`auth status\` only inspects stored credentials. Never print the key.
+
+### 2. Sign the user up from the terminal
+
+Ask the user one question: "What email address should I use for your Runtype account?" Then run:
+
+\`\`\`bash
+runtype auth register --email <their-email>
+\`\`\`
+
+This creates the account and emails the user a 6-digit code. Ask the user: "Runtype emailed a 6-digit code to <their-email> — what is it?" Then run:
+
+\`\`\`bash
+runtype auth verify <code>
+\`\`\`
+
+That completes signup. Every command in this flow prints JSON with a \`next\` field — follow it. Notes:
+
+- These commands work without a TTY and never open a browser.
+- \`register\` is safe to re-run; it resumes a pending signup instead of creating a duplicate account.
+- After \`register\` (before \`verify\`) you already hold a temporary credential: CLI commands work with restricted models and quota, and \`verify\` upgrades the same stored login in place. Do not build anything substantial until \`verify\` succeeds.
+- If the email already has an account, \`email_already_registered\` means signup cannot claim it. Have the user configure an API key privately in their terminal/environment (\`RUNTYPE_API_KEY\` or \`runtype auth login --api-key <key>\`), then run \`runtype auth whoami --no-tty\` to verify the effective credential. Do not ask them to paste a key into chat or register a replacement account.
+- A wrong code returns \`otp_invalid\` — ask the user to re-check and run \`runtype auth verify\` again. An expired code returns \`otp_expired\` — re-send with \`runtype auth claim <email>\`. Codes expire after 10 minutes and lock after 5 wrong attempts, so confirm the code with the user rather than guessing; after a lockout or expiry, re-send with \`runtype auth claim <email>\`.
+
+### 3. Install skills and the MCP connection
+
+\`\`\`bash
+runtype install-mcp
+\`\`\`
+
+This detects one coding harness, installs its Runtype skills, and writes user-level hosted MCP configuration. If selection is ambiguous, use \`--agent <id>\` for the current harness. Relay any harness-owned OAuth action to the user; it may open a browser and is separate from browserless signup.
+
+### 4. Keep working in this session with the CLI
+
+Do not stop just because the new MCP connection is not visible yet. Use CLI commands for useful first-session work:
+
+\`\`\`bash
+runtype auth whoami
+runtype --help
+\`\`\`
+
+Continue the user's task, not an unsolicited inventory of their account. Read command help before mutations. \`runtype mcp tools\` lists hosted tools and \`runtype mcp call <tool>\` invokes one without a restart; use this bridge for build instructions, schemas, validation, and setup checks too.
+
+### 5. Tell the user to restart or reload the harness
+
+Before finishing this session, read the final status and next steps from \`runtype install-mcp\`. Retry any failed skill installation. Do not call setup complete while the command reports \`action-required\`, \`partial\`, or an error.
+
+Only after signup is verified and skills are installed, tell the user exactly what changed and ask them to restart or reload the coding harness. Use direct language such as:
+
+> Your Runtype account is verified and the skills plus MCP connection are installed. Please restart or reload this coding agent (or start a new session) so it can activate the new MCP tools. I used the CLI to keep this first session productive; after restart I will use MCP by default.
+
+If an action remains, report that exact action instead of using the success wording above. Do not claim the running agent can use MCP until its Runtype tools actually appear.
+
+### 6. Switch to MCP after restart
+
+Once the tools appear, use Runtype MCP first. Do not fall back to the CLI just because it worked previously. For a product build, call \`get_build_instructions\` with:
+
+\`\`\`json
+{
+  "task": "build-product",
+  "description": "Describe the user's product goal here"
+}
+\`\`\`
+
+For a bare flow use \`task: "generate-flow"\`; for scoping use \`"explain-capabilities"\`. Read-only account operations do not need build instructions. Fetch only relevant schema topics, validate before creating or updating, and test safely before reporting success.
+
+## If the install needs recovery
+
+\`runtype install-mcp\` intentionally changes one confidently selected harness, not every agent config it can find. If detection is ambiguous, re-run it with one explicit id:
+
+\`\`\`bash
+runtype install-mcp --agent claude
+runtype install-mcp --agent codex
+runtype install-mcp --agent cursor
+runtype install-mcp --agent gemini
+runtype install-mcp --agent opencode
+runtype install-mcp --agent vscode
+\`\`\`
+
+Use only the line for the current harness. Follow the command's restart instructions. Use \`--force\` only when the command reports that an existing MCP server named \`runtype\` points to a different URL and the user agrees to replace it.
+
+## Auth reference
+
+The signup commands wrap the agent auth protocol documented at \`https://runtype.com/auth.md\` (anonymous registration plus an email claim ceremony). You normally never need the raw protocol — the CLI is the supported client:
+
+- \`runtype auth register --email <email>\` — create the account and send the code (one step)
+- \`runtype auth claim <email>\` — re-send or change the email for a pending signup
+- \`runtype auth verify <code>\` — finish signup with the 6-digit code
+- \`runtype auth login --api-key <key>\` — privately store an existing credential; not an account-creation command
+- \`runtype auth status\` — inspect the login this directory uses, linked-org state, and pending signup state
+- \`runtype auth accounts\` — list stored logins (one per organization)
+- \`runtype link <orgId>\` — pin the current project to an organization (writes \`.runtype/project.json\`, no secrets)
+- \`runtype auth whoami --no-tty\` — verify the effective credential (environment key first, then stored login)
+
+A user-supplied \`RUNTYPE_API_KEY\` environment variable also authenticates API-backed CLI commands without a stored login; \`auth status\` still describes only the stored state. Never print a credential into the transcript or write one into a committed file.
+
+Browser login (\`runtype auth login\` with no flags) exists for humans running the CLI in their own interactive terminal. Do not use it from a coding harness.
+
+## After MCP is active
+
+- Call \`get_build_instructions\` before building.
+- Use \`get_platform_documentation\` instead of inventing payload shapes.
+- Let the installed Runtype skills route task-specific work: product builds, live account operations, Persona embeds, templates, and SDK/CLI workflows.
+- If the user gives you a \`use.runtype.com/now?...\`, example, or template/FPO link, use the Runtype template skill and MCP tools rather than opening the login-gated dashboard page.
+- Validate before creating/updating. Check product setup, then test with safe inputs and authorized side effects. Report what passed and what remains blocked or untested.
+
+Runtype MCP can create and operate agents, flows, products, records, secrets, evals, and surfaces; attach built-in, HTTP, MCP, flow, and subagent tools; and ship chat, API, webhook, messaging, schedule, MCP, and hosted-page experiences.
+
+Docs: [docs.runtype.com](https://docs.runtype.com)
+Dashboard: [use.runtype.com](https://use.runtype.com)
+API: [api.runtype.com](https://api.runtype.com)
+`;
+// src/commands/onboard.ts
+const AUTH_LOGIN_INSTRUCTION = "Sign in to Runtype first. New account: `runtype auth register --email <email>` then `runtype auth verify <code>`. Existing account: `runtype auth login --api-key <key>` (or set RUNTYPE_API_KEY). Then re-run `runtype onboard`.";
+const AFTER_RESTART_STEPS = [
+	"Use the Runtype MCP server first for all Runtype work.",
+	"Start with the get_build_instructions tool before creating or changing resources.",
+	"Do not fall back to the Runtype CLI once the MCP connection is active."
+];
+const EXISTING_PROJECT_ADVICE = "Building AI features into an existing codebase? After restart, decide with the user whether flow/agent config should be hosted (dashboard-editable, called via the dispatch API) or code-first in this repo via the TypeScript SDK. They run on the same platform and can be mixed.";
+/**
+* Trivial heuristic for "the user ran onboarding inside an existing project":
+* the cwd has a package.json or a .git directory and is not the CLI itself.
+*/
+function detectExistingProject(cwd = process.cwd()) {
+	const packageJsonPath = join(cwd, "package.json");
+	const hasPackageJson = existsSync(packageJsonPath);
+	if (!hasPackageJson && !existsSync(join(cwd, ".git"))) return false;
+	if (hasPackageJson) try {
+		if (JSON.parse(readFileSync(packageJsonPath, "utf8")).name === "@runtypelabs/cli") return false;
+	} catch {}
+	return true;
+}
+const defaultDependencies = {
+	getEnvApiKey: () => getRuntimeApiKey(),
+	getStoredCredentials: async () => {
+		const credentials = await new CredentialStore().getCredentials();
+		if (!credentials) return null;
+		return {
+			userId: credentials.userId,
+			orgId: credentials.orgId
+		};
+	},
+	ensureAuth,
+	selectAgent,
+	configureMcp: (agent, options) => configureMcpAgent(agent, options),
+	authenticateMcp: (agent, options) => authenticateMcpAgent(agent, options),
+	installSkills: installSkillsForAgent,
+	isExistingProject: detectExistingProject,
+	setExitCode: (code) => {
+		process.exitCode = code;
+	}
+};
+async function resolveAuth(dependencies, options) {
+	if (dependencies.getEnvApiKey()) return {
+		authenticated: true,
+		method: "env"
+	};
+	const stored = await dependencies.getStoredCredentials();
+	if (stored) return {
+		authenticated: true,
+		method: "stored",
+		userId: stored.userId,
+		orgId: stored.orgId
+	};
+	if (!options.interactiveLogin) return {
+		authenticated: false,
+		instruction: AUTH_LOGIN_INSTRUCTION
+	};
+	if (!await dependencies.ensureAuth({ exitOnFailure: false })) return {
+		authenticated: false,
+		instruction: AUTH_LOGIN_INSTRUCTION
+	};
+	const after = await dependencies.getStoredCredentials();
+	return {
+		authenticated: true,
+		method: "browser-login",
+		userId: after?.userId,
+		orgId: after?.orgId
+	};
+}
+function printAuthLine(auth) {
+	if (!auth.authenticated) {
+		console.log(chalk.yellow(`! Not signed in. ${auth.instruction}`));
+		return;
+	}
+	if (auth.method === "env") {
+		console.log(chalk.green("✓ Signed in with RUNTYPE_API_KEY from the environment."));
+		return;
+	}
+	const identity = auth.userId ? ` (user ${auth.userId}${auth.orgId ? `, org ${auth.orgId}` : ""})` : "";
+	if (auth.method === "stored") console.log(chalk.green(`✓ Already signed in${identity}.`));
+	else console.log(chalk.green(`✓ Signed in${identity}.`));
+}
+function createOnboardCommand(overrides = {}) {
+	const dependencies = {
+		...defaultDependencies,
+		...overrides
+	};
+	return new Command("onboard").description("Set up Runtype for this coding agent: sign in, install skills and OAuth MCP").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", "Skip browser sign-in and MCP OAuth").option("--no-skills", "Skip installing Runtype agent skills").option("--json", "Structured JSON output; implies --no-login").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").option("--print-instructions", "Print the canonical agent onboarding markdown and exit").action(async (options, cmd) => {
+		if (options.printInstructions) {
+			console.log(AGENT_ONBOARDING_MARKDOWN);
+			return;
+		}
+		const globals = cmd.optsWithGlobals();
+		const jsonMode = !!(options.json ?? globals.json);
+		const tty = isTTY(options);
+		const loginAllowed = !jsonMode && tty && options.login !== false;
+		if (!jsonMode) {
+			console.log(chalk.cyan("\nRuntype onboarding"));
+			console.log("Runtype is a platform for building AI products: agents, flows, evals, and surfaces your team ships to its own users.");
+			console.log(chalk.dim("This command signs you in, installs Runtype skills and the hosted OAuth MCP server, then prints next steps.\n"));
+		}
+		let auth;
+		try {
+			auth = await resolveAuth(dependencies, { interactiveLogin: loginAllowed && !options.dryRun });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (jsonMode) printJson({
+				status: "error",
+				code: "AUTH_RESOLUTION_FAILED",
+				error: message
+			});
+			else console.error(chalk.red(`Could not read Runtype credentials: ${message}`));
+			dependencies.setExitCode(1);
+			return;
+		}
+		if (!jsonMode) printAuthLine(auth);
+		let agent;
+		try {
+			agent = await dependencies.selectAgent({
+				agent: options.agent,
+				json: jsonMode
+			}, tty);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (jsonMode) printJson({
+				status: "error",
+				code: "AGENT_DETECTION_FAILED",
+				auth,
+				error: message
+			});
+			else console.error(chalk.red(message));
+			dependencies.setExitCode(1);
+			return;
+		}
+		const definition = MCP_AGENT_DEFINITIONS[agent];
+		if (!jsonMode) console.log(chalk.cyan(`\nSetting up Runtype for ${definition.displayName}…`));
+		const configuration = await dependencies.configureMcp(agent, {
+			force: options.force,
+			dryRun: options.dryRun
+		});
+		if (!configuration.configured) {
+			if (jsonMode) printJson({
+				status: "error",
+				code: "MCP_CONFIG_FAILED",
+				agent,
+				auth,
+				configuration
+			});
+			else console.error(chalk.red(configuration.error ?? "Could not configure Runtype MCP."));
+			dependencies.setExitCode(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 dependencies.authenticateMcp(agent, {
+			login: loginAllowed,
+			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 dependencies.installSkills(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 existingProject = dependencies.isExistingProject();
+		const nextSteps = [];
+		if (options.dryRun) nextSteps.push(`Re-run \`runtype onboard --agent ${agent}\` without --dry-run to sign in, install skills, and configure MCP.`);
+		else {
+			if (!auth.authenticated && auth.instruction) nextSteps.push(auth.instruction);
+			if (authentication.instruction) nextSteps.push(authentication.instruction);
+			if (authentication.error && !authentication.instruction) nextSteps.push("Resolve the OAuth blocker reported above, then re-run `runtype onboard`.");
+			if (skills.status === "error") nextSteps.push(`Retry skill installation with \`runtype skills install --agent ${getMcpSkillsAgentId(agent)}\`.`);
+			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 (auth.authenticated && authentication.authenticated && skills.status !== "error") nextSteps.push(`Tell the user that Runtype is set up, then ask them to restart or reload ${definition.displayName}.`);
+			else nextSteps.push("Tell the user that setup still has the action(s) above; do not call onboarding complete yet.");
+			nextSteps.push(`After completing any action above, ${restartInstruction}`);
+		}
+		const partial = !options.dryRun && (Boolean(authentication.error) || skills.status === "error");
+		const status = options.dryRun ? "planned" : partial ? "partial" : auth.authenticated && authentication.authenticated ? "ok" : "action-required";
+		if (jsonMode) printJson({
+			status,
+			agent,
+			auth,
+			configuration,
+			authentication,
+			skills,
+			activation: options.dryRun ? "not-configured" : "restart-required",
+			restartInstruction,
+			afterRestart: AFTER_RESTART_STEPS,
+			...existingProject ? { existingProjectAdvice: EXISTING_PROJECT_ADVICE } : {},
+			nextSteps
+		});
+		else {
+			console.log(chalk.bold(`\nOnboarding status: ${status}`));
+			console.log(chalk.bold("\nDo exactly this next:"));
+			nextSteps.forEach((step, index) => console.log(`  ${index + 1}. ${step}`));
+			console.log(chalk.bold(`\nAfter restarting ${definition.displayName}:`));
+			AFTER_RESTART_STEPS.forEach((step) => console.log(`  - ${step}`));
+			if (existingProject) console.log(`\n${EXISTING_PROJECT_ADVICE}`);
+			console.log("");
+		}
+		if (partial) dependencies.setExitCode(1);
+	});
+}
+const onboardCommand = createOnboardCommand();
+export { onboardCommand };
+