gsd-pi 2.28.0 → 2.29.0-dev.23d50d0

package/dist/resources/extensions/mcp-client/index.ts

@@ -0,0 +1,459 @@
+/**
+ * MCP Client Extension — Native MCP server integration for pi
+ *
+ * Provides on-demand access to MCP servers configured in project files
+ * (.mcp.json, .gsd/mcp.json) using the @modelcontextprotocol/sdk Client
+ * directly — no external CLI dependency required.
+ *
+ * Three tools:
+ *   mcp_servers   — List available MCP servers from config files
+ *   mcp_discover  — Get tool signatures for a specific server (lazy connect)
+ *   mcp_call      — Call a tool on an MCP server (lazy connect)
+ */
+
+import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+import {
+	truncateHead,
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	formatSize,
+} from "@gsd/pi-coding-agent";
+import { Text } from "@gsd/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { Client } from "@modelcontextprotocol/sdk/client";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+interface McpServerConfig {
+	name: string;
+	transport: "stdio" | "http" | "unknown";
+	command?: string;
+	args?: string[];
+	env?: Record<string, string>;
+	url?: string;
+	cwd?: string;
+}
+
+interface McpToolSchema {
+	name: string;
+	description: string;
+	inputSchema?: Record<string, unknown>;
+}
+
+interface ManagedConnection {
+	client: Client;
+	transport: StdioClientTransport | StreamableHTTPClientTransport;
+}
+
+// ─── Connection Manager ───────────────────────────────────────────────────────
+
+const connections = new Map<string, ManagedConnection>();
+let configCache: McpServerConfig[] | null = null;
+const toolCache = new Map<string, McpToolSchema[]>();
+
+function readConfigs(): McpServerConfig[] {
+	if (configCache) return configCache;
+
+	const servers: McpServerConfig[] = [];
+	const seen = new Set<string>();
+	const configPaths = [
+		join(process.cwd(), ".mcp.json"),
+		join(process.cwd(), ".gsd", "mcp.json"),
+	];
+
+	for (const configPath of configPaths) {
+		try {
+			if (!existsSync(configPath)) continue;
+			const raw = readFileSync(configPath, "utf-8");
+			const data = JSON.parse(raw) as Record<string, unknown>;
+			const mcpServers = (data.mcpServers ?? data.servers) as
+				| Record<string, Record<string, unknown>>
+				| undefined;
+			if (!mcpServers || typeof mcpServers !== "object") continue;
+
+			for (const [name, config] of Object.entries(mcpServers)) {
+				if (seen.has(name)) continue;
+				seen.add(name);
+
+				const hasCommand = typeof config.command === "string";
+				const hasUrl = typeof config.url === "string";
+				const transport: McpServerConfig["transport"] = hasCommand
+					? "stdio"
+					: hasUrl
+						? "http"
+						: "unknown";
+
+				servers.push({
+					name,
+					transport,
+					...(hasCommand && {
+						command: config.command as string,
+						args: Array.isArray(config.args) ? (config.args as string[]) : undefined,
+						env: config.env && typeof config.env === "object"
+							? (config.env as Record<string, string>)
+							: undefined,
+						cwd: typeof config.cwd === "string" ? config.cwd : undefined,
+					}),
+					...(hasUrl && { url: config.url as string }),
+				});
+			}
+		} catch {
+			// Non-fatal — config file may not exist or be malformed
+		}
+	}
+
+	configCache = servers;
+	return servers;
+}
+
+function getServerConfig(name: string): McpServerConfig | undefined {
+	return readConfigs().find((s) => s.name === name);
+}
+
+async function getOrConnect(name: string, signal?: AbortSignal): Promise<Client> {
+	const existing = connections.get(name);
+	if (existing) return existing.client;
+
+	const config = getServerConfig(name);
+	if (!config) throw new Error(`Unknown MCP server: "${name}". Use mcp_servers to list available servers.`);
+
+	const client = new Client({ name: "gsd", version: "1.0.0" });
+	let transport: StdioClientTransport | StreamableHTTPClientTransport;
+
+	if (config.transport === "stdio" && config.command) {
+		transport = new StdioClientTransport({
+			command: config.command,
+			args: config.args,
+			env: config.env ? { ...process.env, ...config.env } as Record<string, string> : undefined,
+			cwd: config.cwd,
+			stderr: "pipe",
+		});
+	} else if (config.transport === "http" && config.url) {
+		transport = new StreamableHTTPClientTransport(new URL(config.url));
+	} else {
+		throw new Error(`Server "${name}" has unsupported transport: ${config.transport}`);
+	}
+
+	await client.connect(transport, { signal, timeout: 30000 });
+	connections.set(name, { client, transport });
+	return client;
+}
+
+async function closeAll(): Promise<void> {
+	const closing = Array.from(connections.entries()).map(async ([name, conn]) => {
+		try {
+			await conn.client.close();
+		} catch {
+			// Best-effort cleanup
+		}
+		connections.delete(name);
+	});
+	await Promise.allSettled(closing);
+	toolCache.clear();
+}
+
+// ─── Formatters ───────────────────────────────────────────────────────────────
+
+function formatServerList(servers: McpServerConfig[]): string {
+	if (servers.length === 0) return "No MCP servers configured. Add servers to .mcp.json or .gsd/mcp.json.";
+
+	const lines: string[] = [`${servers.length} MCP servers configured:\n`];
+
+	for (const s of servers) {
+		const connected = connections.has(s.name) ? "✓" : "○";
+		const cached = toolCache.get(s.name);
+		const toolCount = cached ? ` — ${cached.length} tools` : "";
+		lines.push(`${connected} ${s.name} (${s.transport})${toolCount}`);
+	}
+
+	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 formatToolList(serverName: string, tools: McpToolSchema[]): string {
+	const lines: string[] = [`${serverName} — ${tools.length} tools:\n`];
+
+	for (const tool of 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="${serverName}", 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 configured in project files (.mcp.json, .gsd/mcp.json). " +
+			"Shows server names, transport type, and connection status. Use mcp_discover to get full tool schemas for a server.",
+		promptSnippet:
+			"List available MCP servers from project configuration",
+		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) {
+			if (params.refresh) configCache = null;
+
+			const servers = readConfigs();
+			return {
+				content: [{ type: "text", text: formatServerList(servers) }],
+				details: {
+					serverCount: servers.length,
+					cached: !params.refresh && configCache !== null,
+				},
+			};
+		},
+
+		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", "Reading MCP config..."), 0, 0);
+			const d = result.details as { serverCount: number } | undefined;
+			return new Text(
+				theme.fg("success", `${d?.serverCount ?? 0} servers configured`),
+				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. " +
+			"Connects to the server on first call (lazy connection). " +
+			"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 {
+				// Return cached tools if available
+				const cached = toolCache.get(params.server);
+				if (cached) {
+					const text = formatToolList(params.server, cached);
+					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: cached.length, cached: true },
+					};
+				}
+
+				const client = await getOrConnect(params.server, signal);
+				const result = await client.listTools(undefined, { signal, timeout: 30000 });
+				const tools: McpToolSchema[] = (result.tools ?? []).map((t) => ({
+					name: t.name,
+					description: t.description ?? "",
+					inputSchema: t.inputSchema as Record<string, unknown> | undefined,
+				}));
+				toolCache.set(params.server, tools);
+
+				const text = formatToolList(params.server, tools);
+				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: tools.length, cached: false },
+				};
+			} 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. " +
+			"Connects to the server on first call (lazy connection). " +
+			"Use mcp_discover first to see available tools and their required arguments.",
+		promptSnippet: "Call a tool on an MCP server",
+		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) {
+			try {
+				const client = await getOrConnect(params.server, signal);
+				const result = await client.callTool(
+					{ name: params.tool, arguments: params.args ?? {} },
+					undefined,
+					{ signal, timeout: 60000 },
+				);
+
+				// Serialize result content to text
+				const contentItems = result.content as Array<{ type: string; text?: string }>;
+				const raw = contentItems
+					.map((c) => (c.type === "text" ? c.text ?? "" : JSON.stringify(c)))
+					.join("\n");
+
+				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);
+		},
+	});
+
+	// ── Lifecycle ─────────────────────────────────────────────────────────────
+
+	pi.on("session_start", async (_event, ctx) => {
+		const servers = readConfigs();
+		if (servers.length > 0) {
+			ctx.ui.notify(`MCP client ready — ${servers.length} server(s) configured`, "info");
+		}
+	});
+
+	pi.on("session_shutdown", async () => {
+		await closeAll();
+	});
+
+	pi.on("session_switch", async () => {
+		await closeAll();
+		configCache = null;
+	});
+}

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

@@ -2,11 +2,12 @@
  * Remote Questions — Discord adapter
  */
 
-import type { ChannelAdapter, RemotePrompt, RemoteDispatchResult, RemoteAnswer, RemotePromptRef } from "./types.js";
+import { type ChannelAdapter, type RemotePrompt, type RemoteDispatchResult, type RemoteAnswer, type RemotePromptRef } from "./types.js";
 import { formatForDiscord, parseDiscordResponse, DISCORD_NUMBER_EMOJIS } from "./format.js";
+import { apiRequest } from "./http-client.js";
 
 const DISCORD_API = "https://discord.com/api/v10";
-const PER_REQUEST_TIMEOUT_MS = 15_000;
+
 export class DiscordAdapter implements ChannelAdapter {
   readonly name = "discord" as const;
   private botUserId: string | null = null;
@@ -137,23 +138,11 @@ export class DiscordAdapter implements ChannelAdapter {
     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();
+  private async discordApi(method: "GET" | "POST" | "PUT" | "DELETE", path: string, body?: unknown): Promise<any> {
+    return apiRequest(`${DISCORD_API}${path}`, method, body, {
+      authScheme: "Bot",
+      authToken: this.token,
+      errorLabel: "Discord API",
+    });
   }
 }

package/dist/resources/extensions/remote-questions/http-client.ts

@@ -0,0 +1,76 @@
+/**
+ * Remote Questions — shared HTTP client
+ *
+ * Centralizes timeout, error handling, and JSON serialization logic
+ * used by all channel adapters (Discord, Slack, Telegram).
+ */
+
+import { PER_REQUEST_TIMEOUT_MS } from "./types.js";
+
+export interface ApiRequestOptions {
+  /** Authorization header scheme. Omit to skip the Authorization header entirely. */
+  authScheme?: "Bearer" | "Bot";
+  /** Token for the Authorization header. Ignored when authScheme is omitted. */
+  authToken?: string;
+  /** Max chars of error body to include in thrown Error. Default 200. */
+  safeErrorLength?: number;
+  /** Label used in error messages (e.g. "Discord API", "Slack API"). Default "HTTP". */
+  errorLabel?: string;
+  /** Content-Type override. Default "application/json" when body is present. */
+  contentType?: string;
+}
+
+/**
+ * Makes an HTTP request with standardized timeout, error handling, and JSON
+ * serialization.
+ *
+ * - Sets `AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS)` on every request.
+ * - Serializes `body` as JSON and sets Content-Type when provided.
+ * - Returns `{}` for 204 No Content responses.
+ * - Truncates error response bodies to `safeErrorLength` chars (default 200).
+ */
+export async function apiRequest(
+  url: string,
+  method: "GET" | "POST" | "PUT" | "DELETE",
+  body?: unknown,
+  options: ApiRequestOptions = {},
+): Promise<any> {
+  const {
+    authScheme,
+    authToken,
+    safeErrorLength = 200,
+    errorLabel = "HTTP",
+    contentType,
+  } = options;
+
+  const headers: Record<string, string> = {};
+  if (authScheme && authToken) {
+    headers["Authorization"] = `${authScheme} ${authToken}`;
+  }
+
+  const init: RequestInit = {
+    method,
+    headers,
+    signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS),
+  };
+
+  if (body !== undefined) {
+    headers["Content-Type"] = contentType ?? "application/json";
+    init.body = JSON.stringify(body);
+  }
+
+  const response = await fetch(url, init);
+
+  if (response.status === 204) return {};
+
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    const safeText =
+      text.length > safeErrorLength
+        ? text.slice(0, safeErrorLength) + "\u2026"
+        : text;
+    throw new Error(`${errorLabel} HTTP ${response.status}: ${safeText}`);
+  }
+
+  return response.json();
+}

package/dist/resources/extensions/remote-questions/manager.ts

@@ -9,6 +9,7 @@ import { DiscordAdapter } from "./discord-adapter.js";
 import { SlackAdapter } from "./slack-adapter.js";
 import { TelegramAdapter } from "./telegram-adapter.js";
 import { createPromptRecord, writePromptRecord, markPromptAnswered, markPromptDispatched, markPromptStatus, updatePromptRecord } from "./store.js";
+import { sanitizeError } from "../shared/sanitize.js";
 
 interface ToolResult {
   content: Array<{ type: "text"; text: string }>;
@@ -70,7 +71,7 @@ export async function tryRemoteQuestions(
         channel: config.channel,
         timed_out: true,
         promptId: prompt.id,
-        threadUrl: dispatch.ref.threadUrl,
+        threadUrl: dispatch.ref.threadUrl ?? null,
         status: signal?.aborted ? "cancelled" : "timed_out",
       },
     };
@@ -79,11 +80,9 @@ export async function tryRemoteQuestions(
   markPromptAnswered(prompt.id, answer);
 
   // Best-effort acknowledgement gives remote users a visible receipt signal.
-  if (dispatch.ref) {
-    try {
-      await adapter.acknowledgeAnswer?.(dispatch.ref);
-    } catch { /* best-effort */ }
-  }
+  try {
+    await adapter.acknowledgeAnswer?.(dispatch.ref);
+  } catch { /* best-effort */ }
 
   return {
     content: [{ type: "text", text: JSON.stringify({ answers: formatForTool(answer) }) }],
@@ -92,7 +91,7 @@ export async function tryRemoteQuestions(
       channel: config.channel,
       timed_out: false,
       promptId: prompt.id,
-      threadUrl: dispatch.ref.threadUrl,
+      threadUrl: dispatch.ref.threadUrl ?? null,
       questions,
       response: answer,
       status: "answered",
@@ -177,23 +176,6 @@ function formatForTool(answer: RemoteAnswer): Record<string, { answers: string[]
   return out;
 }
 
-// Strip token-like strings from error messages before surfacing
-const TOKEN_PATTERNS = [
-  /xoxb-[A-Za-z0-9\-]+/g,    // Slack bot tokens
-  /xoxp-[A-Za-z0-9\-]+/g,    // Slack user tokens
-  /xoxa-[A-Za-z0-9\-]+/g,    // Slack app tokens
-  /\d{8,10}:[A-Za-z0-9_-]{35}/g, // Telegram bot tokens
-  /[A-Za-z0-9_\-.]{20,}/g,   // Long opaque secrets (Discord tokens, etc.)
-];
-
-export function sanitizeError(msg: string): string {
-  let sanitized = msg;
-  for (const pattern of TOKEN_PATTERNS) {
-    sanitized = sanitized.replace(pattern, "[REDACTED]");
-  }
-  return sanitized;
-}
-
 function errorResult(message: string, channel: string): ToolResult {
   return {
     content: [{ type: "text", text: sanitizeError(message) }],

package/dist/resources/extensions/remote-questions/mod.ts

@@ -0,0 +1,16 @@
+// Barrel file — re-exports consumed by external modules
+
+export { handleRemote } from "./remote-command.js";
+export { createPromptRecord, writePromptRecord } from "./store.js";
+export { getLatestPromptSummary } from "./status.js";
+export {
+	parseSlackReply,
+	parseDiscordResponse,
+	formatForDiscord,
+	formatForSlack,
+	parseSlackReactionResponse,
+	formatForTelegram,
+	parseTelegramResponse,
+} from "./format.js";
+export { resolveRemoteConfig, isValidChannelId } from "./config.js";
+export { sendRemoteNotification } from "./notify.js";