@pixelzx/genesis 2026.6.13-beta.3 → 2026.6.13

package/dist/mcp-cli-Cq3kJYFy.js

@@ -0,0 +1,725 @@
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString, d as normalizeStringifiedOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DPP_aYVc.js";
+import { n as defaultRuntime } from "./runtime-DDkDH9fa.js";
+import { n as VERSION } from "./version-qod78efn.js";
+import { a as loadConfig } from "./io-lNN4Levs.js";
+import "./config-DzozJ_v4.js";
+import { t as GatewayClient } from "./client-BdWZGAKV.js";
+import { i as GATEWAY_CLIENT_NAMES, r as GATEWAY_CLIENT_MODES } from "./client-info-DeQMz3zN.js";
+import { u as normalizeMessageChannel } from "./message-channel-DGBKBihv.js";
+import { d as WRITE_SCOPE, l as READ_SCOPE, s as APPROVALS_SCOPE } from "./method-scopes-BJj0ofY0.js";
+import { i as extractFirstTextBlock } from "./chat-message-content-iIHjZfPu.js";
+import { i as unsetConfiguredMcpServer, r as setConfiguredMcpServer, t as listConfiguredMcpServers } from "./mcp-config-SY5hxaKj.js";
+import { t as resolveGatewayClientBootstrap } from "./client-bootstrap-JabjiE2k.js";
+import { t as parseConfigValue } from "./config-value-DWXWt-dW.js";
+import { t as resolveGatewayAuthOptions } from "./gateway-secret-options-OcxZ59wi.js";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+//#region src/mcp/channel-shared.ts
+const ClaudePermissionRequestSchema = z.object({
+	method: z.literal("notifications/claude/channel/permission_request"),
+	params: z.object({
+		request_id: z.string(),
+		tool_name: z.string(),
+		description: z.string(),
+		input_preview: z.string()
+	})
+});
+function resolveMessageId(entry) {
+	return normalizeOptionalString(entry.id) ?? (entry.__genesis && typeof entry.__genesis === "object" ? normalizeOptionalString(entry.__genesis.id) : void 0);
+}
+function summarizeResult(label, count) {
+	return { content: [{
+		type: "text",
+		text: `${label}: ${count}`
+	}] };
+}
+function resolveConversationChannel(row) {
+	return normalizeMessageChannel(normalizeOptionalString(row.deliveryContext?.channel) ?? normalizeOptionalString(row.lastChannel) ?? normalizeOptionalString(row.channel) ?? normalizeOptionalString(row.origin?.provider));
+}
+function toConversation(row) {
+	const channel = resolveConversationChannel(row);
+	const to = normalizeOptionalString(row.deliveryContext?.to) ?? normalizeOptionalString(row.lastTo);
+	if (!channel || !to) return null;
+	return {
+		sessionKey: row.key,
+		channel,
+		to,
+		accountId: normalizeOptionalString(row.deliveryContext?.accountId) ?? normalizeOptionalString(row.lastAccountId) ?? normalizeOptionalString(row.origin?.accountId),
+		threadId: row.deliveryContext?.threadId ?? row.lastThreadId ?? row.origin?.threadId,
+		label: normalizeOptionalString(row.label),
+		displayName: normalizeOptionalString(row.displayName),
+		derivedTitle: normalizeOptionalString(row.derivedTitle),
+		lastMessagePreview: normalizeOptionalString(row.lastMessagePreview),
+		updatedAt: typeof row.updatedAt === "number" ? row.updatedAt : null
+	};
+}
+function matchEventFilter(event, filter) {
+	if (event.cursor <= filter.afterCursor) return false;
+	if (!filter.sessionKey) return true;
+	return "sessionKey" in event && event.sessionKey === filter.sessionKey;
+}
+function extractAttachmentsFromMessage(message) {
+	if (!message || typeof message !== "object") return [];
+	const content = message.content;
+	if (!Array.isArray(content)) return [];
+	return content.filter((entry) => {
+		if (!entry || typeof entry !== "object") return false;
+		return normalizeOptionalString(entry.type) !== "text";
+	});
+}
+function normalizeApprovalId(value) {
+	const id = normalizeOptionalString(value);
+	return id ? id.trim() : void 0;
+}
+//#endregion
+//#region src/mcp/channel-bridge.ts
+const CLAUDE_PERMISSION_REPLY_RE = /^(yes|no)\s+([a-km-z]{5})$/i;
+const QUEUE_LIMIT = 1e3;
+var GenesisChannelBridge = class {
+	constructor(cfg, params) {
+		this.cfg = cfg;
+		this.params = params;
+		this.gateway = null;
+		this.queue = [];
+		this.pendingWaiters = /* @__PURE__ */ new Set();
+		this.pendingClaudePermissions = /* @__PURE__ */ new Map();
+		this.pendingApprovals = /* @__PURE__ */ new Map();
+		this.server = null;
+		this.cursor = 0;
+		this.closed = false;
+		this.ready = false;
+		this.started = false;
+		this.readySettled = false;
+		this.verbose = params.verbose;
+		this.claudeChannelMode = params.claudeChannelMode;
+		this.readyPromise = new Promise((resolve, reject) => {
+			this.resolveReady = resolve;
+			this.rejectReady = reject;
+		});
+	}
+	setServer(server) {
+		this.server = server;
+	}
+	async start() {
+		if (this.started) {
+			await this.readyPromise;
+			return;
+		}
+		this.started = true;
+		const bootstrap = await resolveGatewayClientBootstrap({
+			config: this.cfg,
+			gatewayUrl: this.params.gatewayUrl,
+			explicitAuth: {
+				token: this.params.gatewayToken,
+				password: this.params.gatewayPassword
+			},
+			env: process.env
+		});
+		if (this.closed) {
+			this.resolveReadyOnce();
+			return;
+		}
+		this.gateway = new GatewayClient({
+			url: bootstrap.url,
+			token: bootstrap.auth.token,
+			password: bootstrap.auth.password,
+			clientName: GATEWAY_CLIENT_NAMES.CLI,
+			clientDisplayName: "Genesis MCP",
+			clientVersion: VERSION,
+			mode: GATEWAY_CLIENT_MODES.CLI,
+			scopes: [
+				READ_SCOPE,
+				WRITE_SCOPE,
+				APPROVALS_SCOPE
+			],
+			onEvent: (event) => {
+				this.handleGatewayEvent(event);
+			},
+			onHelloOk: () => {
+				this.handleHelloOk();
+			},
+			onConnectError: (error) => {
+				this.rejectReadyOnce(error instanceof Error ? error : new Error(String(error)));
+			},
+			onClose: (code, reason) => {
+				if (!this.ready && !this.closed) this.rejectReadyOnce(/* @__PURE__ */ new Error(`gateway closed before ready (${code}): ${reason}`));
+			}
+		});
+		this.gateway.start();
+		await this.readyPromise;
+	}
+	async waitUntilReady() {
+		await this.readyPromise;
+	}
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.resolveReadyOnce();
+		for (const waiter of this.pendingWaiters) {
+			if (waiter.timeout) clearTimeout(waiter.timeout);
+			waiter.resolve(null);
+		}
+		this.pendingWaiters.clear();
+		const gateway = this.gateway;
+		this.gateway = null;
+		await gateway?.stopAndWait().catch(() => void 0);
+	}
+	async listConversations(params) {
+		await this.waitUntilReady();
+		const response = await this.requestGateway("sessions.list", {
+			limit: params?.limit ?? 50,
+			search: params?.search,
+			includeDerivedTitles: params?.includeDerivedTitles ?? true,
+			includeLastMessage: params?.includeLastMessage ?? true
+		});
+		const requestedChannel = normalizeOptionalLowercaseString(params?.channel);
+		return (response.sessions ?? []).map(toConversation).filter((conversation) => Boolean(conversation)).filter((conversation) => requestedChannel ? normalizeLowercaseStringOrEmpty(conversation.channel) === requestedChannel : true);
+	}
+	async getConversation(sessionKey) {
+		const normalizedSessionKey = sessionKey.trim();
+		if (!normalizedSessionKey) return null;
+		return (await this.listConversations({
+			limit: 500,
+			includeLastMessage: true
+		})).find((conversation) => conversation.sessionKey === normalizedSessionKey) ?? null;
+	}
+	async readMessages(sessionKey, limit = 20) {
+		await this.waitUntilReady();
+		return (await this.requestGateway("chat.history", {
+			sessionKey,
+			limit
+		})).messages ?? [];
+	}
+	async sendMessage(params) {
+		const conversation = await this.getConversation(params.sessionKey);
+		if (!conversation) throw new Error(`Conversation not found for session ${params.sessionKey}`);
+		return await this.requestGateway("send", {
+			to: conversation.to,
+			channel: conversation.channel,
+			accountId: conversation.accountId,
+			threadId: conversation.threadId == null ? void 0 : String(conversation.threadId),
+			message: params.text,
+			sessionKey: conversation.sessionKey,
+			idempotencyKey: randomUUID()
+		});
+	}
+	listPendingApprovals() {
+		return [...this.pendingApprovals.values()].toSorted((a, b) => {
+			return (a.createdAtMs ?? 0) - (b.createdAtMs ?? 0);
+		});
+	}
+	async respondToApproval(params) {
+		if (params.kind === "exec") return await this.requestGateway("exec.approval.resolve", {
+			id: params.id,
+			decision: params.decision
+		});
+		return await this.requestGateway("plugin.approval.resolve", {
+			id: params.id,
+			decision: params.decision
+		});
+	}
+	pollEvents(filter, limit = 20) {
+		const events = this.queue.filter((event) => matchEventFilter(event, filter)).slice(0, limit);
+		return {
+			events,
+			nextCursor: events.at(-1)?.cursor ?? filter.afterCursor
+		};
+	}
+	async waitForEvent(filter, timeoutMs = 3e4) {
+		const existing = this.queue.find((event) => matchEventFilter(event, filter));
+		if (existing) return existing;
+		return await new Promise((resolve) => {
+			const waiter = {
+				filter,
+				resolve: (value) => {
+					this.pendingWaiters.delete(waiter);
+					resolve(value);
+				},
+				timeout: null
+			};
+			if (timeoutMs > 0) waiter.timeout = setTimeout(() => {
+				waiter.resolve(null);
+			}, timeoutMs);
+			this.pendingWaiters.add(waiter);
+		});
+	}
+	async handleClaudePermissionRequest(params) {
+		this.pendingClaudePermissions.set(params.requestId, {
+			toolName: params.toolName,
+			description: params.description,
+			inputPreview: params.inputPreview
+		});
+		this.enqueue({
+			cursor: this.nextCursor(),
+			type: "claude_permission_request",
+			requestId: params.requestId,
+			toolName: params.toolName,
+			description: params.description,
+			inputPreview: params.inputPreview
+		});
+		if (this.verbose) process.stderr.write(`genesis mcp: pending Claude permission ${params.requestId}\n`);
+	}
+	async requestGateway(method, params) {
+		if (!this.gateway) throw new Error("Gateway client is not ready");
+		return await this.gateway.request(method, params);
+	}
+	async sendNotification(notification) {
+		if (!this.server || this.closed) return;
+		try {
+			await this.server.server.notification(notification);
+		} catch (error) {
+			if (this.verbose && !this.closed) process.stderr.write(`genesis mcp: notification ${notification.method} failed: ${String(error)}\n`);
+		}
+	}
+	async handleHelloOk() {
+		try {
+			await this.requestGateway("sessions.subscribe", {});
+			this.ready = true;
+			this.resolveReadyOnce();
+		} catch (error) {
+			this.rejectReadyOnce(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+	resolveReadyOnce() {
+		if (this.readySettled) return;
+		this.readySettled = true;
+		this.resolveReady();
+	}
+	rejectReadyOnce(error) {
+		if (this.readySettled) return;
+		this.readySettled = true;
+		this.rejectReady(error);
+	}
+	nextCursor() {
+		this.cursor += 1;
+		return this.cursor;
+	}
+	enqueue(event) {
+		this.queue.push(event);
+		while (this.queue.length > QUEUE_LIMIT) this.queue.shift();
+		for (const waiter of this.pendingWaiters) {
+			if (!matchEventFilter(event, waiter.filter)) continue;
+			if (waiter.timeout) clearTimeout(waiter.timeout);
+			waiter.resolve(event);
+		}
+	}
+	trackApproval(kind, payload) {
+		const id = normalizeApprovalId(payload.id);
+		if (!id) return;
+		this.pendingApprovals.set(id, {
+			kind,
+			id,
+			request: payload.request && typeof payload.request === "object" ? payload.request : void 0,
+			createdAtMs: typeof payload.createdAtMs === "number" ? payload.createdAtMs : void 0,
+			expiresAtMs: typeof payload.expiresAtMs === "number" ? payload.expiresAtMs : void 0
+		});
+	}
+	resolveTrackedApproval(payload) {
+		const id = normalizeApprovalId(payload.id);
+		if (id) this.pendingApprovals.delete(id);
+	}
+	async handleGatewayEvent(event) {
+		switch (event.event) {
+			case "session.message":
+				await this.handleSessionMessageEvent(event.payload);
+				return;
+			case "exec.approval.requested": {
+				const raw = event.payload ?? {};
+				this.trackApproval("exec", raw);
+				this.enqueue({
+					cursor: this.nextCursor(),
+					type: "exec_approval_requested",
+					raw
+				});
+				return;
+			}
+			case "exec.approval.resolved": {
+				const raw = event.payload ?? {};
+				this.resolveTrackedApproval(raw);
+				this.enqueue({
+					cursor: this.nextCursor(),
+					type: "exec_approval_resolved",
+					raw
+				});
+				return;
+			}
+			case "plugin.approval.requested": {
+				const raw = event.payload ?? {};
+				this.trackApproval("plugin", raw);
+				this.enqueue({
+					cursor: this.nextCursor(),
+					type: "plugin_approval_requested",
+					raw
+				});
+				return;
+			}
+			case "plugin.approval.resolved": {
+				const raw = event.payload ?? {};
+				this.resolveTrackedApproval(raw);
+				this.enqueue({
+					cursor: this.nextCursor(),
+					type: "plugin_approval_resolved",
+					raw
+				});
+			}
+		}
+	}
+	async handleSessionMessageEvent(payload) {
+		const sessionKey = normalizeOptionalString(payload.sessionKey);
+		if (!sessionKey) return;
+		const conversation = toConversation({
+			key: sessionKey,
+			lastChannel: normalizeOptionalString(payload.lastChannel),
+			lastTo: normalizeOptionalString(payload.lastTo),
+			lastAccountId: normalizeOptionalString(payload.lastAccountId),
+			lastThreadId: payload.lastThreadId
+		}) ?? void 0;
+		const role = normalizeOptionalString(payload.message?.role);
+		const text = extractFirstTextBlock(payload.message);
+		const permissionMatch = text ? CLAUDE_PERMISSION_REPLY_RE.exec(text) : null;
+		if (permissionMatch) {
+			const requestId = normalizeOptionalLowercaseString(permissionMatch[2]);
+			if (requestId && this.pendingClaudePermissions.has(requestId)) {
+				this.pendingClaudePermissions.delete(requestId);
+				await this.sendNotification({
+					method: "notifications/claude/channel/permission",
+					params: {
+						request_id: requestId,
+						behavior: normalizeLowercaseStringOrEmpty(permissionMatch[1]).startsWith("y") ? "allow" : "deny"
+					}
+				});
+				return;
+			}
+		}
+		this.enqueue({
+			cursor: this.nextCursor(),
+			type: "message",
+			sessionKey,
+			conversation,
+			messageId: normalizeOptionalString(payload.messageId),
+			messageSeq: typeof payload.messageSeq === "number" ? payload.messageSeq : void 0,
+			role,
+			text,
+			raw: payload
+		});
+		if (!this.shouldEmitClaudeChannel(role, conversation)) return;
+		await this.sendNotification({
+			method: "notifications/claude/channel",
+			params: {
+				content: text ?? "[non-text message]",
+				meta: {
+					session_key: sessionKey,
+					channel: conversation?.channel ?? "",
+					to: conversation?.to ?? "",
+					account_id: conversation?.accountId ?? "",
+					thread_id: conversation?.threadId == null ? "" : String(conversation.threadId),
+					message_id: normalizeOptionalString(payload.messageId) ?? ""
+				}
+			}
+		});
+	}
+	shouldEmitClaudeChannel(role, conversation) {
+		if (this.claudeChannelMode === "off") return false;
+		if (role !== "user") return false;
+		return Boolean(conversation);
+	}
+};
+//#endregion
+//#region src/mcp/channel-tools.ts
+function getChannelMcpCapabilities(claudeChannelMode) {
+	if (claudeChannelMode === "off") return;
+	return { experimental: {
+		"claude/channel": {},
+		"claude/channel/permission": {}
+	} };
+}
+function registerChannelMcpTools(server, bridge) {
+	server.tool("conversations_list", "List Genesis channel-backed conversations available through session routes.", {
+		limit: z.number().int().min(1).max(500).optional(),
+		search: z.string().optional(),
+		channel: z.string().optional(),
+		includeDerivedTitles: z.boolean().optional(),
+		includeLastMessage: z.boolean().optional()
+	}, async (args) => {
+		const conversations = await bridge.listConversations(args);
+		return {
+			...summarizeResult("conversations", conversations.length),
+			structuredContent: { conversations }
+		};
+	});
+	server.tool("conversation_get", "Get one Genesis conversation by session key.", { session_key: z.string().min(1) }, async ({ session_key }) => {
+		const conversation = await bridge.getConversation(session_key);
+		if (!conversation) return {
+			content: [{
+				type: "text",
+				text: `conversation not found: ${session_key}`
+			}],
+			isError: true
+		};
+		return {
+			content: [{
+				type: "text",
+				text: `conversation ${conversation.sessionKey}`
+			}],
+			structuredContent: { conversation }
+		};
+	});
+	server.tool("messages_read", "Read recent messages for one Genesis conversation.", {
+		session_key: z.string().min(1),
+		limit: z.number().int().min(1).max(200).optional()
+	}, async ({ session_key, limit }) => {
+		const messages = await bridge.readMessages(session_key, limit ?? 20);
+		return {
+			...summarizeResult("messages", messages.length),
+			structuredContent: { messages }
+		};
+	});
+	server.tool("attachments_fetch", "List non-text attachments for a message in one Genesis conversation.", {
+		session_key: z.string().min(1),
+		message_id: z.string().min(1),
+		limit: z.number().int().min(1).max(200).optional()
+	}, async ({ session_key, message_id, limit }) => {
+		const message = (await bridge.readMessages(session_key, limit ?? 100)).find((entry) => resolveMessageId(entry) === message_id);
+		if (!message) return {
+			content: [{
+				type: "text",
+				text: `message not found: ${message_id}`
+			}],
+			isError: true
+		};
+		const attachments = extractAttachmentsFromMessage(message);
+		return {
+			...summarizeResult("attachments", attachments.length),
+			structuredContent: {
+				attachments,
+				message
+			}
+		};
+	});
+	server.tool("events_poll", "Poll queued Genesis conversation events since a cursor.", {
+		after_cursor: z.number().int().min(0).optional(),
+		session_key: z.string().optional(),
+		limit: z.number().int().min(1).max(200).optional()
+	}, async ({ after_cursor, session_key, limit }) => {
+		const { events, nextCursor } = bridge.pollEvents({
+			afterCursor: after_cursor ?? 0,
+			sessionKey: normalizeOptionalString(session_key)
+		}, limit ?? 20);
+		return {
+			...summarizeResult("events", events.length),
+			structuredContent: {
+				events,
+				next_cursor: nextCursor
+			}
+		};
+	});
+	server.tool("events_wait", "Wait for the next queued Genesis conversation event.", {
+		after_cursor: z.number().int().min(0).optional(),
+		session_key: z.string().optional(),
+		timeout_ms: z.number().int().min(1).max(3e5).optional()
+	}, async ({ after_cursor, session_key, timeout_ms }) => {
+		const event = await bridge.waitForEvent({
+			afterCursor: after_cursor ?? 0,
+			sessionKey: normalizeOptionalString(session_key)
+		}, timeout_ms ?? 3e4);
+		return {
+			content: [{
+				type: "text",
+				text: event ? `event ${event.cursor}` : "timeout"
+			}],
+			structuredContent: { event }
+		};
+	});
+	server.tool("messages_send", "Send a message back through the same Genesis conversation route.", {
+		session_key: z.string().min(1),
+		text: z.string().min(1)
+	}, async ({ session_key, text }) => {
+		return {
+			content: [{
+				type: "text",
+				text: "sent"
+			}],
+			structuredContent: { result: await bridge.sendMessage({
+				sessionKey: session_key,
+				text
+			}) }
+		};
+	});
+	server.tool("permissions_list_open", "List open Genesis exec or plugin approval requests visible through the Gateway.", {}, async () => {
+		const approvals = bridge.listPendingApprovals();
+		return {
+			...summarizeResult("approvals", approvals.length),
+			structuredContent: { approvals }
+		};
+	});
+	server.tool("permissions_respond", "Allow or deny one pending Genesis exec or plugin approval request.", {
+		kind: z.enum(["exec", "plugin"]),
+		id: z.string().min(1),
+		decision: z.enum([
+			"allow-once",
+			"allow-always",
+			"deny"
+		])
+	}, async ({ kind, id, decision }) => {
+		return {
+			content: [{
+				type: "text",
+				text: "approval resolved"
+			}],
+			structuredContent: { result: await bridge.respondToApproval({
+				kind,
+				id,
+				decision
+			}) }
+		};
+	});
+}
+//#endregion
+//#region src/mcp/channel-server.ts
+async function createGenesisChannelMcpServer(opts = {}) {
+	const cfg = opts.config ?? loadConfig();
+	const claudeChannelMode = opts.claudeChannelMode ?? "auto";
+	const capabilities = getChannelMcpCapabilities(claudeChannelMode);
+	const server = new McpServer({
+		name: "genesis",
+		version: VERSION
+	}, capabilities ? { capabilities } : void 0);
+	const bridge = new GenesisChannelBridge(cfg, {
+		gatewayUrl: opts.gatewayUrl,
+		gatewayToken: opts.gatewayToken,
+		gatewayPassword: opts.gatewayPassword,
+		claudeChannelMode,
+		verbose: opts.verbose ?? false
+	});
+	bridge.setServer(server);
+	server.server.setNotificationHandler(ClaudePermissionRequestSchema, async ({ params }) => {
+		await bridge.handleClaudePermissionRequest({
+			requestId: params.request_id,
+			toolName: params.tool_name,
+			description: params.description,
+			inputPreview: params.input_preview
+		});
+	});
+	registerChannelMcpTools(server, bridge);
+	return {
+		server,
+		bridge,
+		start: async () => {
+			await bridge.start();
+		},
+		close: async () => {
+			await bridge.close();
+			await server.close();
+		}
+	};
+}
+async function serveGenesisChannelMcp(opts = {}) {
+	const { server, start, close } = await createGenesisChannelMcpServer(opts);
+	const transport = new StdioServerTransport();
+	let shuttingDown = false;
+	let resolveClosed;
+	const closed = new Promise((resolve) => {
+		resolveClosed = resolve;
+	});
+	const shutdown = () => {
+		if (shuttingDown) return;
+		shuttingDown = true;
+		process.stdin.off("end", shutdown);
+		process.stdin.off("close", shutdown);
+		process.off("SIGINT", shutdown);
+		process.off("SIGTERM", shutdown);
+		transport["onclose"] = void 0;
+		close().then(resolveClosed, resolveClosed);
+	};
+	transport["onclose"] = shutdown;
+	process.stdin.once("end", shutdown);
+	process.stdin.once("close", shutdown);
+	process.once("SIGINT", shutdown);
+	process.once("SIGTERM", shutdown);
+	try {
+		await server.connect(transport);
+		await start();
+		await closed;
+	} finally {
+		shutdown();
+		await closed;
+	}
+}
+//#endregion
+//#region src/cli/mcp-cli.ts
+function fail(message) {
+	defaultRuntime.error(message);
+	defaultRuntime.exit(1);
+	throw new Error(message);
+}
+function printJson(value) {
+	defaultRuntime.writeJson(value);
+}
+function registerMcpCli(program) {
+	const mcp = program.command("mcp").description("Manage Genesis MCP config and channel bridge");
+	mcp.command("serve").description("Expose Genesis channels over MCP stdio").option("--url <url>", "Gateway WebSocket URL (defaults to gateway.remote.url when configured)").option("--token <token>", "Gateway token (if required)").option("--token-file <path>", "Read gateway token from file").option("--password <password>", "Gateway password (if required)").option("--password-file <path>", "Read gateway password from file").option("--claude-channel-mode <mode>", "Claude channel notification mode: auto, on, or off", "auto").option("-v, --verbose", "Verbose logging to stderr", false).action(async (opts) => {
+		try {
+			const { gatewayToken, gatewayPassword } = resolveGatewayAuthOptions(opts);
+			const claudeChannelMode = normalizeLowercaseStringOrEmpty(normalizeStringifiedOptionalString(opts.claudeChannelMode) ?? "auto");
+			if (claudeChannelMode !== "auto" && claudeChannelMode !== "on" && claudeChannelMode !== "off") throw new Error("Invalid --claude-channel-mode value. Use auto, on, or off.");
+			await serveGenesisChannelMcp({
+				gatewayUrl: opts.url,
+				gatewayToken,
+				gatewayPassword,
+				claudeChannelMode,
+				verbose: Boolean(opts.verbose)
+			});
+		} catch (err) {
+			defaultRuntime.error(String(err));
+			defaultRuntime.exit(1);
+		}
+	});
+	mcp.command("list").description("List configured MCP servers").option("--json", "Print JSON").action(async (opts) => {
+		const loaded = await listConfiguredMcpServers();
+		if (!loaded.ok) fail(loaded.error);
+		if (opts.json) {
+			printJson(loaded.mcpServers);
+			return;
+		}
+		const names = Object.keys(loaded.mcpServers).toSorted();
+		if (names.length === 0) {
+			defaultRuntime.log(`No MCP servers configured in ${loaded.path}.`);
+			return;
+		}
+		defaultRuntime.log(`MCP servers (${loaded.path}):`);
+		for (const name of names) defaultRuntime.log(`- ${name}`);
+	});
+	mcp.command("show").description("Show one configured MCP server or the full MCP config").argument("[name]", "MCP server name").option("--json", "Print JSON").action(async (name, opts) => {
+		const loaded = await listConfiguredMcpServers();
+		if (!loaded.ok) fail(loaded.error);
+		const value = name ? loaded.mcpServers[name] : loaded.mcpServers;
+		if (name && !value) fail(`No MCP server named "${name}" in ${loaded.path}.`);
+		if (opts.json) {
+			printJson(value ?? {});
+			return;
+		}
+		if (name) defaultRuntime.log(`MCP server "${name}" (${loaded.path}):`);
+		else defaultRuntime.log(`MCP servers (${loaded.path}):`);
+		printJson(value ?? {});
+	});
+	mcp.command("set").description("Set one configured MCP server from a JSON object").argument("<name>", "MCP server name").argument("<value>", "JSON object, for example {\"command\":\"uvx\",\"args\":[\"context7-mcp\"]}").action(async (name, rawValue) => {
+		const parsed = parseConfigValue(rawValue);
+		if (parsed.error) fail(parsed.error);
+		const result = await setConfiguredMcpServer({
+			name,
+			server: parsed.value
+		});
+		if (!result.ok) fail(result.error);
+		defaultRuntime.log(`Saved MCP server "${name}" to ${result.path}.`);
+	});
+	mcp.command("unset").description("Remove one configured MCP server").argument("<name>", "MCP server name").action(async (name) => {
+		const result = await unsetConfiguredMcpServer({ name });
+		if (!result.ok) fail(result.error);
+		if (!result.removed) fail(`No MCP server named "${name}" in ${result.path}.`);
+		defaultRuntime.log(`Removed MCP server "${name}" from ${result.path}.`);
+	});
+}
+//#endregion
+export { registerMcpCli };