@tuan_son.dinh/gsd 2.6.0

package/src/resources/extensions/mcporter/index.ts

@@ -0,0 +1,429 @@
+/**
+ * MCPorter Extension — Lazy MCP server integration for pi
+ *
+ * Provides on-demand access to all MCP servers configured on the system
+ * (via Claude Desktop, Cursor, VS Code, mcporter config, etc.) without
+ * registering every tool upfront. This keeps token usage near-zero until
+ * the agent actually needs an MCP tool.
+ *
+ * Three tools:
+ *   mcp_servers   — List available MCP servers (cached after first call)
+ *   mcp_discover  — Get tool signatures for a specific server
+ *   mcp_call      — Call a tool on an MCP server
+ *
+ * Requirements:
+ *   - mcporter installed globally: npm i -g mcporter
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import {
+	truncateHead,
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	formatSize,
+} from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { execFile, exec } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const execAsync = promisify(exec);
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+interface McpServer {
+	name: string;
+	status: string;
+	transport?: string;
+	tools: { name: string; description: string }[];
+}
+
+interface McpListResponse {
+	mode: string;
+	counts: { ok: number; auth: number; offline: number; http: number; error: number };
+	servers: McpServer[];
+}
+
+interface McpToolSchema {
+	name: string;
+	description: string;
+	inputSchema?: Record<string, unknown>;
+}
+
+interface McpServerDetail {
+	name: string;
+	status: string;
+	tools: McpToolSchema[];
+}
+
+// ─── Cache ────────────────────────────────────────────────────────────────────
+
+let serverListCache: McpServer[] | null = null;
+const serverDetailCache = new Map<string, McpServerDetail>();
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function escapeShellArg(arg: string): string {
+	if (process.platform === "win32") {
+		return `"${arg.replace(/"/g, '""')}"`;
+	}
+	return `'${arg.replace(/'/g, "'\\''")}'`;
+}
+
+async function runMcporter(
+	args: string[],
+	signal?: AbortSignal,
+	timeoutMs = 30000,
+): Promise<string> {
+	// Cross-platform: use execFile on Windows to avoid quote handling issues
+	// On Windows, cmd.exe doesn't strip single quotes like Unix shells do
+	if (process.platform === "win32") {
+		const { stdout } = await execFileAsync("mcporter", args, {
+			timeout: timeoutMs,
+			maxBuffer: 1024 * 1024,
+			signal,
+			env: { ...process.env },
+			shell: true,
+		});
+		return stdout;
+	}
+	// Use shell exec so PATH resolution works on Unix
+	const escaped = args.map((a) => escapeShellArg(a)).join(" ");
+	const { stdout } = await execAsync(`mcporter ${escaped}`, {
+		timeout: timeoutMs,
+		maxBuffer: 1024 * 1024,
+		signal,
+		env: { ...process.env },
+	});
+	return stdout;
+}
+
+async function getServerList(signal?: AbortSignal): Promise<McpServer[]> {
+	if (serverListCache) return serverListCache;
+
+	const raw = await runMcporter(["list", "--json"], signal, 60000);
+	let data: McpListResponse;
+	try {
+		data = JSON.parse(raw) as McpListResponse;
+	} catch (e) {
+		throw new Error(`Failed to parse mcporter output: ${raw.slice(0, 300)}`);
+	}
+	if (!Array.isArray(data.servers)) {
+		throw new Error(`Unexpected mcporter response shape: ${JSON.stringify(Object.keys(data))}`);
+	}
+	serverListCache = data.servers;
+	return serverListCache;
+}
+
+async function getServerDetail(
+	serverName: string,
+	signal?: AbortSignal,
+): Promise<McpServerDetail> {
+	if (serverDetailCache.has(serverName)) return serverDetailCache.get(serverName)!;
+
+	const raw = await runMcporter(["list", serverName, "--schema", "--json"], signal);
+	const data = JSON.parse(raw) as McpServerDetail;
+	serverDetailCache.set(serverName, data);
+	return data;
+}
+
+function formatServerList(servers: McpServer[]): string {
+	if (servers.length === 0) return "No MCP servers found.";
+
+	const lines: string[] = [`${servers.length} MCP servers available:\n`];
+
+	for (const s of servers) {
+		const tools = s.tools ?? [];
+		const status = s.status === "ok" ? "✓" : s.status === "auth" ? "🔑" : "✗";
+		lines.push(`${status} ${s.name} — ${tools.length} tools (${s.status})`);
+		for (const t of tools) {
+			lines.push(`    ${t.name}: ${t.description?.slice(0, 100) ?? ""}`);
+		}
+	}
+
+	lines.push("\nUse mcp_discover to see full tool schemas for a specific server.");
+	lines.push("Use mcp_call to invoke a tool: mcp_call(server, tool, args).");
+	return lines.join("\n");
+}
+
+function formatServerDetail(detail: McpServerDetail): string {
+	const lines: string[] = [`${detail.name} — ${detail.tools.length} tools:\n`];
+
+	for (const tool of detail.tools) {
+		lines.push(`## ${tool.name}`);
+		if (tool.description) lines.push(tool.description);
+		if (tool.inputSchema) {
+			lines.push("```json");
+			lines.push(JSON.stringify(tool.inputSchema, null, 2));
+			lines.push("```");
+		}
+		lines.push("");
+	}
+
+	lines.push(`Call with: mcp_call(server="${detail.name}", tool="<tool_name>", args={...})`);
+	return lines.join("\n");
+}
+
+// ─── Extension ────────────────────────────────────────────────────────────────
+
+export default function (pi: ExtensionAPI) {
+	// ── mcp_servers ──────────────────────────────────────────────────────────
+
+	pi.registerTool({
+		name: "mcp_servers",
+		label: "MCP Servers",
+		description:
+			"List all available MCP servers discovered from your system (Claude Desktop, Cursor, VS Code, mcporter config). " +
+			"Shows server names, status, and tool counts. Use mcp_discover to get full tool schemas for a server.",
+		promptSnippet:
+			"List available MCP servers and their tools (lazy discovery via mcporter)",
+		promptGuidelines: [
+			"Call mcp_servers to see what MCP servers are available before trying to use one.",
+			"MCP servers provide external integrations (Twitter, Linear, Railway, etc.) via the Model Context Protocol.",
+			"After listing, use mcp_discover(server) to get tool schemas, then mcp_call(server, tool, args) to invoke.",
+		],
+		parameters: Type.Object({
+			refresh: Type.Optional(
+				Type.Boolean({ description: "Force refresh the server list (default: use cache)" }),
+			),
+		}),
+
+		async execute(_id, params, signal) {
+			if (params.refresh) serverListCache = null;
+
+			try {
+				const servers = await getServerList(signal);
+				return {
+					content: [{ type: "text", text: formatServerList(servers) }],
+					details: {
+						serverCount: servers.length,
+						cached: !params.refresh && serverListCache !== null,
+					},
+				};
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				throw new Error(
+					`Failed to list MCP servers. Is mcporter installed? (npm i -g mcporter)\n${msg}`,
+				);
+			}
+		},
+
+		renderCall(args, theme) {
+			let text = theme.fg("toolTitle", theme.bold("mcp_servers"));
+			if (args.refresh) text += theme.fg("warning", " (refresh)");
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { isPartial }, theme) {
+			if (isPartial) return new Text(theme.fg("warning", "Discovering MCP servers..."), 0, 0);
+			const d = result.details as { serverCount: number } | undefined;
+			return new Text(
+				theme.fg("success", `${d?.serverCount ?? 0} servers found`),
+				0,
+				0,
+			);
+		},
+	});
+
+	// ── mcp_discover ─────────────────────────────────────────────────────────
+
+	pi.registerTool({
+		name: "mcp_discover",
+		label: "MCP Discover",
+		description:
+			"Get detailed tool signatures and JSON schemas for a specific MCP server. " +
+			"Use this to understand what tools a server provides and what arguments they accept " +
+			"before calling them with mcp_call.",
+		promptSnippet:
+			"Get tool schemas for a specific MCP server before calling its tools",
+		promptGuidelines: [
+			"Call mcp_discover with a server name to see the full tool signatures before calling mcp_call.",
+			"The schemas show required and optional parameters with types and descriptions.",
+		],
+		parameters: Type.Object({
+			server: Type.String({
+				description:
+					"MCP server name (from mcp_servers output), e.g. 'railway', 'twitter-mcp', 'linear'",
+			}),
+		}),
+
+		async execute(_id, params, signal) {
+			try {
+				const detail = await getServerDetail(params.server, signal);
+				const text = formatServerDetail(detail);
+
+				// Truncation guard
+				const truncation = truncateHead(text, {
+					maxLines: DEFAULT_MAX_LINES,
+					maxBytes: DEFAULT_MAX_BYTES,
+				});
+				let finalText = truncation.content;
+				if (truncation.truncated) {
+					finalText +=
+						`\n\n[Truncated: ${truncation.outputLines}/${truncation.totalLines} lines ` +
+						`(${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)})]`;
+				}
+
+				return {
+					content: [{ type: "text", text: finalText }],
+					details: {
+						server: params.server,
+						toolCount: detail.tools.length,
+						cached: serverDetailCache.has(params.server),
+					},
+				};
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				throw new Error(`Failed to discover tools for "${params.server}": ${msg}`);
+			}
+		},
+
+		renderCall(args, theme) {
+			let text = theme.fg("toolTitle", theme.bold("mcp_discover "));
+			text += theme.fg("accent", args.server);
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { isPartial }, theme) {
+			if (isPartial)
+				return new Text(theme.fg("warning", "Discovering tools..."), 0, 0);
+			const d = result.details as { server: string; toolCount: number } | undefined;
+			return new Text(
+				theme.fg("success", `${d?.toolCount ?? 0} tools`) +
+					theme.fg("dim", ` · ${d?.server}`),
+				0,
+				0,
+			);
+		},
+	});
+
+	// ── mcp_call ─────────────────────────────────────────────────────────────
+
+	pi.registerTool({
+		name: "mcp_call",
+		label: "MCP Call",
+		description:
+			"Call a tool on an MCP server. Provide the server name, tool name, and arguments. " +
+			"Use mcp_discover first to see available tools and their required arguments.",
+		promptSnippet: "Call a tool on an MCP server via mcporter",
+		promptGuidelines: [
+			"Always use mcp_discover first to understand the tool's parameters before calling mcp_call.",
+			"Arguments are passed as a JSON object matching the tool's input schema.",
+		],
+		parameters: Type.Object({
+			server: Type.String({
+				description: "MCP server name, e.g. 'railway', 'twitter-mcp'",
+			}),
+			tool: Type.String({
+				description: "Tool name on that server, e.g. 'railway_list_projects'",
+			}),
+			args: Type.Optional(
+				Type.Record(Type.String(), Type.Unknown(), {
+					description:
+						"Tool arguments as key-value pairs matching the tool's input schema",
+				}),
+			),
+		}),
+
+		async execute(_id, params, signal) {
+			// Build mcporter call command: mcporter call server.tool key:value ...
+			const callTarget = `${params.server}.${params.tool}`;
+			const cliArgs = ["call", callTarget, "--output", "raw"];
+
+			if (params.args && Object.keys(params.args).length > 0) {
+				for (const [key, value] of Object.entries(params.args)) {
+					const strVal =
+						typeof value === "string" ? value : JSON.stringify(value);
+					cliArgs.push(`${key}:${strVal}`);
+				}
+			}
+
+			try {
+				const raw = await runMcporter(cliArgs, signal, 60000);
+
+				// Truncation guard
+				const truncation = truncateHead(raw, {
+					maxLines: DEFAULT_MAX_LINES,
+					maxBytes: DEFAULT_MAX_BYTES,
+				});
+				let finalText = truncation.content;
+				if (truncation.truncated) {
+					finalText +=
+						`\n\n[Output truncated: ${truncation.outputLines}/${truncation.totalLines} lines ` +
+						`(${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)})]`;
+				}
+
+				return {
+					content: [{ type: "text", text: finalText }],
+					details: {
+						server: params.server,
+						tool: params.tool,
+						charCount: finalText.length,
+						truncated: truncation.truncated,
+					},
+				};
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				throw new Error(
+					`MCP call failed: ${params.server}.${params.tool}\n${msg}`,
+				);
+			}
+		},
+
+		renderCall(args, theme) {
+			let text = theme.fg("toolTitle", theme.bold("mcp_call "));
+			text += theme.fg("accent", `${args.server}.${args.tool}`);
+			if (args.args && Object.keys(args.args).length > 0) {
+				const preview = Object.entries(args.args)
+					.slice(0, 3)
+					.map(([k, v]) => {
+						const val = typeof v === "string" ? v : JSON.stringify(v);
+						return `${k}:${val.length > 30 ? val.slice(0, 30) + "…" : val}`;
+					})
+					.join(" ");
+				text += " " + theme.fg("muted", preview);
+			}
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { isPartial, expanded }, theme) {
+			if (isPartial) return new Text(theme.fg("warning", "Calling MCP tool..."), 0, 0);
+
+			const d = result.details as {
+				server: string;
+				tool: string;
+				charCount: number;
+				truncated: boolean;
+			} | undefined;
+
+			let text = theme.fg("success", `✓ ${d?.server}.${d?.tool}`);
+			text += theme.fg("dim", ` · ${(d?.charCount ?? 0).toLocaleString()} chars`);
+			if (d?.truncated) text += theme.fg("warning", " · truncated");
+
+			if (expanded) {
+				const content = result.content[0];
+				if (content?.type === "text") {
+					const preview = content.text.split("\n").slice(0, 15).join("\n");
+					text += "\n\n" + theme.fg("dim", preview);
+				}
+			}
+
+			return new Text(text, 0, 0);
+		},
+	});
+
+	// ── Verify mcporter is available ─────────────────────────────────────────
+
+	pi.on("session_start", async (_event, ctx) => {
+		try {
+			const ver = (await runMcporter(["--version"], undefined, 5000)).trim();
+		ctx.ui.notify(`MCPorter ${ver} ready`, "info");
+		} catch {
+			ctx.ui.notify(
+				"MCPorter not found. Install with: npm i -g mcporter",
+				"error",
+			);
+		}
+	});
+}

package/src/resources/extensions/remote-questions/config.ts

@@ -0,0 +1,81 @@
+/**
+ * Remote Questions — configuration resolution and validation
+ */
+
+import { loadEffectiveGSDPreferences, type RemoteQuestionsConfig } from "../gsd/preferences.js";
+import type { RemoteChannel } from "./types.js";
+
+export interface ResolvedConfig {
+  channel: RemoteChannel;
+  channelId: string;
+  timeoutMs: number;
+  pollIntervalMs: number;
+  token: string;
+}
+
+const ENV_KEYS: Record<RemoteChannel, string> = {
+  slack: "SLACK_BOT_TOKEN",
+  discord: "DISCORD_BOT_TOKEN",
+};
+
+// Channel ID format validation — prevents SSRF if preferences are attacker-controlled
+const CHANNEL_ID_PATTERNS: Record<RemoteChannel, RegExp> = {
+  slack: /^[A-Z0-9]{9,12}$/,
+  discord: /^\d{17,20}$/,
+};
+
+const DEFAULT_TIMEOUT_MINUTES = 5;
+const DEFAULT_POLL_INTERVAL_SECONDS = 5;
+const MIN_TIMEOUT_MINUTES = 1;
+const MAX_TIMEOUT_MINUTES = 30;
+const MIN_POLL_INTERVAL_SECONDS = 2;
+const MAX_POLL_INTERVAL_SECONDS = 30;
+
+export function resolveRemoteConfig(): ResolvedConfig | null {
+  const prefs = loadEffectiveGSDPreferences();
+  const rq: RemoteQuestionsConfig | undefined = prefs?.preferences.remote_questions;
+  if (!rq || !rq.channel || !rq.channel_id) return null;
+  if (rq.channel !== "slack" && rq.channel !== "discord") return null;
+
+  const channelId = String(rq.channel_id);
+  if (!CHANNEL_ID_PATTERNS[rq.channel].test(channelId)) return null;
+
+  const token = process.env[ENV_KEYS[rq.channel]];
+  if (!token) return null;
+
+  const timeoutMinutes = clampNumber(rq.timeout_minutes, DEFAULT_TIMEOUT_MINUTES, MIN_TIMEOUT_MINUTES, MAX_TIMEOUT_MINUTES);
+  const pollIntervalSeconds = clampNumber(rq.poll_interval_seconds, DEFAULT_POLL_INTERVAL_SECONDS, MIN_POLL_INTERVAL_SECONDS, MAX_POLL_INTERVAL_SECONDS);
+
+  return {
+    channel: rq.channel,
+    channelId,
+    timeoutMs: timeoutMinutes * 60 * 1000,
+    pollIntervalMs: pollIntervalSeconds * 1000,
+    token,
+  };
+}
+
+export function getRemoteConfigStatus(): string {
+  const prefs = loadEffectiveGSDPreferences();
+  const rq: RemoteQuestionsConfig | undefined = prefs?.preferences.remote_questions;
+  if (!rq || !rq.channel || !rq.channel_id) return "Remote questions: not configured";
+  if (rq.channel !== "slack" && rq.channel !== "discord") return `Remote questions: unknown channel type \"${rq.channel}\"`;
+  const channelId = String(rq.channel_id);
+  if (!CHANNEL_ID_PATTERNS[rq.channel].test(channelId)) return `Remote questions: invalid ${rq.channel} channel ID format`;
+  const envVar = ENV_KEYS[rq.channel];
+  if (!process.env[envVar]) return `Remote questions: ${envVar} not set — remote questions disabled`;
+
+  const timeoutMinutes = clampNumber(rq.timeout_minutes, DEFAULT_TIMEOUT_MINUTES, MIN_TIMEOUT_MINUTES, MAX_TIMEOUT_MINUTES);
+  const pollIntervalSeconds = clampNumber(rq.poll_interval_seconds, DEFAULT_POLL_INTERVAL_SECONDS, MIN_POLL_INTERVAL_SECONDS, MAX_POLL_INTERVAL_SECONDS);
+  return `Remote questions: ${rq.channel} configured (timeout ${timeoutMinutes}m, poll ${pollIntervalSeconds}s)`;
+}
+
+export function isValidChannelId(channel: RemoteChannel, id: string): boolean {
+  return CHANNEL_ID_PATTERNS[channel].test(id);
+}
+
+function clampNumber(value: unknown, fallback: number, min: number, max: number): number {
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.max(min, Math.min(max, n));
+}

package/src/resources/extensions/remote-questions/discord-adapter.ts

@@ -0,0 +1,128 @@
+/**
+ * Remote Questions — Discord adapter
+ */
+
+import type { ChannelAdapter, RemotePrompt, RemoteDispatchResult, RemoteAnswer, RemotePromptRef } from "./types.js";
+import { formatForDiscord, parseDiscordResponse } from "./format.js";
+
+const DISCORD_API = "https://discord.com/api/v10";
+const PER_REQUEST_TIMEOUT_MS = 15_000;
+const NUMBER_EMOJIS = ["1️⃣", "2️⃣", "3️⃣", "4️⃣", "5️⃣"];
+
+export class DiscordAdapter implements ChannelAdapter {
+  readonly name = "discord" as const;
+  private botUserId: string | null = null;
+  private readonly token: string;
+  private readonly channelId: string;
+
+  constructor(token: string, channelId: string) {
+    this.token = token;
+    this.channelId = channelId;
+  }
+
+  async validate(): Promise<void> {
+    const res = await this.discordApi("GET", "/users/@me");
+    if (!res.id) throw new Error("Discord auth failed: invalid token");
+    this.botUserId = String(res.id);
+  }
+
+  async sendPrompt(prompt: RemotePrompt): Promise<RemoteDispatchResult> {
+    const { embeds, reactionEmojis } = formatForDiscord(prompt);
+    const res = await this.discordApi("POST", `/channels/${this.channelId}/messages`, {
+      content: "**GSD needs your input** — reply to this message with your answer",
+      embeds,
+    });
+
+    if (!res.id) throw new Error(`Discord send failed: ${JSON.stringify(res)}`);
+
+    const messageId = String(res.id);
+    if (prompt.questions.length === 1) {
+      for (const emoji of reactionEmojis) {
+        try {
+          await this.discordApi("PUT", `/channels/${this.channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}/@me`);
+        } catch {
+          // Best-effort only
+        }
+      }
+    }
+
+    return {
+      ref: {
+        id: prompt.id,
+        channel: "discord",
+        messageId,
+        channelId: this.channelId,
+      },
+    };
+  }
+
+  async pollAnswer(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null> {
+    if (!this.botUserId) await this.validate();
+
+    if (prompt.questions.length === 1) {
+      const reactionAnswer = await this.checkReactions(prompt, ref);
+      if (reactionAnswer) return reactionAnswer;
+    }
+
+    return this.checkReplies(prompt, ref);
+  }
+
+  private async checkReactions(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null> {
+    const reactions: Array<{ emoji: string; count: number }> = [];
+    for (const emoji of NUMBER_EMOJIS) {
+      try {
+        const users = await this.discordApi("GET", `/channels/${ref.channelId}/messages/${ref.messageId}/reactions/${encodeURIComponent(emoji)}`);
+        if (Array.isArray(users)) {
+          const humanUsers = users.filter((u: { id: string }) => u.id !== this.botUserId);
+          if (humanUsers.length > 0) reactions.push({ emoji, count: humanUsers.length });
+        }
+      } catch (err) {
+        const msg = String((err as Error).message ?? "");
+        // 404 = no reactions for this emoji — expected, continue
+        if (msg.includes("HTTP 404")) continue;
+        // 401/403 = auth failure — surface to caller so it can fail the poll
+        if (msg.includes("HTTP 401") || msg.includes("HTTP 403")) throw err;
+        // Other errors (rate limit, network) — skip this emoji, best-effort
+      }
+    }
+
+    if (reactions.length === 0) return null;
+    return parseDiscordResponse(reactions, null, prompt.questions);
+  }
+
+  private async checkReplies(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null> {
+    const messages = await this.discordApi("GET", `/channels/${ref.channelId}/messages?after=${ref.messageId}&limit=10`);
+    if (!Array.isArray(messages)) return null;
+
+    const replies = messages.filter(
+      (m: { author?: { id?: string }; message_reference?: { message_id?: string }; content?: string }) =>
+        m.author?.id &&
+        m.author.id !== this.botUserId &&
+        m.message_reference?.message_id === ref.messageId &&
+        m.content,
+    );
+
+    if (replies.length === 0) return null;
+    return parseDiscordResponse([], String(replies[0].content), prompt.questions);
+  }
+
+  private async discordApi(method: string, path: string, body?: unknown): Promise<any> {
+    const headers: Record<string, string> = { Authorization: `Bot ${this.token}` };
+    const init: RequestInit = { method, headers };
+    if (body) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(body);
+    }
+
+    init.signal = AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS);
+    const response = await fetch(`${DISCORD_API}${path}`, init);
+    if (response.status === 204) return {};
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      // Limit error body length to avoid leaking verbose Discord error responses
+      const safeText = text.length > 200 ? text.slice(0, 200) + "…" : text;
+      throw new Error(`Discord API HTTP ${response.status}: ${safeText}`);
+    }
+    return response.json();
+  }
+}