pi-roundtable-mcp 0.27.1 → 0.28.0

package/CHANGELOG.md

@@ -5,6 +5,14 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.28.0] - 2026-10-31
+
+### Added
+
+- `CONNECTORS` adds, re-describes and removes connectors (`add`, `describe`, `remove`) with the rules of `/<root> connector add`: no token is no authentication, a token alone is a bearer token, a header name sends the token in that header. Refusals are `ConnectorError`s in the configured wording, now marked `refusal: true`. `ConnectorInput`, `ConnectorError` and `displayUrl` are exported.
+- `REMOTE_MCP` manages channel grants as `/<root> mcp` does: `operations`, `bundles(client)` with each channel's names, operations and recent audit, `revoke`, `describe`, `rotate` (the new URL returned once) and `authorize(client, input)` under the same channel checks: a server text or announcement channel the acting owner may manage, with the permissions behind each operation held by them and the bot. Refusals are `RemoteMcpError`s (`refusal: true`) in the configured wording; the new `operationsRequired` message refuses an empty or unknown operation choice.
+- The Discord commands and the services share one implementation of these operations.
+
 ## [0.27.1] - 2026-10-31
 
 - Release in lockstep with pi-roundtable 0.27.1; no package-specific behavior changes. The core peer range stays `>=0.27.0 <0.28.0`.

package/README.md

@@ -20,7 +20,7 @@ The package name and public API are unchanged from the standalone repository.
 ## What you need
 
 - [Bun](https://bun.sh/docs/installation) 1.4.4 or newer.
-- A running pi-roundtable host (`pi-roundtable` is a peer dependency, `>=0.27.0 <0.28.0`), with its PostgreSQL.
+- A running pi-roundtable host (`pi-roundtable` is a peer dependency, `>=0.28.0 <0.29.0`), with its PostgreSQL.
 - For `mcpConnectors`: a [ContextForge](#contextforge) gateway that you run yourself.
 - For `remoteMcp`: an HTTPS address that reaches the host's `public` listener, such as a tunnel; this is the host's `http.publicUrl`.
 
@@ -113,6 +113,12 @@ It provides the `CONNECTORS` service (`Connectors`):
 | `token` | The bearer token that the virtual servers' URLs expect; one per process, valid for a year |
 | `resolve(serverName)` | Reads one virtual server's URL and tools by name, for servers the host manages itself rather than as connectors |
 | `admin` | `gateways()` and `servers()`: what ContextForge holds, upstream gateways with their state and every virtual server with its tool names, for a host's status view |
+| `add({ name, url, description, header?, token? })` | Adds a connector as `/<root> connector add` does: no token is no authentication, a token alone is sent as `Authorization: Bearer`, and a header name sends the token in that header. The token goes to ContextForge only; the result, `{ connector, skipped }`, never holds it |
+| `describe(name, description)` | Changes a connector's purpose |
+| `remove(name)` | Deletes a connector, its virtual server, and its upstream server with its token |
+
+A refusal from `add`, `describe` or `remove` is a `ConnectorError` whose message is the configured wording, ready to show the owner; it also carries `refusal: true` for a host that does not import the class.
+`list()` returns each connector's full URL, which may hold a credential in its path or query: show the owner `displayUrl(url, unreadable)` (exported), which keeps only the scheme and host.
 
 The plugin reads the stored connectors, and resolves each one's server in ContextForge, in its `preflight`, which the host runs after every plugin is set up and before any service starts or any listener opens: during `setup` `list()`, `servers()` and `profileSources()` are empty and `version` is 0, and `version` changes once the connectors are loaded. Read them from a service's `start`, or later (a turn, a command, a request); no command or turn arrives before they are loaded. `resolve(serverName)` and `token` work from setup. A host's `Roundtable.check()` runs no preflight, so it needs neither the database nor ContextForge. The runtime's startup tool probe runs before this preflight, so it does not see the connectors' servers: a `requiredTools` entry that only a connector's server provides fails the start; the first real session connects to them instead.
 The plugin does not decide which agent uses which connector.
@@ -208,6 +214,14 @@ The plugin provides the `REMOTE_MCP` service (`RemoteMcpService`) for a host tha
 | --- | --- |
 | `grants` | `bundles()` and `grants(bundleId?)`, read only: every bundle, and the channel grants of one bundle or of all |
 | `describeGrant(client, grant)` | One grant as lines of text for a Discord message: the name the agent sees, where the channel is, its purpose, and the allowed operations, in the plugin's wording |
+| `operations` | Every operation a grant may allow, `{ id, label }`, in order |
+| `bundles(client)` | Every bundle with its channels: names (Discord's current ones, or the last known when the bot cannot see the channel), the name and purpose the agent sees, operations, and each channel's recent audit entries |
+| `revoke(bundle, channelId)` | Removes a channel from a bundle |
+| `describe(bundle, channelId, { displayName?, description? })` | Changes the channel name and purpose that the agent sees |
+| `rotate(bundle)` | Replaces a bundle's MCP URL and returns `{ url }`, this once; only its hash is kept |
+| `authorize(client, { bundle, channelId, userId, operations, displayName?, description? })` | Adds a channel to a bundle, creating the bundle when it does not exist, with the checks `/<root> mcp authorize` makes: a server text or announcement channel that `userId`, the acting owner's Discord ID, may manage, with the permissions behind each operation held by them and the bot. A new bundle's URL is in the result this once |
+
+A refusal from these is a `RemoteMcpError` whose message is the configured wording; it also carries `refusal: true`.
 
 #### `ChannelGrantStore`
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-roundtable-mcp",
-	"version": "0.27.1",
+	"version": "0.28.0",
 	"description": "MCP connectors through ContextForge and a remote MCP endpoint for pi-roundtable",
 	"type": "module",
 	"license": "MIT",
@@ -40,12 +40,12 @@
 		"typebox": "1.3.37"
 	},
 	"peerDependencies": {
-		"pi-roundtable": ">=0.27.0 <0.28.0"
+		"pi-roundtable": ">=0.28.0 <0.29.0"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.5.15",
 		"@types/bun": "1.4.3",
-		"pi-roundtable": "0.27.1",
+		"pi-roundtable": "0.28.0",
 		"typescript": "7.0.2"
 	}
 }

package/src/connectors/connector-commands.ts

@@ -20,12 +20,12 @@ import {
 	plain,
 	replyWithPanels,
 } from "pi-roundtable/discord";
+import { authFrom, displayUrl } from "./connector-input.ts";
 import {
 	type Connector,
 	ConnectorError,
 	type ConnectorRegistry,
 } from "./connector-registry.ts";
-import type { UpstreamAuth } from "./contextforge.ts";
 import type { ConnectorMessages } from "./messages.ts";
 
 export const CONNECTOR_MODAL_ID = "rtmcp:connector:add";
@@ -38,7 +38,6 @@ const FIELD = {
 	token: "token",
 } as const;
 
-const HEADER_NAME = /^[A-Za-z0-9-]{1,100}$/;
 const TOOL_PREVIEW = 12;
 
 function connectorGroup(text: ConnectorMessages) {
@@ -137,33 +136,6 @@ export function connectorModal(text: ConnectorMessages): ModalBuilder {
 		);
 }
 
-function authFrom(
-	header: string,
-	token: string,
-	text: ConnectorMessages,
-): UpstreamAuth {
-	if (!token) {
-		if (header) throw new OwnerFacingError(text.headerNeedsToken);
-		return { type: "none" };
-	}
-	if (!header) return { type: "bearer", token };
-	if (!HEADER_NAME.test(header)) throw new OwnerFacingError(text.headerRule);
-	return { type: "header", name: header, value: token };
-}
-
-/** Scheme and host only: some servers take their credential in the path, query, or user part. */
-export function displayUrl(url: string, unreadable: string): string {
-	const parsed = URL.parse(url);
-	if (!parsed) return unreadable;
-	const hidden =
-		parsed.pathname !== "/" ||
-		parsed.search ||
-		parsed.hash ||
-		parsed.username ||
-		parsed.password;
-	return `${parsed.origin}${hidden ? "/…" : ""}`;
-}
-
 function section(connector: Connector, text: ConnectorMessages): string {
 	const tools = connector.server?.tools ?? [];
 	const listed = tools

package/src/connectors/connector-input.ts

@@ -0,0 +1,34 @@
+import { ConnectorError, type NewConnector } from "./connector-registry.ts";
+import type { ConnectorMessages } from "./messages.ts";
+
+type UpstreamAuth = NewConnector["auth"];
+
+const HEADER_NAME = /^[A-Za-z0-9-]{1,100}$/;
+
+/** How a new connector authenticates upstream: no token is none, a token alone is a bearer token, a header name sends the token in that header. */
+export function authFrom(
+	header: string,
+	token: string,
+	text: ConnectorMessages,
+): UpstreamAuth {
+	if (!token) {
+		if (header) throw new ConnectorError(text.headerNeedsToken);
+		return { type: "none" };
+	}
+	if (!header) return { type: "bearer", token };
+	if (!HEADER_NAME.test(header)) throw new ConnectorError(text.headerRule);
+	return { type: "header", name: header, value: token };
+}
+
+/** Scheme and host only: some servers take their credential in the path, query, or user part. */
+export function displayUrl(url: string, unreadable: string): string {
+	const parsed = URL.parse(url);
+	if (!parsed) return unreadable;
+	const hidden =
+		parsed.pathname !== "/" ||
+		parsed.search ||
+		parsed.hash ||
+		parsed.username ||
+		parsed.password;
+	return `${parsed.origin}${hidden ? "/…" : ""}`;
+}

package/src/connectors/connector-registry.ts

@@ -16,7 +16,10 @@ export const DEFAULT_MAX_TOOL_NAME = 45;
 export const DEFAULT_SERVER_PREFIX = "roundtable-conn-";
 
 /** A request the owner can fix; the message is shown to the owner as is. */
-export class ConnectorError extends Error {}
+export class ConnectorError extends Error {
+	/** Marks the error as one whose message the owner reads, for a host that does not know this class. */
+	readonly refusal = true;
+}
 
 export interface Connector {
 	name: string;

package/src/connectors/connectors-plugin.ts

@@ -7,6 +7,7 @@ import {
 import { DISCORD } from "pi-roundtable/discord";
 import type { VirtualServer } from "pi-roundtable/kit";
 import { connectorCommands } from "./connector-commands.ts";
+import { authFrom } from "./connector-input.ts";
 import {
 	type Connector,
 	type ConnectorProfileSource,
@@ -58,6 +59,49 @@ export interface Connectors {
 	resolve(serverName: string): Promise<VirtualServer>;
 	/** What ContextForge holds, upstream gateways and virtual servers, for a host's status view. */
 	readonly admin: Pick<ContextForgeAdmin, "gateways" | "servers">;
+	/**
+	 * Adds a connector as `/<root> connector add` does. No token is no authentication, a token alone
+	 * is sent as `Authorization: Bearer`, and a header name sends the token in that header. The
+	 * token goes to ContextForge only; nothing returned holds it. A refusal is a `ConnectorError`.
+	 */
+	add(
+		input: ConnectorInput,
+	): Promise<{ connector: Connector; skipped: string[] }>;
+	/** Changes a connector's purpose; a refusal is a `ConnectorError`. */
+	describe(name: string, description: string): Promise<Connector>;
+	/** Deletes a connector, its virtual server, and its upstream server with its token. */
+	remove(name: string): Promise<void>;
+}
+
+/** A new connector as the owner gives it; `header` and `token` are optional. */
+export interface ConnectorInput {
+	name: string;
+	url: string;
+	description: string;
+	header?: string;
+	token?: string;
+}
+
+/** The registry's management, with the header and token rules of the Discord form. */
+export function connectorManagement(
+	registry: Pick<ConnectorRegistry, "add" | "describe" | "remove">,
+	text: ConnectorMessages,
+): Pick<Connectors, "add" | "describe" | "remove"> {
+	return {
+		add: async (input) =>
+			registry.add({
+				name: input.name.trim(),
+				url: input.url.trim(),
+				description: input.description.trim(),
+				auth: authFrom(
+					input.header?.trim() ?? "",
+					input.token?.trim() ?? "",
+					text,
+				),
+			}),
+		describe: (name, description) => registry.describe(name, description),
+		remove: (name) => registry.remove(name),
+	};
 }
 
 export const CONNECTORS = serviceKey<Connectors>(
@@ -123,6 +167,7 @@ export function mcpConnectors(options: McpConnectorsOptions): RoundtablePlugin {
 					gateways: () => admin.gateways(),
 					servers: () => admin.servers(),
 				},
+				...connectorManagement(registry, text),
 			});
 			// Nothing is added but what preflight reads.
 			load = () => registry.load();

package/src/index.ts

@@ -1,11 +1,14 @@
 // The package's one entry: two plugins, their options, and the service the connectors plugin provides.
 
+export { displayUrl } from "./connectors/connector-input.ts";
 export type {
 	Connector,
 	ConnectorProfileSource,
 	NewConnector,
 } from "./connectors/connector-registry.ts";
+export { ConnectorError } from "./connectors/connector-registry.ts";
 export type {
+	ConnectorInput,
 	Connectors,
 	ContextForgeOptions,
 	McpConnectorsOptions,
@@ -18,6 +21,12 @@ export type {
 	ChannelGrant,
 } from "./remote-mcp/channel-grants.ts";
 export { ChannelGrantStore } from "./remote-mcp/channel-grants.ts";
+export type {
+	Authorized,
+	AuthorizeInput,
+	BundleView,
+	GrantView,
+} from "./remote-mcp/grant-operations.ts";
 export type {
 	RemoteMcpMessages,
 	RemoteToolNames,
@@ -30,4 +39,7 @@ export type {
 } from "./remote-mcp/remote-mcp-plugin.ts";
 export { remoteMcp } from "./remote-mcp/remote-mcp-plugin.ts";
 export type { RemoteMcpService } from "./remote-mcp/remote-mcp-service.ts";
-export { REMOTE_MCP } from "./remote-mcp/remote-mcp-service.ts";
+export {
+	REMOTE_MCP,
+	RemoteMcpError,
+} from "./remote-mcp/remote-mcp-service.ts";

package/src/remote-mcp/grant-operations.ts

@@ -0,0 +1,240 @@
+import type { Client } from "discord.js";
+import {
+	type ChannelOperation,
+	fetchManagedChannel,
+	isChannelOperation,
+	type ManagedChannel,
+	OwnerFacingError,
+} from "pi-roundtable/discord";
+import {
+	type ChannelAudit,
+	type ChannelBundle,
+	type ChannelGrant,
+	type ChannelGrantStore,
+	newChannelEndpoint,
+} from "./channel-grants.ts";
+import { managedChannel } from "./mcp-grant-panels.ts";
+import type { RemoteMcpMessages } from "./messages.ts";
+
+/** One channel of a bundle, with where it is now and its recent audit entries. */
+export interface GrantView {
+	channelId: string;
+	guildId: string;
+	/** The server and channel names Discord gives now, or the last known ones when it cannot be fetched. */
+	guildName: string;
+	channelName: string;
+	/** False when the bot cannot see the channel now. */
+	visible: boolean;
+	displayName: string;
+	description: string;
+	operations: ChannelOperation[];
+	authorizedAt: Date;
+	audit: ChannelAudit[];
+}
+
+export interface BundleView {
+	name: string;
+	defaultOperations: ChannelOperation[];
+	grants: GrantView[];
+}
+
+/** A channel to add to a bundle, by the person who authorizes it. */
+export interface AuthorizeInput {
+	bundle: string;
+	channelId: string;
+	/** The authorizing owner's Discord user ID; they must be able to manage the channel. */
+	userId: string;
+	operations: readonly string[];
+	displayName?: string;
+	description?: string;
+}
+
+export interface Authorized {
+	bundle: string;
+	channelName: string;
+	operations: ChannelOperation[];
+	/** The bundle's new MCP URL, present only when this created the bundle; shown once. */
+	url?: string;
+}
+
+const CHANNEL_ID = /^\d{1,20}$/;
+
+/**
+ * What `/<root> mcp` and the `REMOTE_MCP` service both do to the owner's bundles, with the same
+ * checks. A refusal is an `OwnerFacingError` in the configured wording.
+ */
+export class GrantOperations {
+	readonly #grants: ChannelGrantStore;
+	readonly #publicUrl: string;
+	readonly #root: string;
+	readonly #text: RemoteMcpMessages;
+	readonly #quote: (name: string) => string;
+
+	/** `quote` readies a name for a refusal's text, such as Discord's markdown escaping. */
+	constructor(
+		grants: ChannelGrantStore,
+		publicUrl: string,
+		root: string,
+		text: RemoteMcpMessages,
+		quote: (name: string) => string = (name) => name,
+	) {
+		this.#grants = grants;
+		this.#publicUrl = publicUrl;
+		this.#root = root;
+		this.#text = text;
+		this.#quote = quote;
+	}
+
+	/** The named bundle; refuses one that does not exist. */
+	async bundle(name: string): Promise<ChannelBundle> {
+		const bundle = await this.#grants.bundleByName(name.trim());
+		if (!bundle)
+			throw new OwnerFacingError(
+				this.#text.noBundle(this.#quote(name.trim()), this.#root),
+			);
+		return bundle;
+	}
+
+	/** Refuses anything but a channel ID. */
+	channelId(channelId: string): string {
+		const id = channelId.trim();
+		if (!CHANNEL_ID.test(id))
+			throw new OwnerFacingError(this.#text.channelIdRule);
+		return id;
+	}
+
+	/** Every bundle with its channels and each channel's recent audit entries. */
+	async bundles(client: Client): Promise<BundleView[]> {
+		const [bundles, grants] = await Promise.all([
+			this.#grants.bundles(),
+			this.#grants.grants(),
+		]);
+		return Promise.all(
+			bundles.map(async (bundle) => ({
+				name: bundle.name,
+				defaultOperations: bundle.defaultOperations,
+				grants: await Promise.all(
+					grants
+						.filter((g) => g.bundleId === bundle.id)
+						.map((g) => this.#grantView(client, g)),
+				),
+			})),
+		);
+	}
+
+	/** Resolves false when the channel was not in the bundle. */
+	async revoke(bundle: ChannelBundle, channelId: string): Promise<boolean> {
+		return this.#grants.revoke(bundle.id, channelId);
+	}
+
+	/** Changes the name and purpose an agent sees; resolves false when the channel is not in the bundle. */
+	async describe(
+		bundle: ChannelBundle,
+		channelId: string,
+		change: { displayName?: string; description?: string },
+	): Promise<boolean> {
+		const displayName = change.displayName?.trim();
+		const description = change.description?.trim();
+		if (displayName === undefined && description === undefined)
+			throw new OwnerFacingError(this.#text.nameOrDescription);
+		return this.#grants.describe(bundle.id, channelId, {
+			...(displayName === undefined ? {} : { displayName }),
+			...(description === undefined ? {} : { description }),
+		});
+	}
+
+	/** Replaces the bundle's URL; the new one is returned this once and only its hash is kept. */
+	async rotate(bundleId: string): Promise<string> {
+		const endpoint = newChannelEndpoint(this.#publicUrl);
+		await this.#grants.rotateToken(bundleId, endpoint.tokenHash);
+		return endpoint.url;
+	}
+
+	/** Refuses a bundle name the flow would not take. */
+	bundleName(name: string): string {
+		const trimmed = name.trim();
+		if (!trimmed || trimmed.length > 80)
+			throw new OwnerFacingError(this.#text.bundleNameRule);
+		return trimmed;
+	}
+
+	/** Refuses an empty choice or an operation that is not one. */
+	operations(operations: readonly string[]): ChannelOperation[] {
+		const chosen = operations.filter(isChannelOperation);
+		if (chosen.length === 0 || chosen.length !== operations.length)
+			throw new OwnerFacingError(this.#text.operationsRequired);
+		return [...new Set(chosen)];
+	}
+
+	/**
+	 * Adds the channel to the bundle, creating the bundle when it does not exist, or replaces its
+	 * grant there. The channel must be one the user may manage, and the user and the bot must both
+	 * hold the permissions behind each operation.
+	 */
+	async authorize(
+		client: Client,
+		input: Omit<AuthorizeInput, "operations"> & {
+			operations: ChannelOperation[];
+		},
+	): Promise<Authorized & { channel: ManagedChannel; created: boolean }> {
+		const channel = await managedChannel(
+			client,
+			input.channelId,
+			input.userId,
+			input.operations,
+			this.#text,
+		);
+		const endpoint = newChannelEndpoint(this.#publicUrl);
+		const { bundle, created } = await this.#grants.ensureBundle(
+			input.bundle,
+			endpoint.tokenHash,
+			input.operations,
+		);
+		const existing = await this.#grants.grant(bundle.id, channel.id);
+		await this.#grants.save({
+			bundleId: bundle.id,
+			channelId: channel.id,
+			guildId: channel.guildId,
+			operations: input.operations,
+			displayName: input.displayName || existing?.displayName || channel.name,
+			description: input.description || existing?.description || "",
+			guildName: channel.guild.name,
+			channelName: channel.name,
+			authorizedBy: input.userId,
+			authorizedAt: new Date(),
+		});
+		return {
+			bundle: bundle.name,
+			channelName: channel.name,
+			operations: input.operations,
+			channel,
+			created,
+			...(created ? { url: endpoint.url } : {}),
+		};
+	}
+
+	async #grantView(client: Client, grant: ChannelGrant): Promise<GrantView> {
+		let guildName = grant.guildName;
+		let channelName = grant.channelName;
+		let visible = true;
+		try {
+			const channel = await fetchManagedChannel(client, grant.channelId);
+			guildName = channel.guild.name;
+			channelName = channel.name;
+		} catch {
+			visible = false;
+		}
+		return {
+			channelId: grant.channelId,
+			guildId: grant.guildId,
+			guildName,
+			channelName,
+			visible,
+			displayName: grant.displayName,
+			description: grant.description,
+			operations: grant.operations,
+			authorizedAt: grant.authorizedAt,
+			audit: await this.#grants.recentAudit(grant.channelId),
+		};
+	}
+}

package/src/remote-mcp/mcp-grant-flow.ts

@@ -13,10 +13,8 @@ import {
 	plain,
 	replyWithPanels,
 } from "pi-roundtable/discord";
-import {
-	type ChannelGrantStore,
-	newChannelEndpoint,
-} from "./channel-grants.ts";
+import type { ChannelBundle, ChannelGrantStore } from "./channel-grants.ts";
+import { GrantOperations } from "./grant-operations.ts";
 import {
 	authorizePanel,
 	describeGrant,
@@ -37,7 +35,7 @@ type ButtonOrMenu = ButtonInteraction | StringSelectMenuInteraction;
  */
 export class McpGrantFlow {
 	readonly #grants: ChannelGrantStore;
-	readonly #publicUrl: string;
+	readonly #ops: GrantOperations;
 	readonly #root: string;
 	readonly #text: RemoteMcpMessages;
 	readonly #pending = new Map<string, Pending>();
@@ -49,7 +47,7 @@ export class McpGrantFlow {
 		text: RemoteMcpMessages,
 	) {
 		this.#grants = grants;
-		this.#publicUrl = publicUrl;
+		this.#ops = new GrantOperations(grants, publicUrl, root, text, plain);
 		this.#root = root;
 		this.#text = text;
 	}
@@ -85,9 +83,7 @@ export class McpGrantFlow {
 		const bundleName = interaction.options.getString("bundle", true).trim();
 		if (sub === "authorize")
 			return this.#beginAuthorize(interaction, bundleName);
-		const bundle = await this.#grants.bundleByName(bundleName);
-		if (!bundle)
-			throw new OwnerFacingError(text.noBundle(plain(bundleName), this.#root));
+		const bundle = await this.#ops.bundle(bundleName);
 		if (sub === "token") {
 			const id = this.#hold(interaction, {
 				bundleName: bundle.name,
@@ -98,14 +94,12 @@ export class McpGrantFlow {
 			await interaction.editReply(rotatePanel(bundle.name, id, text));
 			return;
 		}
-		const channelId =
-			interaction.options.getString("channel_id")?.trim() ??
-			interaction.channelId;
-		if (!/^\d{1,20}$/.test(channelId))
-			throw new OwnerFacingError(text.channelIdRule);
+		const channelId = this.#ops.channelId(
+			interaction.options.getString("channel_id") ?? interaction.channelId,
+		);
 		if (sub === "describe")
 			return this.#describe(interaction, bundle, channelId);
-		const removed = await this.#grants.revoke(bundle.id, channelId);
+		const removed = await this.#ops.revoke(bundle, channelId);
 		for (const [id, value] of this.#pending)
 			if (value.channelId === channelId) this.#pending.delete(id);
 		await interaction.editReply(
@@ -174,15 +168,14 @@ export class McpGrantFlow {
 
 	async #describe(
 		interaction: ChatInputCommandInteraction,
-		bundle: { id: string; name: string },
+		bundle: ChannelBundle,
 		channelId: string,
 	): Promise<void> {
 		const text = this.#text;
-		const displayName = interaction.options.getString("name")?.trim();
-		const description = interaction.options.getString("description")?.trim();
-		if (displayName === undefined && description === undefined)
-			throw new OwnerFacingError(text.nameOrDescription);
-		const changed = await this.#grants.describe(bundle.id, channelId, {
+		const displayName = interaction.options.getString("name") ?? undefined;
+		const description =
+			interaction.options.getString("description") ?? undefined;
+		const changed = await this.#ops.describe(bundle, channelId, {
 			...(displayName === undefined ? {} : { displayName }),
 			...(description === undefined ? {} : { description }),
 		});
@@ -202,14 +195,13 @@ export class McpGrantFlow {
 		bundleId: string,
 	): Promise<void> {
 		const text = this.#text;
-		const endpoint = newChannelEndpoint(this.#publicUrl);
-		await this.#grants.rotateToken(bundleId, endpoint.tokenHash);
+		const url = await this.#ops.rotate(bundleId);
 		await interaction.editReply(
 			ownerPanel({
 				title: text.rotatedTitle,
 				sections: [
 					text.rotated(plain(pending.bundleName)),
-					text.urlSection(endpoint.url),
+					text.urlSection(url),
 				],
 				footer: text.urlFooter,
 			}),
@@ -221,8 +213,7 @@ export class McpGrantFlow {
 		bundleName: string,
 	): Promise<void> {
 		const text = this.#text;
-		if (!bundleName || bundleName.length > 80)
-			throw new OwnerFacingError(text.bundleNameRule);
+		this.#ops.bundleName(bundleName);
 		await managedChannel(
 			interaction.client,
 			interaction.channelId,
@@ -257,44 +248,26 @@ export class McpGrantFlow {
 
 	async #confirm(interaction: ButtonOrMenu, pending: Pending): Promise<void> {
 		const text = this.#text;
-		const channel = await managedChannel(
-			interaction.client,
-			pending.channelId,
-			pending.userId,
-			pending.operations,
-			text,
-		);
-		const endpoint = newChannelEndpoint(this.#publicUrl);
-		const { bundle, created } = await this.#grants.ensureBundle(
-			pending.bundleName,
-			endpoint.tokenHash,
-			pending.operations,
-		);
-		const existing = await this.#grants.grant(bundle.id, channel.id);
-		await this.#grants.save({
-			bundleId: bundle.id,
-			channelId: channel.id,
-			guildId: channel.guildId,
+		const done = await this.#ops.authorize(interaction.client, {
+			bundle: pending.bundleName,
+			channelId: pending.channelId,
+			userId: pending.userId,
 			operations: pending.operations,
-			displayName: pending.displayName ?? existing?.displayName ?? channel.name,
-			description: pending.description ?? existing?.description ?? "",
-			guildName: channel.guild.name,
-			channelName: channel.name,
-			authorizedBy: pending.userId,
-			authorizedAt: new Date(),
+			...(pending.displayName ? { displayName: pending.displayName } : {}),
+			...(pending.description ? { description: pending.description } : {}),
 		});
 		await interaction.editReply(
 			ownerPanel({
 				title: text.grantedTitle,
 				sections: [
 					text.granted(
-						plain(channel.name),
-						plain(bundle.name),
-						opLabels(pending.operations, text),
+						plain(done.channelName),
+						plain(done.bundle),
+						opLabels(done.operations, text),
 					),
-					created ? text.urlSection(endpoint.url) : text.existingUrl,
+					done.url ? text.urlSection(done.url) : text.existingUrl,
 				],
-				footer: created ? text.urlFooter : text.urlLostFooter(this.#root),
+				footer: done.url ? text.urlFooter : text.urlLostFooter(this.#root),
 			}),
 		);
 	}

package/src/remote-mcp/messages.ts

@@ -79,6 +79,8 @@ export interface RemoteMcpMessages {
 	rotated(bundle: string): string;
 	urlFooter: string;
 	bundleNameRule: string;
+	/** Refuses an authorization with no operation chosen, or one that is not an operation. */
+	operationsRequired: string;
 	grantedTitle: string;
 	granted(channel: string, bundle: string, operations: string): string;
 	existingUrl: string;
@@ -187,6 +189,7 @@ export const REMOTE_MCP_MESSAGES: RemoteMcpMessages = {
 	urlFooter:
 		"This URL is the access credential and is shown only this once; only its hash is stored.",
 	bundleNameRule: "A bundle name needs 1 to 80 characters.",
+	operationsRequired: "Choose one or more of the allowed operations.",
 	grantedTitle: "Authorized",
 	granted: (channel, bundle, operations) =>
 		`**#${channel}** was added to bundle **${bundle}**, allowing: ${operations}.`,

package/src/remote-mcp/remote-mcp-plugin.ts

@@ -212,7 +212,10 @@ export function remoteMcp(options: RemoteMcpOptions): RoundtablePlugin {
 			discord.commands.add(
 				mcpGrantCommands(discord.guard, grants, options.publicUrl, text),
 			);
-			services.provide(REMOTE_MCP, remoteMcpService(grants, text));
+			services.provide(
+				REMOTE_MCP,
+				remoteMcpService(grants, text, options.publicUrl, discord.guard.root),
+			);
 			// Read before any service starts, by `preflight` above.
 			adopt = async () => {
 				found = await boundPrincipal(identities, identity);

package/src/remote-mcp/remote-mcp-service.ts

@@ -1,31 +1,120 @@
 import type { Client } from "discord.js";
 import { serviceKey } from "pi-roundtable";
+import {
+	CHANNEL_OPERATIONS,
+	type ChannelOperation,
+	OwnerFacingError,
+	operationLabel,
+} from "pi-roundtable/discord";
 import type { ChannelGrant, ChannelGrantStore } from "./channel-grants.ts";
+import {
+	type Authorized,
+	type AuthorizeInput,
+	type BundleView,
+	GrantOperations,
+} from "./grant-operations.ts";
 import { describeGrant } from "./mcp-grant-panels.ts";
 import type { RemoteMcpMessages } from "./messages.ts";
 
-/** What a host reads to show the owner which channels outside agents may use. */
+/** A refusal the owner can act on, in the configured wording; `refusal` marks it for a host that does not know this class. */
+export class RemoteMcpError extends Error {
+	readonly refusal = true;
+}
+
+/** What a host reads to show the owner which channels outside agents may use, and to manage them as `/<root> mcp` does. */
 export interface RemoteMcpService {
 	/** The owner's bundles and their channel grants, read only. */
 	grants: Pick<ChannelGrantStore, "bundles" | "grants">;
 	/** One grant as lines of text: the agent's name for the channel, where it is, its purpose, and the allowed operations. */
 	describeGrant(client: Client, grant: ChannelGrant): Promise<string>;
+	/** Every operation a grant may allow, in order, with its label. */
+	readonly operations: readonly { id: ChannelOperation; label: string }[];
+	/** Every bundle with its channels, their operations, and each channel's recent audit entries. */
+	bundles(client: Client): Promise<BundleView[]>;
+	/** Removes a channel from a bundle; refuses an unknown bundle or a channel not in it. */
+	revoke(bundle: string, channelId: string): Promise<void>;
+	/** Changes the channel name and purpose an agent sees; give either or both. */
+	describe(
+		bundle: string,
+		channelId: string,
+		change: { displayName?: string; description?: string },
+	): Promise<void>;
+	/** Replaces a bundle's MCP URL; the new URL is returned this once and only its hash is kept. */
+	rotate(bundle: string): Promise<{ url: string }>;
+	/**
+	 * Adds a channel to a bundle with the chosen operations, creating the bundle when it does not
+	 * exist, under the checks `/<root> mcp authorize` makes: the channel is a server text or
+	 * announcement channel, `userId` (the acting owner's Discord ID) may manage it, and they and
+	 * the bot both hold the permissions behind each operation. A new bundle's URL is in the result
+	 * this once.
+	 */
+	authorize(client: Client, input: AuthorizeInput): Promise<Authorized>;
 }
 
 export const REMOTE_MCP = serviceKey<RemoteMcpService>(
 	"pi-roundtable-mcp.remote-mcp",
 );
 
+/** The flow's refusals, as this service's. */
+async function refused<T>(call: () => Promise<T>): Promise<T> {
+	try {
+		return await call();
+	} catch (error) {
+		if (error instanceof OwnerFacingError)
+			throw new RemoteMcpError(error.message);
+		throw error;
+	}
+}
+
 /** The service over the plugin's grant store and its wording. */
 export function remoteMcpService(
 	grants: ChannelGrantStore,
 	text: RemoteMcpMessages,
+	publicUrl: string,
+	root: string,
 ): RemoteMcpService {
+	const ops = new GrantOperations(grants, publicUrl, root, text);
 	return {
 		grants: {
 			bundles: () => grants.bundles(),
 			grants: (...args) => grants.grants(...args),
 		},
 		describeGrant: (client, grant) => describeGrant(client, grant, text),
+		operations: CHANNEL_OPERATIONS.map((id) => ({
+			id,
+			label: operationLabel(id),
+		})),
+		bundles: (client) => ops.bundles(client),
+		revoke: (bundle, channelId) =>
+			refused(async () => {
+				const found = await ops.bundle(bundle);
+				if (!(await ops.revoke(found, ops.channelId(channelId))))
+					throw new OwnerFacingError(text.revokeNotInBundle(found.name));
+			}),
+		describe: (bundle, channelId, change) =>
+			refused(async () => {
+				const found = await ops.bundle(bundle);
+				if (!(await ops.describe(found, ops.channelId(channelId), change)))
+					throw new OwnerFacingError(text.notInBundle(found.name));
+			}),
+		rotate: (bundle) =>
+			refused(async () => ({
+				url: await ops.rotate((await ops.bundle(bundle)).id),
+			})),
+		authorize: (client, input) =>
+			refused(async () => {
+				const done = await ops.authorize(client, {
+					...input,
+					bundle: ops.bundleName(input.bundle),
+					channelId: ops.channelId(input.channelId),
+					operations: ops.operations(input.operations),
+				});
+				return {
+					bundle: done.bundle,
+					channelName: done.channelName,
+					operations: done.operations,
+					...(done.url ? { url: done.url } : {}),
+				};
+			}),
 	};
 }