@runtypelabs/cli 2.59.1 → 2.59.4

package/dist/chunk-BmB6UVZ9.js

@@ -0,0 +1,1559 @@
+#!/usr/bin/env node
+import { F as getCliVersion } from "./index.js";
+import { a as getApiVersion, c as getDevPlanOverride, i as getApiUrl } from "./chunk-BW2fg46T.js";
+import { n as ensureAuth } from "./chunk-CJraEBVd.js";
+import { a as printJson, i as printDetail } from "./chunk-CcFCyqbB.js";
+import { Command, InvalidArgumentError } from "commander";
+import chalk from "chalk";
+import { readFile } from "node:fs/promises";
+import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+// src/lib/mcp-client.ts
+const CONNECT_TIMEOUT_MS = 1e4;
+function parseHttpUrl(raw, label) {
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		throw new Error(`${label} must be a valid URL`);
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error(`${label} must use http or https`);
+	return url;
+}
+function appendPath(baseUrl, ...segments) {
+	const url = parseHttpUrl(baseUrl, "RUNTYPE_API_URL");
+	url.pathname = `${url.pathname.replace(/\/+$/, "")}/${segments.map((segment) => segment.replace(/^\/+|\/+$/g, "")).join("/")}`;
+	url.search = "";
+	url.hash = "";
+	return url;
+}
+/** Resolve the selected first-party MCP endpoint without accepting arbitrary CLI URLs. */
+function resolveMcpEndpoint(target, config) {
+	if (target === "standard") {
+		if (config.standardUrl) return parseHttpUrl(config.standardUrl, "RUNTYPE_MCP_URL");
+		return appendPath(config.apiUrl, config.apiVersion, "mcp", "protocol");
+	}
+	if (config.codeUrl) return parseHttpUrl(config.codeUrl, "RUNTYPE_CODE_MCP_URL");
+	const apiUrl = parseHttpUrl(config.apiUrl, "RUNTYPE_API_URL");
+	if (apiUrl.hostname === "api.runtype.com") return new URL("https://code.runtype.com/mcp");
+	if (apiUrl.hostname === "api.runtype-staging.com") return new URL("https://code.runtype-staging.com/mcp");
+	if (apiUrl.hostname === "localhost" || apiUrl.hostname === "127.0.0.1" || apiUrl.hostname === "[::1]") {
+		apiUrl.port = "2529";
+		apiUrl.pathname = "/mcp";
+		apiUrl.search = "";
+		apiUrl.hash = "";
+		return apiUrl;
+	}
+	throw new Error(`Cannot infer the Code Mode MCP endpoint from ${config.apiUrl}; set RUNTYPE_CODE_MCP_URL explicitly`);
+}
+function currentEndpointConfig() {
+	return {
+		apiUrl: getApiUrl(),
+		apiVersion: getApiVersion(),
+		standardUrl: process.env.RUNTYPE_MCP_URL,
+		codeUrl: process.env.RUNTYPE_CODE_MCP_URL
+	};
+}
+/** Connect an authenticated, one-shot MCP client for a CLI operation. */
+async function connectMcpClient(apiKey, target, options = {}) {
+	const endpoint = resolveMcpEndpoint(target, currentEndpointConfig());
+	const version = getCliVersion();
+	const devOverride = getDevPlanOverride();
+	const headers = {
+		Authorization: `Bearer ${apiKey}`,
+		"X-Runtype-Client": "cli",
+		"X-Runtype-CLI-Version": version,
+		"User-Agent": `runtype-cli/${version}`,
+		...devOverride ? { "X-Dev-Plan-Override": devOverride } : {}
+	};
+	const transport = new StreamableHTTPClientTransport(endpoint, {
+		requestInit: { headers },
+		...options.fetch ? { fetch: options.fetch } : {}
+	});
+	const client = new Client({
+		name: "runtype-cli",
+		version
+	}, {});
+	const connectPromise = client.connect(transport);
+	connectPromise.catch(() => void 0);
+	let timer;
+	const timeout = new Promise((_resolve, reject) => {
+		timer = setTimeout(() => {
+			reject(/* @__PURE__ */ new Error(`MCP connection timed out after ${CONNECT_TIMEOUT_MS}ms`));
+		}, CONNECT_TIMEOUT_MS);
+	});
+	try {
+		await Promise.race([connectPromise, timeout]);
+	} catch (error) {
+		await client.close().catch(() => void 0);
+		throw error;
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+	return {
+		client,
+		endpoint
+	};
+}
+/** Collect every tools/list page while treating cursors as opaque values. */
+async function listAllMcpTools(client, options) {
+	const tools = [];
+	const seenCursors = /* @__PURE__ */ new Set();
+	let cursor;
+	do {
+		const page = await client.listTools(cursor === void 0 ? void 0 : { cursor }, options);
+		tools.push(...page.tools);
+		const nextCursor = page.nextCursor;
+		if (nextCursor !== void 0) {
+			if (seenCursors.has(nextCursor)) throw new Error("MCP server returned a repeated tools/list cursor");
+			seenCursors.add(nextCursor);
+		}
+		cursor = nextCursor;
+	} while (cursor !== void 0);
+	return tools;
+}
+// ../mcp-cli/dist/chunk-Cx5MQp1B.mjs
+const e$2 = {
+	Success: 0,
+	ToolError: 1,
+	Usage: 2,
+	Auth: 3,
+	Transport: 4,
+	InputRequired: 5,
+	WaitTimeout: 6,
+	Interrupted: 130
+};
+const t$2 = {
+	usage: e$2.Usage,
+	unknown_command: e$2.Usage,
+	unknown_flag: e$2.Usage,
+	invalid_value: e$2.Usage,
+	missing_argument: e$2.Usage,
+	confirmation_required: e$2.Usage,
+	config: e$2.Usage,
+	credential_conflict: e$2.Usage,
+	tool_error: e$2.ToolError,
+	auth_required: e$2.Auth,
+	auth_failed: e$2.Auth,
+	transport: e$2.Transport,
+	timeout: e$2.Transport,
+	protocol: e$2.Transport,
+	input_required: e$2.InputRequired,
+	input_rejected: e$2.Usage,
+	wait_timeout: e$2.WaitTimeout,
+	tasks_unsupported: e$2.Usage,
+	task_cancelled: e$2.ToolError,
+	interrupted: e$2.Interrupted,
+	plugin_error: e$2.ToolError,
+	internal: e$2.ToolError
+};
+var n$2 = class extends Error {
+	code;
+	hint;
+	details;
+	exitCode;
+	constructor(e, n, r, i) {
+		super(n), this.code = e, this.hint = r, this.details = i, this.name = `CliError`, this.exitCode = t$2[e];
+	}
+	toEnvelope() {
+		return { error: {
+			...this.details,
+			code: this.code,
+			message: this.message,
+			...this.hint ? { hint: this.hint } : {},
+			exitCode: this.exitCode
+		} };
+	}
+};
+// ../mcp-cli/dist/chunk-CQq_8FZL.mjs
+function e$1(e) {
+	return e.replace(/([a-z0-9])([A-Z])/g, `$1-$2`).replace(/([A-Z]+)([A-Z][a-z])/g, `$1-$2`).replace(/[^A-Za-z0-9]+/g, `-`).replace(/^-+|-+$/g, ``).toLowerCase();
+}
+function t$1(e, t) {
+	if (e === t) return 0;
+	let n = Array.from({ length: t.length + 1 }, (e, t) => t);
+	for (let r = 1; r <= e.length; r += 1) {
+		let i = n[0];
+		n[0] = r;
+		for (let a = 1; a <= t.length; a += 1) {
+			let o = n[a];
+			n[a] = Math.min(n[a] + 1, n[a - 1] + 1, i + (e[r - 1] === t[a - 1] ? 0 : 1)), i = o;
+		}
+	}
+	return n[t.length];
+}
+function n$1(e, n, r = 3) {
+	let i = e.toLowerCase(), a = Math.max(2, Math.floor(i.length / 3)), o = [];
+	for (let e of new Set(n)) {
+		let n = e.toLowerCase(), r = n.startsWith(i) || i.startsWith(n) ? 1 : t$1(i, n);
+		r <= a && o.push([e, r]);
+	}
+	return o.sort((e, t) => e[1] - t[1] || e[0].localeCompare(t[0])).slice(0, r).map(([e]) => e);
+}
+// ../mcp-cli/dist/chunk-B4F-cgd0.mjs
+function e(e, t) {
+	switch (e) {
+		case void 0:
+		case `auto`: return t.stdoutIsTTY ? `pretty` : `compact`;
+		default: return e;
+	}
+}
+const t = /\u001b\[[0-9;?]*[ -/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)|\u001b[@-Z\\-_]/g;
+const n = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g;
+function r(e) {
+	return e.replace(t, ``).replace(/\r\n/g, `
+`).replace(n, ``);
+}
+function o(e) {
+	let t = e.endsWith(`==`) ? 2 : +!!e.endsWith(`=`);
+	return Math.max(0, Math.floor(e.length * 3 / 4) - t);
+}
+function s$1(e) {
+	return e < 1024 ? `${e} B` : e < 1048576 ? `${(e / 1024).toFixed(1)} KB` : `${(e / 1048576).toFixed(1)} MB`;
+}
+function c$1(e, t, n) {
+	let i = t.get(e);
+	switch (e.type) {
+		case `text`: return n ? String(e.text) : r(String(e.text));
+		case `image`:
+		case `audio`: {
+			let t = String(e.mimeType ?? `application/octet-stream`);
+			return i ? `[${e.type} ${t} saved to ${i.path}]` : `[${e.type} ${t}, ${s$1(o(String(e.data ?? ``)))}; use --save <dir> to write it]`;
+		}
+		case `resource_link`: return `${e.name ? `${r(String(e.name))}: ` : ``}${r(String(e.uri))}`;
+		case `resource`: {
+			let t = e.resource ?? {};
+			return typeof t.text == `string` ? n ? t.text : r(t.text) : i ? `[resource ${t.uri ?? ``} saved to ${i.path}]` : `[resource ${r(String(t.uri ?? ``))}${t.blob ? `, ${s$1(o(t.blob))}` : ``}]`;
+		}
+		default: return `[${r(String(e.type))} content]`;
+	}
+}
+function l$1(e, t) {
+	return JSON.stringify(e) === JSON.stringify(t);
+}
+function u$1(e) {
+	let t = Array.isArray(e.content) ? e.content : [];
+	return e.structuredContent === void 0 ? t : t.filter((t) => {
+		if (t.type !== `text`) return !0;
+		try {
+			return !l$1(JSON.parse(String(t.text)), e.structuredContent);
+		} catch {
+			return !0;
+		}
+	});
+}
+function f$1(e) {
+	return typeof e == `object` && !!e && !Array.isArray(e) && Object.values(e).every((e) => typeof e != `object` || !e);
+}
+function p$2(e) {
+	let t = e.structuredContent, n = [];
+	t !== void 0 && (n.push(t), typeof t == `object` && t && n.push(...Object.values(t)));
+	for (let e of n) if (Array.isArray(e) && e.length > 0 && e.every(f$1)) return e;
+	return null;
+}
+function m$2(e) {
+	let t = [...new Set(e.flatMap((e) => Object.keys(e)))], n = (e) => e == null ? `` : r(String(e)).replace(/\n/g, ` `), i = t.map((t) => Math.max(t.length, ...e.map((e) => n(e[t]).length))), a = (e) => e.map((e, t) => e.padEnd(i[t])).join(`  `).trimEnd();
+	return [a(t.map((e) => e.toUpperCase())), ...e.map((e) => a(t.map((t) => n(e[t]))))].join(`
+`);
+}
+function h$2(e, t) {
+	let n = t.saved ?? /* @__PURE__ */ new Map();
+	switch (t.mode) {
+		case `json`: return JSON.stringify(e);
+		case `ndjson`: return JSON.stringify({
+			type: `result`,
+			result: e
+		});
+		case `table`: {
+			let n = p$2(e);
+			return n ? m$2(n) : h$2(e, {
+				...t,
+				mode: `pretty`
+			});
+		}
+		case `pretty`:
+		case `compact`:
+			if (e.structuredContent !== void 0) {
+				let r = t.mode === `pretty` ? JSON.stringify(e.structuredContent, null, 2) : JSON.stringify(e.structuredContent), i = u$1(e).map((e) => c$1(e, n, !1));
+				return t.mode === `pretty` && i.length > 0 ? [r, ...i].join(`
+`) : r;
+			}
+			return u$1(e).map((e) => c$1(e, n, t.mode === `compact`)).join(`
+`);
+		case `text`:
+		case `raw`: {
+			let r = u$1(e).map((e) => c$1(e, n, t.mode === `raw`));
+			return r.length === 0 && e.structuredContent !== void 0 ? JSON.stringify(e.structuredContent, null, t.mode === `text` ? 2 : void 0) : r.join(`
+`);
+		}
+	}
+}
+// ../mcp-cli/dist/chunk-CMnHEuio.mjs
+const i = /* @__PURE__ */ new Set([
+	`approvals`,
+	`auth`,
+	`call`,
+	`completion`,
+	`doctor`,
+	`help`,
+	`login`,
+	`logout`,
+	`resources`,
+	`resume`,
+	`schema`,
+	`skill`,
+	`tasks`,
+	`tools`,
+	`version`,
+	`whoami`,
+	`__complete`
+]);
+[...i];
+function s(e) {
+	return e.split(/\s+/).filter(Boolean);
+}
+function c(e, t) {
+	if (t?.group || t?.name) {
+		let n = t.group ? s(t.group) : [], r = t.name ?? (e.name.includes(`.`) ? e.name.split(`.`).filter(Boolean).at(-1) ?? e.name : e.name);
+		return [...n, r];
+	}
+	if (e.name.includes(`.`)) {
+		let t = e.name.split(`.`).filter(Boolean);
+		if (t.length > 0) return t;
+	}
+	return [e.name];
+}
+const l = (e) => e.join(`\0`);
+function u(e, t = {}, r = i) {
+	let a = [], o = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), d = (e, t, n) => {
+		if (t.length === 0 || t.some((e) => e === ``)) return;
+		let r = u.get(l(t)) ?? [];
+		r.push({
+			entry: e,
+			priority: n
+		}), u.set(l(t), r);
+	}, f = /* @__PURE__ */ new Map();
+	for (let r of e) {
+		if (o.has(r.name)) continue;
+		let e = Object.prototype.hasOwnProperty.call(t, r.name) ? t[r.name] : void 0, i = c(r, e), l = {
+			tool: e?.description ? {
+				...r,
+				description: e.description
+			} : r,
+			path: i,
+			aliases: [],
+			hidden: e?.hidden === !0,
+			callOnly: !1,
+			override: e
+		};
+		a.push(l), o.set(r.name, l);
+		let u = [
+			{
+				path: [r.name],
+				priority: 0
+			},
+			{
+				path: i,
+				priority: 1
+			},
+			...(e?.aliases ?? []).map((e) => ({
+				path: s(e),
+				priority: 2
+			})),
+			{
+				path: i.map(e$1),
+				priority: 3
+			},
+			{
+				path: [e$1(r.name)],
+				priority: 3
+			}
+		];
+		f.set(l, u);
+		for (let e of u) d(l, e.path, e.priority);
+	}
+	let p = { children: /* @__PURE__ */ new Map() }, m = /* @__PURE__ */ new Map();
+	for (let [e, t] of f) {
+		let n = /* @__PURE__ */ new Set();
+		for (let { path: i } of t) {
+			let t = l(i);
+			if (n.has(t) || i.length === 0 || (n.add(t), r.has(i[0]))) continue;
+			let a = u.get(t) ?? [], o = Math.min(...a.map((e) => e.priority)), s = a.filter((e) => e.priority === o), c = new Set(s.map((e) => e.entry));
+			if (c.size !== 1 || !c.has(e)) continue;
+			let d = p;
+			for (let e of i) {
+				let t = d.children.get(e);
+				t || (t = { children: /* @__PURE__ */ new Map() }, d.children.set(e, t)), d = t;
+			}
+			d.entry = e;
+			let f = m.get(e) ?? [];
+			f.push(i), m.set(e, f);
+		}
+	}
+	for (let e of a) {
+		let t = m.get(e) ?? [], n = l(e.path), r = t.find((e) => l(e) === n) ?? t[0];
+		r ? (e.path = r, e.aliases = t.filter((e) => l(e) !== l(r))) : e.callOnly = !0;
+	}
+	let h = (e) => {
+		let t = p;
+		for (let n of e) if (t = t?.children.get(n), !t) return;
+		return t;
+	};
+	return {
+		entries: a,
+		byToolName: o,
+		resolve(e) {
+			let t = p, n = { kind: `none` }, r = [];
+			for (let [i, a] of e.entries()) {
+				let e = t.children.get(a);
+				if (!e) break;
+				t = e, r.push(a), t.entry && (n = {
+					kind: `tool`,
+					entry: t.entry,
+					consumed: i + 1
+				});
+			}
+			return n.kind === `tool` ? n : r.length > 0 ? {
+				kind: `group`,
+				path: r,
+				children: [...t.children.keys()].sort()
+			} : n;
+		},
+		topLevelWords() {
+			return [...p.children.keys()].sort();
+		},
+		childrenOf(e) {
+			return [...h(e)?.children.keys() ?? []].sort();
+		}
+	};
+}
+function d(e) {
+	return typeof e == `object` && !!e && !Array.isArray(e);
+}
+function f(e) {
+	return decodeURIComponent(e).replace(/~1/g, `/`).replace(/~0/g, `~`);
+}
+function p$1(e, t) {
+	if (t === `#`) return e;
+	if (!t.startsWith(`#/`)) return;
+	let n = e;
+	for (let e of t.slice(2).split(`/`)) {
+		if (!d(n)) return;
+		n = n[f(e)];
+	}
+	return d(n) ? n : void 0;
+}
+var m$1 = class extends Error {};
+function h$1(e, t, n, r) {
+	if (n.length > 32) throw new m$1();
+	let i = t;
+	if (typeof i.$ref == `string`) {
+		let t = i.$ref;
+		if (n.includes(t)) throw new m$1();
+		let a = p$1(e, t);
+		if (!a) return {
+			...i,
+			$ref: void 0
+		};
+		r.add(t);
+		let { $ref: o, ...s } = i;
+		i = {
+			...h$1(e, a, [...n, t], r),
+			...s
+		};
+	}
+	if (Array.isArray(i.allOf)) {
+		let { allOf: t, ...a } = i, o = {};
+		for (let i of t) d(i) && (o = g$1(o, h$1(e, i, n, r)));
+		i = g$1(o, a);
+	}
+	return i;
+}
+function g$1(e, t) {
+	let n = {
+		...e,
+		...t
+	};
+	(d(e.properties) || d(t.properties)) && (n.properties = {
+		...d(e.properties) ? e.properties : {},
+		...d(t.properties) ? t.properties : {}
+	});
+	let r = [...Array.isArray(e.required) ? e.required : [], ...Array.isArray(t.required) ? t.required : []];
+	return r.length > 0 && (n.required = [...new Set(r)]), n;
+}
+function _$1(e, t, n = []) {
+	let r = /* @__PURE__ */ new Set();
+	try {
+		return {
+			schema: h$1(e, t, n, r),
+			recursive: !1,
+			ancestors: [...n, ...r]
+		};
+	} catch (e) {
+		if (e instanceof m$1) return {
+			schema: t,
+			recursive: !0,
+			ancestors: n
+		};
+		throw e;
+	}
+}
+function v$1(e) {
+	return typeof e.type == `string` ? [e.type] : Array.isArray(e.type) ? e.type.filter((e) => typeof e == `string`) : [];
+}
+function ee(e) {
+	return e.contentEncoding === `base64` || e.format === `binary` || e.format === `byte` || typeof e.contentMediaType == `string`;
+}
+function y$1(e) {
+	return d(e) && (e.type === `null` || Array.isArray(e.type) && e.type.length === 1 && e.type[0] === `null`);
+}
+function b$1(e, t, n) {
+	return {
+		kind: t,
+		schema: e,
+		nullable: n,
+		description: typeof e.description == `string` ? e.description : void 0,
+		defaultValue: e.default,
+		hasDefault: Object.prototype.hasOwnProperty.call(e, `default`),
+		deprecated: e.deprecated === !0,
+		readOnly: e.readOnly === !0,
+		format: typeof e.format == `string` ? e.format : void 0
+	};
+}
+const x$1 = [
+	`integer`,
+	`number`,
+	`boolean`,
+	`string`
+];
+function S$1(e) {
+	if (e.kind === `integer` || e.kind === `number` || e.kind === `boolean` || e.kind === `string`) return e.kind;
+	if (e.kind === `binary`) return `string`;
+	if (e.kind === `enum` || e.kind === `const`) {
+		let t = e.kind === `enum` ? e.enumValues ?? [] : [e.constValue];
+		if (t.every((e) => typeof e == `string`)) return `string`;
+		if (t.every((e) => Number.isInteger(e))) return `integer`;
+		if (t.every((e) => typeof e == `number`)) return `number`;
+		if (t.every((e) => typeof e == `boolean`)) return `boolean`;
+	}
+}
+function C$1(e, t, n = []) {
+	let { schema: r, recursive: i, ancestors: a } = _$1(e, t, n);
+	if (i) return b$1(r, `json`, !1);
+	let o = r.nullable === !0, s = v$1(r);
+	s.includes(`null`) && (o = !0);
+	let c = s.filter((e) => e !== `null`);
+	if (Object.prototype.hasOwnProperty.call(r, `const`)) return {
+		...b$1(r, `const`, o),
+		constValue: r.const
+	};
+	if (Array.isArray(r.enum)) {
+		let e = r.enum.filter((e) => e !== null);
+		return e.length !== r.enum.length && (o = !0), {
+			...b$1(r, `enum`, o),
+			enumValues: e
+		};
+	}
+	let l = Array.isArray(r.anyOf) ? r.anyOf : Array.isArray(r.oneOf) ? r.oneOf : void 0;
+	if (l) {
+		let t = l.filter((e) => !y$1(e));
+		t.length !== l.length && (o = !0);
+		let n = t.filter(d).map((t) => C$1(e, t, a)), i = {
+			...r,
+			anyOf: void 0,
+			oneOf: void 0
+		};
+		if (n.length === 1) {
+			let e = n[0];
+			return {
+				...e,
+				nullable: o || e.nullable,
+				description: typeof r.description == `string` ? r.description : e.description,
+				hasDefault: e.hasDefault || Object.prototype.hasOwnProperty.call(r, `default`),
+				defaultValue: r.default ?? e.defaultValue,
+				deprecated: r.deprecated === !0 || e.deprecated
+			};
+		}
+		let s = n.map(S$1);
+		if (n.length > 0 && s.every((e) => e !== void 0)) {
+			let e = x$1.filter((e) => s.includes(e));
+			return {
+				...b$1(i, `scalar-union`, o),
+				unionKinds: e
+			};
+		}
+		return b$1(i, `json`, o);
+	}
+	if (c.length > 1) {
+		let e = x$1.filter((e) => c.includes(e));
+		return e.length === c.length ? {
+			...b$1(r, `scalar-union`, o),
+			unionKinds: e
+		} : b$1(r, `json`, o);
+	}
+	switch (c[0] ?? (d(r.properties) || d(r.additionalProperties) ? `object` : void 0)) {
+		case `string`: return b$1(r, ee(r) ? `binary` : `string`, o);
+		case `integer`: return b$1(r, `integer`, o);
+		case `number`: return b$1(r, `number`, o);
+		case `boolean`: return b$1(r, `boolean`, o);
+		case `array`: {
+			let t = C$1(e, d(r.items) ? r.items : {}, a);
+			return S$1(t) !== void 0 || t.kind === `scalar-union` ? {
+				...b$1(r, `scalar-array`, o),
+				item: t
+			} : {
+				...b$1(r, `object-array`, o),
+				item: t
+			};
+		}
+		case `object`:
+			if (!(d(r.properties) && Object.keys(r.properties).length > 0) && d(r.additionalProperties)) {
+				let t = C$1(e, r.additionalProperties, a);
+				if (S$1(t) !== void 0 || t.kind === `scalar-union`) return {
+					...b$1(r, `map`, o),
+					item: t
+				};
+			}
+			return b$1(r, `object`, o);
+		default: return b$1(r, `any`, o);
+	}
+}
+function te(e) {
+	let { schema: t, recursive: n } = _$1(e, e);
+	if (n) return null;
+	let r = v$1(t);
+	if (!(r.includes(`object`) || r.length === 0 && (d(t.properties) || Object.keys(t).length === 0))) return null;
+	let i = Object.create(null);
+	if (d(t.properties)) for (let [e, n] of Object.entries(t.properties)) d(n) && (i[e] = n);
+	return {
+		properties: i,
+		required: Array.isArray(t.required) ? t.required.filter((e) => typeof e == `string` && Object.hasOwn(i, e)) : []
+	};
+}
+function ne(e, t) {
+	let n = (Array.isArray(t.anyOf) ? t.anyOf : Array.isArray(t.oneOf) ? t.oneOf : []).filter((e) => d(e) && !y$1(e));
+	return n.length === 1 ? _$1(e, n[0]).schema : t;
+}
+function re(e, t) {
+	let n = e;
+	for (let r of t) {
+		let { schema: t, recursive: i } = _$1(e, n);
+		if (i) return;
+		let a = ne(e, t);
+		if (r === `[]`) {
+			if (!d(a.items)) return;
+			n = a.items;
+		} else if (d(a.properties) && d(a.properties[r])) n = a.properties[r];
+		else if (d(a.additionalProperties)) n = a.additionalProperties;
+		else return;
+	}
+	return C$1(e, n);
+}
+const w$1 = /* @__PURE__ */ new Set(/* @__PURE__ */ `answers.approvals.approve.approve-all.color.deny.detach.dry-run.example.field.help.help-all.input.json.json-body.jsonl.max-output.no-color.no-input.output.profile.raw-field.raw-strings.save.stream.timeout.token.verbose.wait.yes`.split(`.`));
+function ie(e) {
+	return e.kind === `string` || e.kind === `enum` || e.kind === `binary`;
+}
+function T$1(e, t) {
+	let r = e.inputSchema ?? {}, i = te(r);
+	if (!i) return {
+		tool: e,
+		bodyOnly: !0,
+		flags: [],
+		byFlag: /* @__PURE__ */ new Map(),
+		byWire: /* @__PURE__ */ new Map(),
+		positionals: [],
+		constFields: {},
+		defaults: {},
+		required: []
+	};
+	let a = {}, o = { ...t?.defaults }, s = [], c = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Map();
+	for (let e of Object.keys(i.properties)) l.set(e$1(e), (l.get(e$1(e)) ?? 0) + 1);
+	for (let [e, t] of Object.entries(i.properties)) {
+		let u = C$1(r, t);
+		if (u.readOnly) continue;
+		if (u.kind === `const`) {
+			E$1(a, e, u.constValue);
+			continue;
+		}
+		let d = e$1(e) || e, f = d;
+		if (w$1.has(f) || (l.get(d) ?? 0) > 1 || c.has(f)) for (f = `arg-${d}`, (c.has(f) || (l.get(d) ?? 0) > 1) && (f = `arg-${e}`); c.has(f);) f = `arg-${f}`;
+		c.add(f);
+		let p = i.required.includes(e);
+		p && u.hasDefault && !Object.hasOwn(o, e) && E$1(o, e, u.defaultValue), s.push({
+			wire: e,
+			flag: f,
+			field: u,
+			required: p && !Object.hasOwn(o, e),
+			hidden: u.deprecated
+		});
+	}
+	let u = new Map(s.map((e) => [e.wire, e])), d = [];
+	if (t?.positional && t.positional.length > 0) d = t.positional.map((e) => u.get(e)).filter((e) => e !== void 0 && ie(e.field));
+	else {
+		let e = s.filter((e) => e.required);
+		e.length === 1 && e[0].field.kind === `string` && (d = e);
+	}
+	return d.forEach((e, t) => {
+		e.position = t;
+	}), {
+		tool: e,
+		bodyOnly: !1,
+		flags: s,
+		byFlag: new Map(s.map((e) => [e.flag, e])),
+		byWire: u,
+		positionals: d,
+		constFields: a,
+		defaults: o,
+		required: s.filter((e) => e.required).map((e) => e.wire)
+	};
+}
+function E$1(e, t, n) {
+	Object.defineProperty(e, t, {
+		value: n,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	});
+}
+function D$1(e) {
+	return e?.startsWith(`\0`) === !0;
+}
+function O$1(t, n) {
+	let r = n.slice(1), i = t.startsWith(`--`) ? `${t}=${r}` : `${t}${r}`;
+	return new n$2(`usage`, `${t} needs a value, but the word after it, ${r}, is a global flag`, `Write ${i} to pass it as the value, or put ${r} after the value`);
+}
+const k$1 = /* @__PURE__ */ new Set([
+	`auto`,
+	`json`,
+	`text`,
+	`raw`,
+	`ndjson`,
+	`table`
+]);
+const A$1 = /* @__PURE__ */ new Set([
+	`output`,
+	`timeout`,
+	`save`,
+	`input`,
+	`json-body`,
+	`field`,
+	`raw-field`,
+	`max-output`,
+	`approve`,
+	`deny`,
+	`approvals`,
+	`answers`,
+	`wait`,
+	`stream`
+]);
+const j$1 = /* @__PURE__ */ new Set([
+	`auto`,
+	`raw`,
+	`off`
+]);
+const M$1 = /* @__PURE__ */ new Set([
+	`prompt`,
+	`fail`,
+	`deny`
+]);
+const oe = {
+	h: `help`,
+	o: `output`,
+	y: `yes`,
+	f: `raw-field`,
+	F: `field`
+};
+function N$1(e) {
+	return e.field.kind === `scalar-array` || e.field.kind === `object-array` || e.field.kind === `map`;
+}
+function P$1(t, n) {
+	let r = /^(\d+(?:\.\d+)?)(ms|s|m|h)?$/.exec(t.trim());
+	if (!r) throw new n$2(`invalid_value`, `${n} expects a duration such as 30000, 30s or 5m`);
+	let i = Number(r[1]), a = r[2] ?? `ms`, o = Math.round(i * (a === `h` ? 36e5 : a === `m` ? 6e4 : a === `s` ? 1e3 : 1));
+	if (o <= 0) throw new n$2(`invalid_value`, `${n} must be greater than zero`);
+	return o;
+}
+function se(t) {
+	if (t === `0` || t === `none` || t === `unlimited`) return null;
+	if (!/^\d+$/.test(t)) throw new n$2(`invalid_value`, `--max-output expects a character count, or 0 for unlimited`);
+	return Number(t);
+}
+function ce(t, n) {
+	let r = {
+		help: !1,
+		helpAll: !1,
+		dryRun: !1,
+		example: !1,
+		detach: !1,
+		yes: !1,
+		fields: [],
+		rawFields: [],
+		rawStrings: !1,
+		approve: [],
+		deny: [],
+		approveAll: !1
+	}, i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), o = [], s = /* @__PURE__ */ new Set(), c = (t, n) => {
+		if (t === `field`) return void r.fields.push(n);
+		if (t === `raw-field`) return void r.rawFields.push(n);
+		if (t === `approve` || t === `deny`) {
+			if (n.trim() === ``) throw new n$2(`invalid_value`, `--${t} needs a tool name`);
+			r[t].push(n);
+		} else {
+			if (s.has(t)) throw new n$2(`usage`, `--${t} was given more than once`);
+			switch (s.add(t), t) {
+				case `output`:
+					if (!k$1.has(n)) throw new n$2(`invalid_value`, `--output must be one of ${[...k$1].join(`, `)}`);
+					r.output = F(r.output, n);
+					return;
+				case `timeout`:
+					r.timeoutMs = P$1(n, `--timeout`);
+					return;
+				case `save`:
+					r.save = n;
+					return;
+				case `input`:
+					r.input = n;
+					return;
+				case `json-body`:
+					r.jsonBody = n;
+					return;
+				case `max-output`:
+					r.maxOutput = se(n);
+					return;
+				case `approvals`:
+					if (!M$1.has(n)) throw new n$2(`invalid_value`, `--approvals must be prompt, fail or deny`);
+					r.approvals = n;
+					return;
+				case `answers`:
+					r.answers = n;
+					return;
+				case `wait`:
+					r.wait = n;
+					return;
+				case `stream`:
+					if (!j$1.has(n)) throw new n$2(`invalid_value`, `--stream must be auto, raw or off`);
+					r.stream = n;
+					return;
+			}
+		}
+	}, l = (e) => {
+		switch (e) {
+			case `help`: return r.help = !0, !0;
+			case `help-all`: return r.helpAll = !0, !0;
+			case `json`: return r.output = F(r.output, `json`), !0;
+			case `jsonl`: return r.output = F(r.output, `ndjson`), !0;
+			case `dry-run`: return r.dryRun = !0, !0;
+			case `example`: return r.example = !0, !0;
+			case `detach`: return r.detach = !0, !0;
+			case `yes`: return r.yes = !0, !0;
+			case `raw-strings`: return r.rawStrings = !0, !0;
+			case `approve-all`: return r.approveAll = !0, !0;
+			default: return !1;
+		}
+	}, u = (t, n) => {
+		let r = i.get(t) ?? [];
+		if (r.length > 0 && !N$1(t)) throw new n$2(`usage`, `--${t.flag} was given more than once`, le(t));
+		r.push(n), i.set(t, r);
+	}, d = (t, n) => {
+		if (a.has(t)) throw new n$2(`usage`, `--${t.flag} was given more than once`);
+		a.set(t, n);
+	};
+	for (let r = 0; r < t.length; r += 1) {
+		let i = t[r];
+		if (!D$1(i)) {
+			if (i === `--`) {
+				o.push(...t.slice(r + 1));
+				break;
+			}
+			if (i.startsWith(`--`) && i.length > 2) {
+				let a = i.indexOf(`=`), o = a === -1 ? i.slice(2) : i.slice(2, a), s = a === -1 ? void 0 : i.slice(a + 1), f = () => {
+					if (s !== void 0) return s;
+					if (D$1(t[r + 1])) throw O$1(i, t[r + 1]);
+					if (r + 1 >= t.length) throw new n$2(`missing_argument`, `--${o} needs a value`);
+					return r += 1, t[r];
+				}, p = n.byFlag.get(o);
+				if (p) {
+					p.field.kind === `boolean` ? d(p, s === void 0 || I(s, `--${o}`)) : u(p, f());
+					continue;
+				}
+				if (o.startsWith(`no-`)) {
+					let t = n.byFlag.get(o.slice(3));
+					if (t && t.field.kind === `boolean`) {
+						if (s !== void 0) throw new n$2(`usage`, `--${o} takes no value; use --${t.flag}=${s}`);
+						d(t, !1);
+						continue;
+					}
+				}
+				if (A$1.has(o)) {
+					c(o, f());
+					continue;
+				}
+				if (s === void 0 && l(o)) continue;
+				throw L(o, n);
+			}
+			if (i.startsWith(`-`) && i.length > 1 && !/^-\d/.test(i)) {
+				let a = i.slice(1, 2), o = oe[a];
+				if (!o) throw L(i.slice(1), n);
+				let s = i.slice(2);
+				if (A$1.has(o)) {
+					let n = s;
+					if (n === ``) {
+						if (D$1(t[r + 1])) throw O$1(i, t[r + 1]);
+						if (r + 1 >= t.length) throw new n$2(`missing_argument`, `-${a} needs a value`);
+						r += 1, n = t[r];
+					}
+					c(o, n);
+				} else {
+					if (s !== ``) throw L(i.slice(1), n);
+					l(o);
+				}
+			} else o.push(i);
+		}
+	}
+	return {
+		reserved: r,
+		values: i,
+		booleans: a,
+		positionals: o
+	};
+}
+function F(t, n) {
+	if (t && t !== n) throw new n$2(`usage`, `Choose one output format: --json, --jsonl or --output`);
+	return n;
+}
+function le(e) {
+	return e.field.kind === `object` || e.field.kind === `json` ? `Pass one JSON value to --${e.flag}, or use -F ${e.wire}[key]=value` : void 0;
+}
+function I(t, n) {
+	let r = t.trim().toLowerCase();
+	if (r === `true`) return !0;
+	if (r === `false`) return !1;
+	throw new n$2(`invalid_value`, `${n} expects true or false, got ${JSON.stringify(t)}`);
+}
+function L(n, r) {
+	let a = n$1(n, [...r.flags.filter((e) => !e.hidden).map((e) => e.flag), ...w$1]);
+	return new n$2(`unknown_flag`, `Unknown flag --${n} for ${r.tool.name}`, a.length > 0 ? `Did you mean ${a.map((e) => `--${e}`).join(`, `)}?` : `Run with --help to list flags`);
+}
+function R(e) {
+	if (!e) return ``;
+	let t = r(e).trim().split(`
+`, 1)[0], n = /^(.+?[.!?])(\s|$)/.exec(t);
+	return (n ? n[1] : t).trim();
+}
+function z(e) {
+	let t = e.annotations ?? {}, n = [];
+	return t.readOnlyHint && n.push(`read-only`), t.destructiveHint && n.push(`destructive`), t.idempotentHint && n.push(`idempotent`), t.openWorldHint && n.push(`open-world`), n;
+}
+function B(e, t, n = 0) {
+	switch (e.kind) {
+		case `string`: return `string`;
+		case `binary`: return `base64`;
+		case `enum`: return (e.enumValues ?? []).map((e) => JSON.stringify(e)).join(` | `);
+		case `const`: return JSON.stringify(e.constValue);
+		case `integer`:
+		case `number`: return `number`;
+		case `boolean`: return `boolean`;
+		case `scalar-union`: return (e.unionKinds ?? []).map((e) => e === `integer` ? `number` : e).filter((e, t, n) => n.indexOf(e) === t).join(` | `);
+		case `scalar-array`: return `${V(B(e.item ?? e, t, n))}[]`;
+		case `object-array`: return `${H(e.item?.schema ?? {}, t, n)}[]`;
+		case `map`: return `Record<string, ${B(e.item ?? e, t, n)}>`;
+		case `object`: return H(e.schema, t, n);
+		case `json`:
+		case `any`: return `unknown`;
+	}
+}
+function V(e) {
+	return e.includes(` | `) ? `(${e})` : e;
+}
+function H(e, t, n = 0) {
+	let r = e.properties;
+	if (n > 1 || typeof r != `object` || !r) return `object`;
+	let i = Array.isArray(e.required) ? e.required : [], a = Object.entries(r).map(([e, r]) => {
+		let a = C$1(t, r), o = B(a, t, n + 1);
+		return `${e}${i.includes(e) ? `` : `?`}: ${o}${a.nullable ? ` | null` : ``}`;
+	});
+	return a.length > 0 ? `{ ${a.join(`; `)} }` : `object`;
+}
+function U(e) {
+	let t = e.inputSchema ?? {}, n = T$1(e);
+	if (n.bodyOnly) return r(`${e.name}(body: unknown)`);
+	let i = n.flags.filter((e) => !e.hidden).map((e) => `${e.wire}${e.required ? `` : `?`}: ${B(e.field, t)}${e.field.nullable ? ` | null` : ``}`);
+	return r(`${e.name}(${i.length > 0 ? `{ ${i.join(`; `)} }` : ``})`);
+}
+function W(e) {
+	return e.callOnly ? `call ${e.tool.name}` : e.path.join(` `);
+}
+function Z(e, t = !1) {
+	return e.entries.filter((e) => t || !e.hidden).map((e) => ({
+		command: W(e),
+		tool: e.tool.name,
+		summary: R(e.tool.description),
+		badges: z(e.tool)
+	})).sort((e, t) => e.command.localeCompare(t.command));
+}
+function Q(e) {
+	if (e.length === 0) return `No tools.
+`;
+	let t = Math.min(40, Math.max(...e.map((e) => e.command.length)));
+	return r(`${e.map((e) => `  ${e.command.padEnd(t)}  ${e.summary}${e.badges.length > 0 ? ` [${e.badges.join(`, `)}]` : ``}`.trimEnd()).join(`
+`)}\n`);
+}
+[...[
+	[`login`, `Sign in (browser, --device for a code to approve elsewhere, or --with-token for an API key)`],
+	[`logout`, `Sign out: revoke the session on the server and remove it here`],
+	[`auth status`, `Show who is signed in and which credential is in use`],
+	[`auth token`, `Print the current token`],
+	[`tools`, `List tools (--search <q>, --refresh, --json)`],
+	[`schema <tool>`, `Print a tool's input and output schemas`],
+	[`call <tool>`, `Call a tool by its exact name`],
+	[`resume <id>`, `Answer a paused call (an approval or other input) and print its result`],
+	[`tasks get <id>`, `Print a task's status, or its result once it has finished`],
+	[`tasks watch <id>`, `Follow a task (from --detach or --wait) until it finishes`],
+	[`tasks answer <id>`, `Answer a task waiting for approval or input, then follow it`],
+	[`tasks cancel <id>`, `Ask the server to cancel a task`],
+	[`completion <shell>`, `Print a bash, zsh or fish completion script`],
+	[`skill install`, `Write a SKILL.md for coding agents`],
+	[`doctor`, `Check node, credentials and the server`],
+	[`version`, `Print the version`]
+].slice(0, 13)];
+// ../mcp-cli/dist/chunk-Bc2e_4bO.mjs
+var p = class extends n$2 {};
+function m(e) {
+	return typeof e == `object` && !!e && !Array.isArray(e);
+}
+function h(e, t) {
+	try {
+		return JSON.parse(e);
+	} catch {
+		throw new p(`invalid_value`, `${t} is not valid JSON`);
+	}
+}
+function g(e) {
+	if (Array.isArray(e)) return e.map(g);
+	if (m(e)) {
+		let t = {};
+		for (let [r, i] of Object.entries(e)) E$1(t, r, g(i));
+		return t;
+	}
+	return e;
+}
+function _(e, t) {
+	let r = {};
+	for (let [t, i] of Object.entries(e)) E$1(r, t, i);
+	for (let [e, i] of Object.entries(t)) {
+		let t = Object.prototype.hasOwnProperty.call(r, e) ? r[e] : void 0;
+		E$1(r, e, m(t) && m(i) ? _(t, i) : i);
+	}
+	return r;
+}
+async function v(t, n, r) {
+	let i = t.slice(1);
+	if (i === ``) throw new p(`invalid_value`, `${r}: @ must be followed by a path, or - for stdin`);
+	if (i === `-`) return n.readStdin();
+	try {
+		return await n.readFile(i);
+	} catch (t) {
+		throw new n$2(`invalid_value`, `${r}: cannot read ${i} (${t instanceof Error && `code` in t ? String(t.code) : `unreadable`})`);
+	}
+}
+function y(e, t, n) {
+	switch (e) {
+		case `string`: return t;
+		case `integer`: {
+			let e = t.trim(), r = Number(e);
+			if (!/^[+-]?\d+$/.test(e) || !Number.isSafeInteger(r)) throw new p(`invalid_value`, `${n} expects an integer, got ${JSON.stringify(t)}`);
+			return r;
+		}
+		case `number`: {
+			let e = Number(t.trim());
+			if (t.trim() === `` || !Number.isFinite(e)) throw new p(`invalid_value`, `${n} expects a number, got ${JSON.stringify(t)}`);
+			return e;
+		}
+		case `boolean`: {
+			let e = t.trim().toLowerCase();
+			if (e === `true`) return !0;
+			if (e === `false`) return !1;
+			throw new p(`invalid_value`, `${n} expects true or false, got ${JSON.stringify(t)}`);
+		}
+	}
+}
+function b(e, t, n) {
+	for (let r of e) try {
+		return y(r, t, n);
+	} catch {
+		continue;
+	}
+	throw new p(`invalid_value`, `${n} expects ${e.join(` or `)}, got ${JSON.stringify(t)}`);
+}
+function x(e, t, n) {
+	let r = e.enumValues ?? [], i = r.find((e) => (typeof e == `string` ? e : JSON.stringify(e)) === t);
+	if (i === void 0 && !r.includes(t)) throw new p(`invalid_value`, `${n} must be one of ${r.map((e) => typeof e == `string` ? e : JSON.stringify(e)).join(`, `)}`);
+	return i ?? t;
+}
+async function S(e, t, n) {
+	return e.startsWith(`@@`) ? e.slice(1) : e.startsWith(`@`) ? (await v(e, t, n)).toString(`utf8`) : e;
+}
+async function C(e, t, n, r) {
+	switch (e.kind) {
+		case `string`: return t;
+		case `binary`: return t.startsWith(`@@`) ? t.slice(1) : t.startsWith(`@`) ? (await v(t, r, n)).toString(`base64`) : t;
+		case `enum`: return x(e, t, n);
+		case `integer`:
+		case `number`:
+		case `boolean`: return y(e.kind, t, n);
+		case `scalar-union`: return b(e.unionKinds ?? [`string`], t, n);
+		case `const`: return e.constValue;
+		case `object`:
+		case `object-array`:
+		case `json`: {
+			let i = g(h(await S(t, r, n), n));
+			if (e.kind === `object` && !m(i)) throw new p(`invalid_value`, `${n} expects a JSON object`);
+			return i;
+		}
+		case `any`: {
+			let e = await S(t, r, n);
+			try {
+				return g(JSON.parse(e));
+			} catch {
+				return e;
+			}
+		}
+		case `scalar-array`:
+		case `map`: return C(e.item ?? {
+			...e,
+			kind: `any`
+		}, t, n, r);
+	}
+}
+async function w(t, r, i) {
+	let a = `--${t.flag}`, o = t.field;
+	if (o.kind === `scalar-array`) {
+		let e = o.item ?? o, t = [];
+		for (let n of r) if (r.length === 1 && n.trimStart().startsWith(`[`)) {
+			let r = h(n, a);
+			if (!Array.isArray(r)) throw new p(`invalid_value`, `${a} expects a JSON array`);
+			for (let n of r) t.push(typeof n == `string` ? await C(e, n, a, i) : n);
+		} else t.push(await C(e, n, a, i));
+		return t;
+	}
+	if (o.kind === `object-array`) {
+		let e = [];
+		for (let t of r) {
+			let n = await C({
+				...o,
+				kind: `json`
+			}, t, a, i);
+			Array.isArray(n) ? e.push(...n) : e.push(n);
+		}
+		return e;
+	}
+	if (o.kind === `map`) {
+		let t = {};
+		for (let s of r) {
+			let r = s.indexOf(`=`);
+			if (r <= 0) throw new p(`invalid_value`, `${a} expects key=value`);
+			let c = s.slice(0, r);
+			if (Object.prototype.hasOwnProperty.call(t, c)) throw new n$2(`usage`, `${a} sets ${c} more than once`);
+			E$1(t, c, await C(o.item ?? o, s.slice(r + 1), `${a} ${c}`, i));
+		}
+		return t;
+	}
+	return C(o, r[0], a, i);
+}
+function T(t, n) {
+	let r = n ? `-F` : `-f`, i = t.indexOf(`=`);
+	if (i === -1 && /^[^[\]=]+(?:\[[^[\]]+\])*\[\]$/.test(t)) return {
+		...T(`${t}=`, n),
+		empty: !0
+	};
+	if (i <= 0) throw new n$2(`usage`, `${r} expects key=value, got ${JSON.stringify(t)}`);
+	let a = t.slice(0, i), o = /^([^[\]]+)((?:\[[^[\]]*\])*)$/.exec(a);
+	if (!o) throw new n$2(`usage`, `${r} key ${JSON.stringify(a)} is malformed`);
+	let s = [o[1]], c = !1, l = [...o[2].matchAll(/\[([^[\]]*)\]/g)].map((e) => e[1]);
+	for (let [t, n] of l.entries()) if (n === ``) {
+		if (t !== l.length - 1) throw new n$2(`usage`, `${r} supports [] only at the end of a key`);
+		c = !0;
+	} else s.push(n);
+	return {
+		path: s,
+		append: c,
+		raw: t.slice(i + 1),
+		typed: n
+	};
+}
+async function E(e, n, r, i) {
+	let a = `${e.typed ? `-F` : `-f`} ${e.path.join(`.`)}`;
+	if (!e.typed || r) return e.raw;
+	let s = re(n, e.append ? [...e.path, `[]`] : e.path), c = e.raw;
+	if (c.startsWith(`@@`)) c = c.slice(1);
+	else if (c.startsWith(`@`)) {
+		let e = await v(c, i, a);
+		if (s?.kind === `binary`) return e.toString(`base64`);
+		if (c = e.toString(`utf8`), s && (s.kind === `string` || s.kind === `enum`)) return c;
+	}
+	if (c === `null`) return null;
+	let l = D(c);
+	return typeof l.value == `string` ? s?.kind === `enum` ? x(s, l.value, a) : l.value : s && (s.kind === `string` || s.kind === `binary`) ? c : s?.kind === `enum` ? x(s, c, a) : l.ok ? l.value : c;
+}
+function D(e) {
+	try {
+		return {
+			ok: !0,
+			value: g(JSON.parse(e))
+		};
+	} catch {
+		return { ok: !1 };
+	}
+}
+function O(t, r, i) {
+	let a = t;
+	for (let t of r.path.slice(0, -1)) {
+		let i = Object.prototype.hasOwnProperty.call(a, t) ? a[t] : void 0;
+		if (i === void 0) {
+			let e = {};
+			E$1(a, t, e), a = e;
+		} else if (m(i)) a = i;
+		else throw new n$2(`usage`, `-F ${r.path.join(`.`)} conflicts with a non-object value`);
+	}
+	let o = r.path[r.path.length - 1];
+	if (r.append) {
+		let t = Object.prototype.hasOwnProperty.call(a, o) ? a[o] : void 0, s = r.empty ? [] : [i];
+		if (t === void 0) E$1(a, o, s);
+		else if (Array.isArray(t)) t.push(...s);
+		else throw new n$2(`usage`, `-F ${o}[] conflicts with a non-array value`);
+	} else {
+		if (Object.prototype.hasOwnProperty.call(a, o)) throw new n$2(`usage`, `${r.path.join(`.`)} is set more than once by -f/-F`);
+		E$1(a, o, i);
+	}
+}
+async function k(e, t) {
+	let n = typeof e == `string` ? e : e.toString(`utf8`);
+	if (n.trim() !== ``) return g(h(n, t));
+}
+function A(e, t) {
+	if (t !== `@-`) return !1;
+	switch (e.kind) {
+		case `binary`:
+		case `object`:
+		case `object-array`:
+		case `json`:
+		case `any`: return !0;
+		case `scalar-array`:
+		case `map`: return A(e.item ?? {
+			...e,
+			kind: `any`
+		}, t);
+		default: return !1;
+	}
+}
+function j(e, t) {
+	let { field: n } = e;
+	if (n.kind === `map`) return t.some((e) => e.indexOf(`=`) > 0 && A(n, e.slice(e.indexOf(`=`) + 1)));
+	if (n.kind === `scalar-array` && t.length === 1 && t[0].trimStart().startsWith(`[`)) try {
+		let e = JSON.parse(t[0]);
+		return Array.isArray(e) && e.some((e) => typeof e == `string` && A(n, e));
+	} catch {
+		return !1;
+	}
+	return t.some((e) => A(n, e));
+}
+function M(e, t) {
+	let { reserved: n } = e;
+	if (n.input === `-` || !n.rawStrings && n.fields.some((e) => e.slice(e.indexOf(`=`) + 1) === `@-`) || e.positionals.some((e, n) => t.positionals[n] !== void 0 && A(t.positionals[n].field, e))) return !0;
+	for (let [t, n] of e.values) if (j(t, n)) return !0;
+	return !1;
+}
+function N(e, t) {
+	return e.reserved.answers === `-` || M(e, t);
+}
+async function P(t, r, i) {
+	let { reserved: a } = r;
+	if (a.input !== void 0 && a.jsonBody !== void 0) throw new n$2(`usage`, `Use only one of --input and --json-body`);
+	let o, s = !1;
+	if (a.jsonBody !== void 0) o = await k(a.jsonBody, `--json-body`);
+	else if (a.input !== void 0) o = await k(a.input === `-` ? await i.readStdin() : await v(`@${a.input}`, i, `--input`), a.input === `-` ? `stdin` : a.input);
+	else if (!i.noInput && !N(r, t) && i.stdinIsPipedData()) {
+		let e = await i.readStdin();
+		e.length > 0 && (o = await k(e, `stdin`), s = o !== void 0);
+	}
+	let c = r.values.size > 0 || r.booleans.size > 0 || r.positionals.length > 0, l = a.fields.length > 0 || a.rawFields.length > 0;
+	if (t.bodyOnly) {
+		if (c || l) throw new n$2(`usage`, `${t.tool.name} takes its arguments as one JSON value`, `Use --json-body, --input <file|-> or pipe JSON on stdin`);
+		return {
+			args: o === void 0 ? {} : o,
+			usedAutoStdin: s
+		};
+	}
+	if (o !== void 0 && !m(o)) throw new n$2(`invalid_value`, `The arguments body must be a JSON object`);
+	let u = o ?? {};
+	if (l) {
+		let e = {}, n = t.tool.inputSchema ?? {}, r = [...a.rawFields.map((e) => T(e, !1)), ...a.fields.map((e) => T(e, !0))];
+		for (let o of r) {
+			let r = o.path[0], s = t.byWire.has(r) ? r : t.byFlag.get(r)?.wire ?? r, c = {
+				...o,
+				path: [s, ...o.path.slice(1)]
+			};
+			O(e, c, c.empty ? void 0 : await E(c, n, a.rawStrings, i));
+		}
+		u = _(u, e);
+	}
+	let d = {};
+	if (r.positionals.length > t.positionals.length) {
+		let n = r.positionals.slice(t.positionals.length);
+		throw new n$2(`usage`, `Unexpected argument${n.length > 1 ? `s` : ``}: ${n.map((e) => JSON.stringify(e)).join(` `)}`, t.positionals.length === 0 ? `Pass values as --flags; run with --help to list them` : void 0);
+	}
+	for (let [a, o] of r.positionals.entries()) {
+		let s = t.positionals[a], c = r.values.get(s);
+		if (c && c.some((e) => e !== o)) throw new n$2(`usage`, `${s.wire} was given both positionally and as --${s.flag}, with different values`);
+		E$1(d, s.wire, await C(s.field, o, s.wire, i));
+	}
+	for (let [e, t] of r.values) E$1(d, e.wire, await w(e, t, i));
+	for (let [e, t] of r.booleans) E$1(d, e.wire, t);
+	u = _(u, d);
+	for (let [e, r] of [...Object.entries(t.constFields), ...Object.entries(t.defaults)]) Object.prototype.hasOwnProperty.call(u, e) || E$1(u, e, structuredClone(r));
+	let f = t.required.filter((e) => !Object.prototype.hasOwnProperty.call(u, e));
+	if (f.length > 0) {
+		let e = f.map((e) => {
+			let n = t.byWire.get(e);
+			return n?.position === void 0 ? `--${n?.flag ?? e}` : `<${n.flag}>`;
+		});
+		throw new p(`missing_argument`, `Missing required ${e.length > 1 ? `arguments` : `argument`}: ${e.join(`, `)}`, `Run with --help for usage`);
+	}
+	return {
+		args: u,
+		usedAutoStdin: s
+	};
+}
+// src/lib/mcp-input.ts
+const SCHEMALESS = {
+	name: "tool",
+	inputSchema: { type: "object" }
+};
+function toMcpCliArgv(options) {
+	return [
+		...(options.rawField ?? []).flatMap((value) => ["-f", value]),
+		...(options.field ?? []).flatMap((value) => ["-F", value]),
+		...options.jsonBody !== void 0 ? ["--json-body", options.jsonBody] : [],
+		...options.input !== void 0 ? ["--input", options.input] : []
+	];
+}
+/** Whether resolving these arguments will consume the process stdin stream; the parser that reads it decides. */
+function usesMcpStdin(options) {
+	const spec = T$1(SCHEMALESS);
+	try {
+		return N(ce(toMcpCliArgv(options), spec), spec);
+	} catch {
+		return false;
+	}
+}
+/** `-F` is the only input whose meaning depends on the tool's schema. */
+function needsMcpToolSchema(options) {
+	return (options.field ?? []).length > 0;
+}
+async function readStream(stream) {
+	const chunks = [];
+	for await (const chunk of stream) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+	return Buffer.concat(chunks);
+}
+/**
+* Builds tools/call arguments with the `@runtypelabs/mcp-cli` input layer: `--input`/`--json-body`,
+* then `-f`/`-F` deep-merged over it. Given the tool, `-F id=123` stays a string for a string field.
+*/
+async function resolveMcpArguments(options, dependencies = {}) {
+	let stdinPromise;
+	const deps = {
+		readFile: (path) => readFile(path),
+		readStdin: () => {
+			stdinPromise ??= readStream(process.stdin);
+			return stdinPromise;
+		},
+		...dependencies
+	};
+	const toolSpec = T$1(deps.tool ?? SCHEMALESS);
+	const spec = toolSpec.bodyOnly ? T$1(SCHEMALESS) : {
+		...toolSpec,
+		required: [],
+		positionals: []
+	};
+	const { args } = await P(spec, ce(toMcpCliArgv(options), spec), {
+		readFile: deps.readFile,
+		readStdin: deps.readStdin,
+		stdinIsPipedData: () => false,
+		noInput: true
+	});
+	return args;
+}
+// src/commands/mcp.ts
+const defaultDependencies = {
+	ensureAuth,
+	connect: connectMcpClient,
+	resolveArguments: (options, tool) => resolveMcpArguments(options, { tool }),
+	setExitCode: (code) => {
+		process.exitCode = code;
+	}
+};
+const DEFAULT_TOOL_TIMEOUT_MS = 93e4;
+const TOOL_SCHEMA_LOOKUP_TIMEOUT_MS = 1e4;
+/** Listing for `-F` must not make the SDK enforce `outputSchema`, which a call without `-F` never does. */
+function withoutOutputSchema(tool) {
+	const { outputSchema: _outputSchema, ...definition } = tool;
+	return definition;
+}
+function collectField(value, previous) {
+	return previous.concat(value);
+}
+function parseServer(value) {
+	if (value === "standard" || value === "code") return value;
+	throw new InvalidArgumentError("Allowed values are \"standard\" and \"code\"");
+}
+function parsePositiveInteger(value) {
+	const parsed = Number(value);
+	if (!Number.isSafeInteger(parsed) || parsed <= 0) throw new InvalidArgumentError("Timeout must be a positive integer in milliseconds");
+	return parsed;
+}
+function addCommonOptions(command) {
+	return command.option("--server <server>", "Runtype MCP server to use: standard or code", parseServer, "standard").option("--json", "Output the complete MCP result as JSON");
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+async function withMcpClient(options, dependencies, operation, authOptions) {
+	const apiKey = await dependencies.ensureAuth(authOptions);
+	if (!apiKey) {
+		dependencies.setExitCode(1);
+		return;
+	}
+	const { client } = await dependencies.connect(apiKey, options.server);
+	try {
+		await operation(client);
+	} finally {
+		await client.close().catch(() => void 0);
+	}
+}
+function printTools(tools, target) {
+	if (tools.length === 0) {
+		console.log(chalk.gray("No MCP tools found"));
+		return;
+	}
+	const label = target === "code" ? "Code Mode MCP Tools" : "MCP Tools";
+	console.log(chalk.cyan(`${label}:`));
+	const rows = Z(u(tools), true).map((row) => ({
+		...row,
+		command: row.tool
+	}));
+	process.stdout.write(Q(rows));
+	console.log(chalk.dim(`\n  Total: ${tools.length} tools`));
+}
+function printTool(tool) {
+	printDetail("MCP Tool", [
+		{
+			label: "Name",
+			value: tool.name
+		},
+		{
+			label: "Title",
+			value: tool.title
+		},
+		{
+			label: "Description",
+			value: tool.description
+		},
+		{
+			label: "Signature",
+			value: U(tool)
+		},
+		{
+			label: "Hints",
+			value: z(tool).join(", ") || void 0
+		},
+		{
+			label: "Input Schema",
+			value: tool.inputSchema
+		},
+		{
+			label: "Output Schema",
+			value: tool.outputSchema
+		},
+		{
+			label: "Annotations",
+			value: tool.annotations
+		},
+		{
+			label: "Execution",
+			value: tool.execution
+		}
+	]);
+}
+function printCallResult(result, json) {
+	if (json) {
+		printJson(result);
+		return;
+	}
+	const textOnly = result.content.length > 0 && result.content.every((block) => block.type === "text");
+	if (result.structuredContent !== void 0 || textOnly) {
+		const mode = e(void 0, { stdoutIsTTY: process.stdout.isTTY === true });
+		console.log(h$2(result, { mode }));
+		return;
+	}
+	printJson(result);
+}
+function createMcpCommand(overrides = {}) {
+	const dependencies = {
+		...defaultDependencies,
+		...overrides
+	};
+	const command = new Command("mcp").description("Discover and call tools on the Runtype MCP servers");
+	addCommonOptions(command.command("tools").description("List dynamically exposed MCP tools")).action(async (options) => {
+		try {
+			await withMcpClient(options, dependencies, async (client) => {
+				const tools = await listAllMcpTools(client);
+				if (options.json) printJson({ tools });
+				else printTools(tools, options.server);
+			});
+		} catch (error) {
+			console.error(chalk.red(`Failed to list MCP tools: ${errorMessage(error)}`));
+			dependencies.setExitCode(1);
+		}
+	});
+	addCommonOptions(command.command("inspect <name>").description("Show a tool and its current schemas")).action(async (name, options) => {
+		try {
+			await withMcpClient(options, dependencies, async (client) => {
+				const tool = (await listAllMcpTools(client)).find((candidate) => candidate.name === name);
+				if (!tool) throw new Error(`MCP tool "${name}" was not found`);
+				if (options.json) printJson(tool);
+				else printTool(tool);
+			});
+		} catch (error) {
+			console.error(chalk.red(`Failed to inspect MCP tool: ${errorMessage(error)}`));
+			dependencies.setExitCode(1);
+		}
+	});
+	addCommonOptions(command.command("call <name>").description("Call any MCP tool by name without local registration").option("-f, --raw-field <key=value>", "Add a string argument", collectField, []).option("-F, --field <key=value>", "Add a JSON-typed argument; use @<path> or @- to read its value", collectField, []).option("--json-body <json>", "Use an inline JSON object as the tool arguments").option("--input <file>", "Read the tool arguments JSON object from a file or - for stdin").option("--timeout <ms>", "Maximum time to wait for the tool result in milliseconds", parsePositiveInteger, DEFAULT_TOOL_TIMEOUT_MS)).action(async (name, options) => {
+		try {
+			await withMcpClient(options, dependencies, async (client) => {
+				const tool = needsMcpToolSchema(options) ? (await listAllMcpTools(client, { timeout: TOOL_SCHEMA_LOOKUP_TIMEOUT_MS }).catch(() => [])).find((item) => item.name === name) : void 0;
+				const args = await dependencies.resolveArguments(options, tool);
+				const result = await client.callTool({
+					name,
+					arguments: args
+				}, {
+					timeout: options.timeout,
+					...tool ? { toolDefinition: withoutOutputSchema(tool) } : {}
+				});
+				if (!("content" in result) || !Array.isArray(result.content)) throw new Error("Task-augmented MCP tool results are not supported by this command");
+				const callResult = result;
+				printCallResult(callResult, options.json);
+				if (callResult.isError) dependencies.setExitCode(1);
+			}, usesMcpStdin(options) ? {
+				interactive: false,
+				exitOnFailure: false
+			} : void 0);
+		} catch (error) {
+			console.error(chalk.red(`MCP tool call failed: ${errorMessage(error)}`));
+			dependencies.setExitCode(1);
+		}
+	});
+	return command;
+}
+const mcpCommand = createMcpCommand();
+export { mcpCommand };
+