dsh-mcp-panel 0.2.0

package/lib/index.js

@@ -0,0 +1,1079 @@
+import z from "@deepseek-ai/schemastery";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+//#region src/config.ts
+/**
+* Plugin configuration and its explicit resolve step. `resolveConfig` re-judges
+* every default and bound so programmatic construction that bypasses
+* Schemastery normalization still fails loud instead of running with hidden
+* defaults (the explicit-resolve contract).
+*
+* @module dsh-mcp-panel/config
+*/
+/** Default per-probe timeout in milliseconds. */
+const DEFAULT_PROBE_TIMEOUT_MS = 1e4;
+/** Ceiling for a single probe timeout: a probe is a one-shot HTTP call. */
+const MAX_PROBE_TIMEOUT_MS = 3e5;
+/** Ceiling on the suggested panel refresh interval (1 hour). */
+const MAX_REFRESH_INTERVAL_MS = 36e5;
+/** Schemastery schema for loader-validated configuration. */
+const Config = z.object({
+	probeEnabled: z.boolean().default(true),
+	probeTimeoutMs: z.number().min(1).max(MAX_PROBE_TIMEOUT_MS).default(DEFAULT_PROBE_TIMEOUT_MS),
+	maxProbes: z.number().min(1).max(100).default(10),
+	refreshIntervalMs: z.number().min(0).max(MAX_REFRESH_INTERVAL_MS).default(0),
+	outputLanguage: z.union([
+		"en",
+		"zh",
+		"es",
+		"pt",
+		"hi"
+	]).default("en"),
+	passiveProbeEnabled: z.boolean().default(false),
+	passiveProbeIntervalMs: z.number().min(1e3).max(MAX_REFRESH_INTERVAL_MS).default(6e4)
+});
+/**
+* Resolve raw config to the runtime policy, re-validating defaults and bounds.
+*
+* @param config - raw loader config; `undefined` for a bare row.
+* @returns the frozen resolved config.
+*/
+function resolveConfig(config) {
+	const probeEnabled = config?.probeEnabled ?? true;
+	if (typeof probeEnabled !== "boolean") throw new TypeError("dsh-mcp-panel: config.probeEnabled must be a boolean");
+	const probeTimeoutMs = config?.probeTimeoutMs ?? 1e4;
+	if (!Number.isFinite(probeTimeoutMs) || probeTimeoutMs < 1 || probeTimeoutMs > 3e5) throw new Error(`dsh-mcp-panel: config.probeTimeoutMs must be a finite number between 1 and ${MAX_PROBE_TIMEOUT_MS}`);
+	const maxProbes = config?.maxProbes ?? 10;
+	if (!Number.isInteger(maxProbes) || maxProbes < 1 || maxProbes > 100) throw new Error("dsh-mcp-panel: config.maxProbes must be an integer between 1 and 100");
+	const refreshIntervalMs = config?.refreshIntervalMs ?? 0;
+	if (!Number.isFinite(refreshIntervalMs) || refreshIntervalMs < 0 || refreshIntervalMs > 36e5) throw new Error(`dsh-mcp-panel: config.refreshIntervalMs must be a finite number between 0 and ${MAX_REFRESH_INTERVAL_MS}`);
+	const outputLanguage = config?.outputLanguage ?? "en";
+	if (outputLanguage !== "en" && outputLanguage !== "zh" && outputLanguage !== "es" && outputLanguage !== "pt" && outputLanguage !== "hi") throw new Error(`dsh-mcp-panel: config.outputLanguage must be one of "en", "zh", "es", "pt", "hi", got ${JSON.stringify(outputLanguage)}`);
+	const passiveProbeEnabled = config?.passiveProbeEnabled ?? false;
+	if (typeof passiveProbeEnabled !== "boolean") throw new TypeError("dsh-mcp-panel: config.passiveProbeEnabled must be a boolean");
+	const passiveProbeIntervalMs = config?.passiveProbeIntervalMs ?? 6e4;
+	if (!Number.isFinite(passiveProbeIntervalMs) || passiveProbeIntervalMs < 1e3 || passiveProbeIntervalMs > 36e5) throw new Error(`dsh-mcp-panel: config.passiveProbeIntervalMs must be a finite number between 1000 and ${MAX_REFRESH_INTERVAL_MS}`);
+	return Object.freeze({
+		probeEnabled,
+		probeTimeoutMs,
+		maxProbes,
+		refreshIntervalMs,
+		outputLanguage,
+		passiveProbeEnabled,
+		passiveProbeIntervalMs
+	});
+}
+//#endregion
+//#region src/command.ts
+/** Placeholder for fields the panel cannot observe yet. */
+const UNKNOWN = "—";
+/** English output dictionary (default). */
+const EN_MESSAGES = {
+	enabled: "enabled",
+	disabled: "disabled",
+	status: "status",
+	reconnects: "reconnects",
+	lastError: "last error",
+	retryIn: "retry in",
+	cordisFiberFailed: "cordis fiber: failed",
+	tools: "tools",
+	serversHeader: (count) => `MCP servers (${count}):`,
+	noServers: "No MCP servers configured (no @deepseek-ai/dsh-mcp-client rows in this profile).",
+	noteNoSeam: "Note: connection status/reconnect counts are not observable yet — @deepseek-ai/dsh-mcp-client exposes no status seam.",
+	noteProposal: "Upstream proposal: docs/upstream-proposal.md (deepseek-harness). Row facts above are derived from config and the tool registry.",
+	noTools: (server) => `No tools registered for "${server}" (server down, sync failed, or reconnect budget exhausted).`,
+	toolsHeader: (server, count) => `Tools of "${server}" (${count}, model-visible public names):`,
+	noDescription: "(no description)",
+	patchIntro: (action, server, entryId, patchFile) => `To ${action} "${server}" (entry ${entryId}), add this line to the profile patch layer${patchFile === null ? "" : ` (${patchFile})`}:`,
+	patchNoRuntimeToggle: "@deepseek-ai/dsh-mcp-client has no runtime toggle; the Loader applies the patch on reload.",
+	patchReloadPath: "The web surface hot-reloads cordis.patch.yml edits; other surfaces restart. This command never edits your config.",
+	usage: "Usage: /mcp | /mcp <server> | /mcp <server> tools | /mcp <server> disable | /mcp <server> enable | /mcp <server> probe",
+	probeStarted: (server, jobId) => `Probe started for "${server}" (background job ${jobId}). Read the result in the MCP panel: Settings → Plugins → MCP.`,
+	unknownServer: (server, known) => `Unknown MCP server "${server}" (configured: ${known === "" ? "none" : known})`
+};
+/** Every output dictionary indexed by the configured language. */
+const MESSAGES = {
+	en: EN_MESSAGES,
+	zh: {
+		enabled: "已启用",
+		disabled: "已停用",
+		status: "状态",
+		reconnects: "重连",
+		lastError: "最近错误",
+		retryIn: "重试等待",
+		cordisFiberFailed: "cordis fiber: 失败",
+		tools: "工具",
+		serversHeader: (count) => `MCP 服务器（${count} 个）：`,
+		noServers: "此 profile 未配置官方 MCP 服务器（@deepseek-ai/dsh-mcp-client 行）。",
+		noteNoSeam: "说明：连接状态/重连计数尚不可观测——@deepseek-ai/dsh-mcp-client 未暴露状态 seam。",
+		noteProposal: "上游提案：docs/upstream-proposal.md（deepseek-harness）。以上行数据来自配置与工具注册表。",
+		noTools: (server) => `"${server}" 未注册任何工具（服务器宕机、同步失败或重连预算耗尽）。`,
+		toolsHeader: (server, count) => `"${server}" 的工具（${count} 个，模型可见公开名）：`,
+		noDescription: "（无描述）",
+		patchIntro: (action, server, entryId, patchFile) => {
+			return `要${action === "disable" ? "停用" : "启用"} "${server}"（条目 ${entryId}），把下面这行加到 profile patch 层${patchFile === null ? "" : `（${patchFile}）`}：`;
+		},
+		patchNoRuntimeToggle: "@deepseek-ai/dsh-mcp-client 没有运行时开关；Loader 在重载时应用该 patch。",
+		patchReloadPath: "web 面板会热重载 cordis.patch.yml 的修改；其他面板重启生效。本命令绝不修改你的配置。",
+		usage: "用法：/mcp | /mcp <server> | /mcp <server> tools | /mcp <server> disable | /mcp <server> enable | /mcp <server> probe",
+		probeStarted: (server, jobId) => `已对 "${server}" 启动探测（后台任务 ${jobId}）。结果仅面板可见：设置 → 插件 → MCP。`,
+		unknownServer: (server, known) => `未知 MCP 服务器 "${server}"（已配置：${known === "" ? "无" : known}）`
+	},
+	es: {
+		enabled: "habilitado",
+		disabled: "deshabilitado",
+		status: "estado",
+		reconnects: "reconexiones",
+		lastError: "último error",
+		retryIn: "reintento en",
+		cordisFiberFailed: "cordis fiber: falló",
+		tools: "herramientas",
+		serversHeader: (count) => `Servidores MCP (${count}):`,
+		noServers: "No hay servidores MCP configurados (sin filas @deepseek-ai/dsh-mcp-client en este perfil).",
+		noteNoSeam: "Nota: el estado de conexión y los conteos de reconexión aún no son observables — @deepseek-ai/dsh-mcp-client no expone una costura de estado.",
+		noteProposal: "Propuesta upstream: docs/upstream-proposal.md (deepseek-harness). Los datos de arriba derivan de la configuración y del registro de herramientas.",
+		noTools: (server) => `Sin herramientas registradas para "${server}" (servidor caído, sincronización fallida o presupuesto de reconexión agotado).`,
+		toolsHeader: (server, count) => `Herramientas de "${server}" (${count}, nombres públicos visibles al modelo):`,
+		noDescription: "(sin descripción)",
+		patchIntro: (action, server, entryId, patchFile) => {
+			return `Para ${action === "disable" ? "deshabilitar" : "habilitar"} "${server}" (entrada ${entryId}), añade esta línea a la capa de parches del perfil${patchFile === null ? "" : ` (${patchFile})`}:`;
+		},
+		patchNoRuntimeToggle: "@deepseek-ai/dsh-mcp-client no tiene conmutador en tiempo de ejecución; el Loader aplica el parche al recargar.",
+		patchReloadPath: "La superficie web recarga en caliente los cambios de cordis.patch.yml; otras superficies se reinician. Este comando nunca edita tu configuración.",
+		usage: "Uso: /mcp | /mcp <server> | /mcp <server> tools | /mcp <server> disable | /mcp <server> enable | /mcp <server> probe",
+		probeStarted: (server, jobId) => `Sonda iniciada para "${server}" (tarea en segundo plano ${jobId}). Lee el resultado en el panel MCP: Ajustes → Plugins → MCP.`,
+		unknownServer: (server, known) => `Servidor MCP desconocido "${server}" (configurados: ${known === "" ? "ninguno" : known})`
+	},
+	pt: {
+		enabled: "habilitado",
+		disabled: "desabilitado",
+		status: "status",
+		reconnects: "reconexões",
+		lastError: "último erro",
+		retryIn: "nova tentativa em",
+		cordisFiberFailed: "cordis fiber: falhou",
+		tools: "ferramentas",
+		serversHeader: (count) => `Servidores MCP (${count}):`,
+		noServers: "Nenhum servidor MCP configurado (nenhuma linha @deepseek-ai/dsh-mcp-client neste perfil).",
+		noteNoSeam: "Nota: o status de conexão e as contagens de reconexão ainda não são observáveis — @deepseek-ai/dsh-mcp-client não expõe uma costura de status.",
+		noteProposal: "Proposta upstream: docs/upstream-proposal.md (deepseek-harness). Os fatos acima derivam da configuração e do registro de ferramentas.",
+		noTools: (server) => `Nenhuma ferramenta registrada para "${server}" (servidor fora do ar, sincronização falhou ou orçamento de reconexão esgotado).`,
+		toolsHeader: (server, count) => `Ferramentas de "${server}" (${count}, nomes públicos visíveis ao modelo):`,
+		noDescription: "(sem descrição)",
+		patchIntro: (action, server, entryId, patchFile) => {
+			return `Para ${action === "disable" ? "desabilitar" : "habilitar"} "${server}" (entrada ${entryId}), adicione esta linha à camada de patches do perfil${patchFile === null ? "" : ` (${patchFile})`}:`;
+		},
+		patchNoRuntimeToggle: "@deepseek-ai/dsh-mcp-client não tem alternância em tempo de execução; o Loader aplica o patch ao recarregar.",
+		patchReloadPath: "A superfície web recarrega em quente as edições de cordis.patch.yml; outras superfícies reiniciam. Este comando nunca edita sua configuração.",
+		usage: "Uso: /mcp | /mcp <server> | /mcp <server> tools | /mcp <server> disable | /mcp <server> enable | /mcp <server> probe",
+		probeStarted: (server, jobId) => `Sonda iniciada para "${server}" (tarefa em segundo plano ${jobId}). Leia o resultado no painel MCP: Configurações → Plugins → MCP.`,
+		unknownServer: (server, known) => `Servidor MCP desconhecido "${server}" (configurados: ${known === "" ? "nenhum" : known})`
+	},
+	hi: {
+		enabled: "सक्षम",
+		disabled: "अक्षम",
+		status: "स्थिति",
+		reconnects: "रीकनेक्ट",
+		lastError: "अंतिम त्रुटि",
+		retryIn: "पुनः प्रयास",
+		cordisFiberFailed: "cordis fiber: विफल",
+		tools: "टूल",
+		serversHeader: (count) => `MCP सर्वर (${count}):`,
+		noServers: "कोई MCP सर्वर कॉन्फ़िगर नहीं (इस प्रोफ़ाइल में कोई @deepseek-ai/dsh-mcp-client पंक्ति नहीं)।",
+		noteNoSeam: "नोट: कनेक्शन स्थिति/रीकनेक्ट गणना अभी देखने योग्य नहीं — @deepseek-ai/dsh-mcp-client कोई स्थिति सीम उजागर नहीं करता।",
+		noteProposal: "अपस्ट्रीम प्रस्ताव: docs/upstream-proposal.md (deepseek-harness)। ऊपर के तथ्य कॉन्फ़िगरेशन और टूल रजिस्ट्री से प्राप्त हैं।",
+		noTools: (server) => `"${server}" के लिए कोई टूल पंजीकृत नहीं (सर्वर डाउन, सिंक विफल या रीकनेक्ट बजट समाप्त)।`,
+		toolsHeader: (server, count) => `"${server}" के टूल (${count}, मॉडल-दृश्य सार्वजनिक नाम):`,
+		noDescription: "(कोई विवरण नहीं)",
+		patchIntro: (action, server, entryId, patchFile) => {
+			return `"${server}" (एंट्री ${entryId}) को ${action === "disable" ? "अक्षम" : "सक्षम"} करने के लिए प्रोफ़ाइल पैच परत${patchFile === null ? "" : ` (${patchFile})`} में यह पंक्ति जोड़ें:`;
+		},
+		patchNoRuntimeToggle: "@deepseek-ai/dsh-mcp-client के पास रनटाइम टॉगल नहीं है; Loader रीलोड पर पैच लागू करता है।",
+		patchReloadPath: "वेब सतह cordis.patch.yml के बदलाव हॉट-रीलोड करती है; अन्य सतहें रीस्टार्ट करें। यह कमांड आपका कॉन्फ़िगरेशन कभी नहीं बदलती।",
+		usage: "उपयोग: /mcp | /mcp <server> | /mcp <server> tools | /mcp <server> disable | /mcp <server> enable | /mcp <server> probe",
+		probeStarted: (server, jobId) => `"${server}" के लिए प्रोब शुरू (बैकग्राउंड जॉब ${jobId})। परिणाम MCP पैनल में पढ़ें: सेटिंग्स → प्लगइन्स → MCP।`,
+		unknownServer: (server, known) => `अज्ञात MCP सर्वर "${server}" (कॉन्फ़िगर: ${known === "" ? "कोई नहीं" : known})`
+	}
+};
+/** One-line count of the reconnection attempts observed this process. */
+function reconnectText(view) {
+	return view.reconnectCount < 0 ? UNKNOWN : String(view.reconnectCount);
+}
+/** One-line recent-error summary. */
+function lastErrorText(view) {
+	return view.lastError ?? UNKNOWN;
+}
+/** Human status phrase with its provenance. */
+function statusText(view) {
+	return `${view.phase === "unknown" ? "unknown" : view.phase} (source: ${view.statusSource})`;
+}
+/**
+* Render one server row: `name [entryId] transport target | N tools | …`.
+*
+* @param view - the assembled server view.
+* @param messages - the output dictionary.
+* @returns the single display line.
+*/
+function renderServer(view, messages = EN_MESSAGES) {
+	const state = view.enabled ? messages.enabled : messages.disabled;
+	const details = [
+		`${messages.status}: ${statusText(view)}`,
+		`${messages.reconnects}: ${reconnectText(view)}`,
+		`${messages.lastError}: ${lastErrorText(view)}`
+	];
+	if (view.fiberPhase === "failed") details.push(messages.cordisFiberFailed);
+	if (view.delayMs !== null) details.push(`${messages.retryIn} ${view.delayMs}ms`);
+	return `- ${view.serverName} [${view.entryId}] ${view.transport} ${view.target} | ${view.toolCount} ${messages.tools} | ${state} | ${details.join(" | ")}`;
+}
+/**
+* Render the no-argument listing.
+*
+* @param snapshot - the current snapshot.
+* @param messages - the output dictionary.
+* @returns the full listing text.
+*/
+function renderList(snapshot, messages = EN_MESSAGES) {
+	if (snapshot.servers.length === 0) return messages.noServers;
+	const lines = [messages.serversHeader(snapshot.servers.length)];
+	for (const view of snapshot.servers) lines.push(renderServer(view, messages));
+	if (!snapshot.observed) lines.push(messages.noteNoSeam, messages.noteProposal);
+	return lines.join("\n");
+}
+/**
+* Render the tool list for one server.
+*
+* @param view - the assembled server view.
+* @param messages - the output dictionary.
+* @returns the tool listing text.
+*/
+function renderTools(view, messages = EN_MESSAGES) {
+	if (view.tools.length === 0) return messages.noTools(view.serverName);
+	const lines = [messages.toolsHeader(view.serverName, view.tools.length)];
+	for (const tool of view.tools) {
+		const description = tool.description.trim() === "" ? messages.noDescription : tool.description;
+		lines.push(`- ${tool.name} — ${description}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Render the controlled enable/disable patch suggestion. Reads only; the user
+* applies the line themselves. The web surface hot-reloads the profile patch
+* layer; other surfaces apply it on restart.
+*
+* @param view - the assembled server view.
+* @param action - which direction the suggestion flips.
+* @param patchFile - absolute profile patch-layer path, or null when unknown.
+* @param messages - the output dictionary.
+* @returns the suggestion text.
+*/
+function renderPatchSuggestion(view, action, patchFile, messages = EN_MESSAGES) {
+	const disabled = action === "disable";
+	const patch = `- set: { id: ${view.entryId}, name: '@deepseek-ai/dsh-mcp-client', disabled: ${disabled} }`;
+	return [
+		messages.patchIntro(action, view.serverName, view.entryId, patchFile),
+		"",
+		patch,
+		"",
+		messages.patchNoRuntimeToggle,
+		messages.patchReloadPath
+	].join("\n");
+}
+/**
+* Parse the free-form command input.
+*
+* @param rawInput - text after `/mcp`, including leading whitespace.
+* @returns the parsed intent; malformed input becomes `usage`.
+*/
+function parseMcpArgs(rawInput) {
+	const tokens = rawInput.trim().split(/\s+/u).filter((token) => token !== "");
+	if (tokens.length === 0) return { kind: "list" };
+	const server = tokens[0];
+	const action = tokens[1];
+	if (action === void 0) return {
+		kind: "server",
+		server: server ?? "",
+		action: "detail"
+	};
+	if (tokens.length !== 2) return { kind: "usage" };
+	if (action === "tools" || action === "disable" || action === "enable" || action === "probe") return {
+		kind: "server",
+		server: server ?? "",
+		action
+	};
+	return { kind: "usage" };
+}
+/**
+* Build the `/mcp` command definition over one service instance.
+*
+* @param service - the panel service supplying snapshots.
+* @param language - output language for the rendered text.
+* @returns the registration-ready definition.
+*/
+function mcpCommand(service, language = "en") {
+	const messages = MESSAGES[language] ?? EN_MESSAGES;
+	return {
+		name: "mcp",
+		description: "Show MCP server status, tools, and enable/disable patch suggestions (read-only)",
+		input: { hint: "[server] [tools|disable|enable|probe]" },
+		handler: ({ rawInput }) => {
+			const parsed = parseMcpArgs(rawInput);
+			if (parsed.kind === "usage") return {
+				kind: "error",
+				text: messages.usage
+			};
+			const snapshot = service.status();
+			if (parsed.kind === "list") return {
+				kind: "success",
+				text: renderList(snapshot, messages)
+			};
+			const view = snapshot.servers.find((candidate) => candidate.serverName === parsed.server);
+			if (view === void 0) {
+				const known = snapshot.servers.map((candidate) => candidate.serverName).join(", ");
+				return {
+					kind: "error",
+					text: messages.unknownServer(parsed.server, known)
+				};
+			}
+			switch (parsed.action) {
+				case "tools": return {
+					kind: "success",
+					text: renderTools(view, messages)
+				};
+				case "disable": return {
+					kind: "success",
+					text: renderPatchSuggestion(view, "disable", snapshot.patchFile, messages)
+				};
+				case "enable": return {
+					kind: "success",
+					text: renderPatchSuggestion(view, "enable", snapshot.patchFile, messages)
+				};
+				case "probe": try {
+					const started = service.probe(parsed.server);
+					return {
+						kind: "success",
+						text: messages.probeStarted(parsed.server, started.jobId)
+					};
+				} catch (error) {
+					return {
+						kind: "error",
+						text: error instanceof Error ? error.message : String(error)
+					};
+				}
+				default: return {
+					kind: "success",
+					text: renderServer(view, messages)
+				};
+			}
+		}
+	};
+}
+/** Query/field keys whose values are credentials regardless of their name casing. */
+const CREDENTIAL_KEY = /^(?:access[_-]?token|api[_-]?key|apikey|auth|authorization|client[_-]?secret|key|password|passwd|pwd|secret|sig|signature|token)$/iu;
+/** Credential keys for the unparseable-URL fallback and embedded-text scans. */
+const CREDENTIAL_KEY_SOURCE = "(?:access[_-]?token|api[_-]?key|apikey|auth(?:orization)?|client[_-]?secret|key|passw(?:or)?d|passwd|pwd|secret|sig(?:nature)?|token)";
+/** Whole userinfo before `@` (unparseable URLs only — parsed URLs redact just the password). */
+const USERINFO = /([a-z][a-z0-9+.-]*:\/\/)([^/@\s]+)@/giu;
+/** `?key=value` / `&key=value` credential pairs inside arbitrary text. */
+const QUERY_CREDENTIAL = new RegExp(`([?&](?:[^=&#\\s]*${CREDENTIAL_KEY_SOURCE}[^=&#\\s]*)=)[^&#\\s]*`, "giu");
+/** `#key=value` credential pairs in URL fragments and arbitrary text. */
+const FRAGMENT_CREDENTIAL = new RegExp(`(#[^=&#\\s]*${CREDENTIAL_KEY_SOURCE}[^=&#\\s]*=)[^&#\\s]*`, "giu");
+/** `Authorization: <value>`-style header lines in arbitrary text (quoted value first). */
+const HEADER_CREDENTIAL_QUOTED = new RegExp(`(\\b${CREDENTIAL_KEY_SOURCE}\\s*[:=]\\s*["'])[^"']*(["'])`, "giu");
+/** `Authorization: <value>`-style header lines with unquoted values. */
+const HEADER_CREDENTIAL_BARE = new RegExp(`(\\b${CREDENTIAL_KEY_SOURCE}\\s*[:=]\\s*)[^\\s,;)\\]}]+`, "giu");
+/** Environment-variable-shaped credentials (`GITHUB_TOKEN=…`) in spawn errors. */
+const ENV_VAR_CREDENTIAL = /\b[A-Za-z0-9_]*(?:TOKEN|API[_-]?KEY|SECRET|PASSWORD|PASSWD)[A-Za-z0-9_]*\s*=\s*[^\s,;)\]}]+/gu;
+/** Bearer tokens, including the `Bearer ` keyword and the token itself. */
+const BEARER = /(bearer)\s+[A-Za-z0-9._~+/=-]+/giu;
+/** Quoted JSON-ish `"token": "value"` pairs in arbitrary text. */
+const QUOTED_CREDENTIAL = new RegExp(`(["'](?:access[_-]?token|api[_-]?key|client[_-]?secret|secret|token)["']\\s*[:=]\\s*["'])[^"']*(["'])`, "giu");
+/** Raw JWT bodies, wherever they appear. */
+const JWT = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,}\b/gu;
+/**
+* Redact a URL for display: userinfo password, credential query values, and
+* credential fragment pairs. Query keys are read through `URLSearchParams`,
+* so percent-encoded key names are decoded before matching. Unparseable
+* inputs fall back to pattern redaction (whole userinfo, credential query
+* pairs, credential fragment pairs) instead of throwing.
+*
+* @param url - candidate URL text.
+* @returns display-safe URL text.
+*/
+function sanitizeUrl(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return url.replace(USERINFO, "$1***@").replace(QUERY_CREDENTIAL, `$1***`).replace(FRAGMENT_CREDENTIAL, `$1***`);
+	}
+	if (parsed.password !== "") parsed.password = "***";
+	for (const key of [...parsed.searchParams.keys()]) if (CREDENTIAL_KEY.test(key)) parsed.searchParams.set(key, "***");
+	if (parsed.hash !== "") parsed.hash = parsed.hash.replace(FRAGMENT_CREDENTIAL, `$1***`);
+	return parsed.toString();
+}
+/**
+* Redact credential-shaped fragments from free text: header lines, bearer
+* tokens, raw JWTs, embedded query pairs, and quoted token values.
+*
+* @param text - candidate display text.
+* @returns display-safe text.
+*/
+function sanitizeText(text) {
+	return text.replace(BEARER, `$1 ***`).replace(HEADER_CREDENTIAL_QUOTED, `$1***$2`).replace(HEADER_CREDENTIAL_BARE, `$1***`).replace(ENV_VAR_CREDENTIAL, (value) => {
+		const equals = value.indexOf("=");
+		return equals < 0 ? value : `${value.slice(0, equals)}=***`;
+	}).replace(QUOTED_CREDENTIAL, `$1***$2`).replace(QUERY_CREDENTIAL, `$1***`).replace(FRAGMENT_CREDENTIAL, `$1***`).replace(JWT, "***");
+}
+/**
+* Stringify an arbitrary thrown value safely and redact it for display.
+* Never throws: unrenderable values degrade to a fixed marker.
+*
+* @param error - thrown value from a connection attempt, probe, or sync.
+* @returns display-safe error text.
+*/
+function sanitizeError(error) {
+	let text;
+	try {
+		text = typeof error === "string" ? error : String(error);
+	} catch {
+		text = "<unrenderable error>";
+	}
+	return sanitizeText(text);
+}
+//#endregion
+//#region src/probe.ts
+/** Producer kind; also the job-id prefix. */
+const PROBE_KIND = "mcp-probe";
+/** JSON-RPC MCP initialize request used by the probe (protocol constant). */
+const INITIALIZE_PROTOCOL_VERSION = "2024-11-05";
+/** MCP clientInfo facts; protocol constants, not configuration. Exported so the
+* version-consistency tripwire (`tests/version.spec.ts`) can assert the
+* advertised version tracks the package version. */
+const PROBE_CLIENT_INFO = {
+	name: "dsh-mcp-panel",
+	version: "0.2.0"
+};
+/** Display cap for server-reported name/version fields in probe details. */
+const DISPLAY_LIMIT = 80;
+/** Bound one display string so hostile server metadata cannot blow up layouts. */
+function boundedDisplay(value) {
+	return value.length <= DISPLAY_LIMIT ? value : `${value.slice(0, 79)}…`;
+}
+/**
+* POST one MCP `initialize` request and describe the outcome in one sanitized
+* line. Never sends or echoes credentials: the configured headers are used
+* for the request itself (exactly as the bridge would) and never rendered.
+*
+* @param url - endpoint URL (already parsed by the caller).
+* @param headers - the configured request headers; used, never displayed.
+* @param timeoutMs - probe deadline.
+* @param signal - caller-owned abort (job kill or timeout).
+* @returns the settled probe outcome.
+*/
+async function probeEndpoint(url, headers, timeoutMs, signal) {
+	const started = Date.now();
+	try {
+		const response = await fetch(url, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				accept: "application/json, text/event-stream",
+				...headers
+			},
+			body: JSON.stringify({
+				jsonrpc: "2.0",
+				id: 1,
+				method: "initialize",
+				params: {
+					protocolVersion: INITIALIZE_PROTOCOL_VERSION,
+					capabilities: {},
+					clientInfo: PROBE_CLIENT_INFO
+				}
+			}),
+			signal
+		});
+		const ms = Date.now() - started;
+		if (!response.ok) return {
+			status: "failed",
+			detail: `HTTP ${response.status} ${response.statusText} (${ms}ms)`
+		};
+		let serverInfo = {};
+		try {
+			serverInfo = (await response.json())?.result?.serverInfo ?? {};
+		} catch {}
+		const name = typeof serverInfo.name === "string" && serverInfo.name !== "" ? boundedDisplay(sanitizeText(serverInfo.name)) : "unnamed";
+		const version = typeof serverInfo.version === "string" && serverInfo.version !== "" ? boundedDisplay(sanitizeText(serverInfo.version)) : "unknown version";
+		return {
+			status: "completed",
+			detail: `HTTP ${response.status}, MCP initialize ok (server ${name} ${version}) in ${ms}ms`
+		};
+	} catch (error) {
+		if (signal.aborted) return {
+			status: "failed",
+			detail: `timeout after ${timeoutMs}ms or cancelled`
+		};
+		return {
+			status: "failed",
+			detail: sanitizeError(error)
+		};
+	}
+}
+/**
+* Create the background-job hooks for one probe: cancel aborts the fetch, the
+* outcome settles `done` with sanitized detail only.
+*
+* @param url - endpoint URL.
+* @param headers - configured headers (used, never rendered).
+* @param timeoutMs - probe deadline.
+* @returns the registry hooks.
+*/
+function probeJob(url, headers, timeoutMs) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => {
+		controller.abort();
+	}, timeoutMs);
+	timer.unref?.();
+	return {
+		cancel: () => {
+			controller.abort();
+		},
+		done: probeEndpoint(url, headers, timeoutMs, controller.signal).then((outcome) => ({ ...outcome })).finally(() => {
+			clearTimeout(timer);
+		})
+	};
+}
+/** Resolve one configured server's raw endpoint for probing. */
+function probeTarget(service, server) {
+	return service.rawEndpoint(server);
+}
+/**
+* Build the `mcp_probe` tool definition.
+*
+* @param service - panel service (server lookup + snapshot for panel display).
+* @param jobs - background-job registry the probe runs on.
+* @param timeoutMs - per-probe deadline.
+* @returns the registration-ready definition.
+*/
+function mcpProbeTool(service, jobs, timeoutMs) {
+	return defineTool({
+		name: "mcp_probe",
+		description: "Run a one-shot connectivity probe of a configured streamable-http MCP server as a background job. Results appear in the MCP settings panel only — they are not injected into model context.",
+		parameters: { server: {
+			type: "string",
+			required: true,
+			description: "serverName of a configured streamable-http MCP server (see /mcp for the list)."
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					jobId: {
+						type: "string",
+						required: true
+					},
+					note: {
+						type: "string",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Probe started (background job ${value.jobId}). Read the result in the MCP panel: Settings → Plugins → MCP.`
+			}]
+		},
+		async execute(args) {
+			const target = probeTarget(service, args.server);
+			if (target === void 0) throw new Error(`mcp_probe: "${args.server}" is not a configured streamable-http MCP server (see /mcp). stdio servers have no HTTP endpoint to probe.`);
+			return {
+				jobId: jobs.start({
+					kind: PROBE_KIND,
+					label: `mcp_probe ${args.server}`,
+					run: () => probeJob(target.url, target.headers, timeoutMs)
+				}),
+				note: "Probe results are panel-only: Settings → Plugins → MCP."
+			};
+		}
+	});
+}
+/** Marker shown for a `!!js` config value, which the panel never evaluates. */
+const JS_EXPRESSION_MARKER = "<expression>";
+/** Read a plain JSON value from raw config; `!!js` nodes and wrong types become the fallback. */
+function plainField(config, key) {
+	if (typeof config !== "object" || config === null || Array.isArray(config)) return void 0;
+	const value = config[key];
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value === "object" && "__jsExpr" in value) return void 0;
+	return value;
+}
+/** Read a string config field; absent, non-string, or `!!js` becomes the fallback. */
+function stringField(config, key, fallback) {
+	const value = plainField(config, key);
+	return typeof value === "string" ? value : fallback;
+}
+/** Render one argument for the display command line. */
+function renderArg(arg) {
+	if (typeof arg === "string") return /^[\w./:@%+=,_-]+$/u.test(arg) ? arg : JSON.stringify(arg);
+	if (typeof arg === "object" && arg !== null && "__jsExpr" in arg) return JS_EXPRESSION_MARKER;
+	try {
+		return JSON.stringify(arg);
+	} catch {
+		return JS_EXPRESSION_MARKER;
+	}
+}
+/** Transport and display target derived from one raw mcp-client config. */
+function deriveTarget(config) {
+	const transport = stringField(config, "transport", "");
+	if (transport === "stdio") {
+		const command = stringField(config, "command", "");
+		if (command === "") return {
+			transport: "unknown",
+			target: "(unconfigured)"
+		};
+		const argsValue = plainField(config, "args");
+		const args = Array.isArray(argsValue) ? argsValue.map(renderArg) : [];
+		return {
+			transport: "stdio",
+			target: args.length === 0 ? command : `${command} ${args.join(" ")}`
+		};
+	}
+	if (transport === "streamable-http") {
+		const url = stringField(config, "url", "");
+		if (url === "") return {
+			transport: "unknown",
+			target: "(unconfigured)"
+		};
+		return {
+			transport: "streamable-http",
+			target: sanitizeUrl(url)
+		};
+	}
+	return {
+		transport: "unknown",
+		target: "(unconfigured)"
+	};
+}
+/** Read the server namespace from raw config; absent becomes a stable fallback. */
+function serverNameOf(config, fallback) {
+	const name = stringField(config, "serverName", "");
+	return name === "" ? fallback : name;
+}
+/**
+* Derive the config-declared policy facts in one display line. Reads only
+* boolean and number fields (never strings from raw config), so nothing
+* user-supplied or secret can leak; `null` = nothing noteworthy configured.
+*/
+function configuredNote(config) {
+	const parts = [];
+	const reconnectValue = plainField(config, "reconnect");
+	if (typeof reconnectValue === "object" && reconnectValue !== null && !Array.isArray(reconnectValue)) {
+		const enabled = plainField(reconnectValue, "enabled");
+		const maxAttempts = plainField(reconnectValue, "maxAttempts");
+		if (typeof enabled === "boolean" && !enabled) parts.push("reconnect off");
+		else if (typeof maxAttempts === "number" && Number.isFinite(maxAttempts)) parts.push(`reconnect max ${maxAttempts}`);
+	}
+	if (plainField(config, "failOnStartupError") === true) parts.push("fail on startup error");
+	const toolTimeout = plainField(config, "toolCallTimeoutMs");
+	if (typeof toolTimeout === "number" && Number.isFinite(toolTimeout)) parts.push(`tool timeout ${Math.round(toolTimeout / 1e3)}s`);
+	return parts.length === 0 ? null : parts.join("; ");
+}
+/** Upstream phase projected onto the wire vocabulary (unknown when unobserved). */
+function connectionPhase(status) {
+	if (status === void 0) return "unknown";
+	return status.phase;
+}
+/**
+* Assemble one server view from loader, registry, and upstream facts.
+* Missing upstream data degrades to `unknown`/`-1`/`null` — never fabricated.
+*
+* @param row - the mcp-client loader row, or `undefined` for leftover namespaces.
+* @param serverName - the effective namespace.
+* @param group - the tool group for this namespace (possibly empty).
+* @param facts - upstream observations and reconnect totals.
+* @returns the display-ready view.
+*/
+function aggregateServerView(row, serverName, group, facts) {
+	const status = facts.statuses.get(serverName);
+	const { transport, target } = row === void 0 ? {
+		transport: "unknown",
+		target: "(unconfigured)"
+	} : deriveTarget(row.config);
+	const lastError = status?.error === void 0 ? null : sanitizeError(status.error);
+	const attempt = status?.attempt ?? -1;
+	const maxAttempts = status?.maxAttempts ?? -1;
+	const reconnect = facts.reconnects.get(serverName) ?? -1;
+	const connectedAt = status?.connectedAt ?? null;
+	const delayMs = status?.delayMs ?? null;
+	const observedAt = facts.observedAt.get(serverName) ?? null;
+	const probe = facts.probeStates.get(serverName);
+	return {
+		serverName,
+		entryId: row?.entryId ?? "",
+		transport,
+		target,
+		enabled: row?.disabled === false,
+		fiberPhase: row?.fiberPhase ?? null,
+		configuredNote: row === void 0 ? null : configuredNote(row.config),
+		toolCount: group?.tools.length ?? 0,
+		tools: group?.tools ?? [],
+		phase: connectionPhase(status),
+		attempt,
+		maxAttempts,
+		delayMs,
+		reconnectCount: reconnect,
+		lastError,
+		connectedAt,
+		observedAt,
+		probeState: probe?.state ?? null,
+		probeCheckedAt: probe?.checkedAt ?? null,
+		statusSource: status === void 0 ? "derived" : "upstream-event"
+	};
+}
+/**
+* Assemble the complete snapshot from loader rows, tool groups, upstream
+* facts, and probe rows. Tolerates missing fields anywhere in the inputs.
+*
+* @param input - the snapshot inputs (see {@link McpAggregateInput}).
+* @returns the wire snapshot.
+*/
+function aggregateSnapshot(input) {
+	const { rows, groups, facts, probes, patchFile, refreshIntervalMs } = input;
+	const rowsByName = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const name = serverNameOf(row.config, `entry:${row.entryId}`);
+		const existing = rowsByName.get(name);
+		if (existing === void 0 || !row.disabled && existing.disabled) rowsByName.set(name, row);
+	}
+	const groupsByName = new Map(groups.map((group) => [group.serverName, group]));
+	const servers = [.../* @__PURE__ */ new Set([...rowsByName.keys(), ...groupsByName.keys()])].map((name) => aggregateServerView(rowsByName.get(name), name, groupsByName.get(name), facts)).sort((left, right) => left.serverName < right.serverName ? -1 : 1);
+	return {
+		observed: facts.statuses.size > 0,
+		patchFile,
+		refreshIntervalMs,
+		servers,
+		probes
+	};
+}
+//#endregion
+//#region src/grouping.ts
+/** The `mcp__` namespace prefix every bridged MCP tool name starts with. */
+const MCP_TOOL_PREFIX = "mcp__";
+/**
+* Split one registered tool schema list into per-server groups.
+*
+* @param schemas - the `ctx.tools.schemas()` snapshot (or any subset).
+* @param configuredNames - server namespaces from the loader's mcp-client rows.
+* @returns one group per configured namespace (even with zero tools) plus one
+*   group per unmatched `mcp__` namespace, sorted by server name.
+*/
+function groupMcpTools(schemas, configuredNames) {
+	const groups = /* @__PURE__ */ new Map();
+	const configured = new Set(configuredNames);
+	for (const serverName of configuredNames) if (!groups.has(serverName)) groups.set(serverName, {
+		serverName,
+		configured: true,
+		tools: []
+	});
+	for (const schema of schemas) {
+		const name = typeof schema.name === "string" ? schema.name : "";
+		if (!name.startsWith("mcp__")) continue;
+		const server = matchConfigured(name, configured);
+		const key = server ?? leftoverSegment(name);
+		if (key === "") continue;
+		const description = typeof schema.description === "string" ? schema.description : "";
+		const group = groups.get(key) ?? {
+			serverName: key,
+			configured: server !== void 0,
+			tools: []
+		};
+		group.tools.push({
+			name,
+			description
+		});
+		groups.set(key, group);
+	}
+	return [...groups.values()].map((group) => ({
+		...group,
+		tools: [...group.tools].sort((left, right) => left.name < right.name ? -1 : 1)
+	})).sort((left, right) => left.serverName < right.serverName ? -1 : 1);
+}
+/** Match `mcp__<server>__<raw>` against the configured namespaces. */
+function matchConfigured(name, configured) {
+	for (const serverName of configured) if (name.startsWith(`mcp__${serverName}__`)) return serverName;
+}
+/** Best-effort namespace segment for a foreign `mcp__`-prefixed registration. */
+function leftoverSegment(name) {
+	const separator = name.indexOf("__", 5);
+	return separator < 0 ? name.slice(5) : name.slice(5, separator);
+}
+/**
+* Count the tools registered under one configured server namespace.
+*
+* @param schemas - the `ctx.tools.schemas()` snapshot.
+* @param serverName - the configured namespace.
+* @returns the number of matching registrations.
+*/
+function countServerTools(schemas, serverName) {
+	const prefix = `${MCP_TOOL_PREFIX}${serverName}__`;
+	let count = 0;
+	for (const schema of schemas) if (schema.name.startsWith(prefix)) count += 1;
+	return count;
+}
+//#endregion
+//#region src/service.ts
+/**
+* The panel's host service: assembles the read-only MCP snapshot and serves
+* it under the `mcpPanel` Typert Remote namespace (`mcpPanel/status`).
+*
+* Data sources, all read-only:
+* - `ctx.loader` — mcp-client rows (raw config, effective disabled, fiber phase).
+* - `ctx.tools.schemas()` — registered `mcp__<server>__` tool names + descriptions.
+* - the proposed upstream `mcp/status` seam — observed via {@link observe}.
+* - `ctx.jobs` — unowned `mcp-probe` background jobs (panel-only results).
+*
+* Connection status is reported honestly: without upstream observations the
+* view reads `unknown` with `statusSource: 'derived'`; the panel never infers
+* a connection state from tool-registry presence.
+*
+* @module dsh-mcp-panel/service
+*/
+/**
+* Runtime mirror of the Cordis `FiberState` const enum (numeric cross-package
+* const enums have no runtime import), projected to the wire phases.
+*/
+const FIBER_PHASE = {
+	0: "pending",
+	1: "loading",
+	2: "active",
+	3: "failed",
+	4: null,
+	5: "unloading"
+};
+/** The profile patch-layer filename the enable/disable suggestions name. */
+const PROFILE_PATCH_FILENAME = "cordis.patch.yml";
+/** Label prefix written by the `mcp_probe` tool and the panel probe action. */
+const PROBE_LABEL_PREFIX = "mcp_probe ";
+/** Defaults for direct (non-Loader) service construction. */
+const DEFAULT_SERVICE_CONFIG = {
+	probeTimeoutMs: 1e4,
+	maxProbes: 10,
+	refreshIntervalMs: 0,
+	passiveProbeEnabled: false,
+	passiveProbeIntervalMs: 6e4
+};
+/** Read-only MCP management snapshot service, exported over the `mcpPanel` Remote namespace. */
+var McpPanelService = class extends TypertRemoteService {
+	config;
+	static inject = ["loader", "tools"];
+	/** Latest upstream payload per server namespace. */
+	statuses = /* @__PURE__ */ new Map();
+	/** Cumulative reconnect attempts observed per server namespace. */
+	reconnects = /* @__PURE__ */ new Map();
+	/** Epoch ms of the latest upstream event receipt per server namespace. */
+	observedAt = /* @__PURE__ */ new Map();
+	/** Latest passive-probe reachability per server namespace. */
+	probeStates = /* @__PURE__ */ new Map();
+	/** Passive-probe loop guard: one sweep at a time. */
+	passiveRunning = false;
+	/**
+	* @param ctx - context carrying the loader and tool registry.
+	* @param config - resolved runtime settings; defaults apply for direct construction.
+	*/
+	constructor(ctx, config = DEFAULT_SERVICE_CONFIG) {
+		super(ctx, "mcpPanel");
+		this.config = config;
+		if (config.passiveProbeEnabled) {
+			const timer = setInterval(() => {
+				this.runPassiveProbes();
+			}, config.passiveProbeIntervalMs);
+			timer.unref?.();
+			ctx.effect(() => () => {
+				clearInterval(timer);
+			}, "dsh-mcp-panel: passive probe loop");
+		}
+	}
+	/**
+	* Record one upstream `mcp/status` payload (event or query-seed). A
+	* `connecting` payload with a positive attempt counts one reconnect.
+	*
+	* @param payload - post-transition status facts.
+	*/
+	observe(payload) {
+		if (typeof payload.serverName !== "string" || payload.serverName === "") return;
+		this.statuses.set(payload.serverName, payload);
+		this.observedAt.set(payload.serverName, Date.now());
+		if (payload.phase === "connecting" && payload.attempt > 0) this.reconnects.set(payload.serverName, (this.reconnects.get(payload.serverName) ?? 0) + 1);
+	}
+	/**
+	* Assemble the current snapshot. Read-only: touches no configuration file
+	* and mutates no registry. Exported on the wire by the `mcpPanel/status`
+	* invocation descriptor in `./wire.ts` (registered through the package's
+	* `./typert` manifest) — no method decorator, so the built bundle stays
+	* plain ESM.
+	*
+	* @returns the wire snapshot (validated by the strict Typert codec on both faces).
+	*/
+	status() {
+		const rows = [];
+		for (const entry of this.ctx.loader.entries()) {
+			if (entry.options.name !== "@deepseek-ai/dsh-mcp-client") continue;
+			rows.push({
+				entryId: entry.options.id,
+				disabled: entry.disabled,
+				fiberPhase: entry.fiber === void 0 ? null : FIBER_PHASE[entry.fiber.state] ?? null,
+				config: entry.options.config
+			});
+		}
+		return aggregateSnapshot({
+			rows,
+			groups: groupMcpTools(this.ctx.tools.schemas(), rows.map((row) => serverNameOf(row.config, `entry:${row.entryId}`))),
+			facts: {
+				statuses: this.statuses,
+				reconnects: this.reconnects,
+				observedAt: this.observedAt,
+				probeStates: this.probeStates
+			},
+			probes: this.probeViews(),
+			patchFile: this.patchFile(),
+			refreshIntervalMs: this.config.refreshIntervalMs
+		});
+	}
+	/**
+	* Start a one-shot connectivity probe of one configured streamable-http
+	* server as an UNOWNED background job — panel-only, like the `mcp_probe`
+	* tool, but callable from the settings tab. Exported on the wire by the
+	* `mcpPanel/probe` invocation descriptor.
+	*
+	* @param serverName - configured namespace.
+	* @returns the started job id and where the result lands.
+	*/
+	probe(serverName) {
+		const target = this.rawEndpoint(serverName);
+		if (target === void 0) throw new Error(`dsh-mcp-panel: "${serverName}" is not a configured streamable-http MCP server`);
+		const jobs = this.ctx.get("jobs");
+		if (jobs === void 0) throw new Error("dsh-mcp-panel: ctx.jobs is not composed — the panel probe action needs a background-job registry");
+		return {
+			jobId: jobs.start({
+				kind: PROBE_KIND,
+				label: `mcp_probe ${serverName}`,
+				run: () => probeJob(target.url, target.headers, this.config.probeTimeoutMs)
+			}),
+			note: "Probe results are panel-only: Settings → Plugins → MCP."
+		};
+	}
+	/** One passive-probe sweep over every configured streamable-http server. */
+	async runPassiveProbes() {
+		if (this.passiveRunning) return;
+		this.passiveRunning = true;
+		try {
+			for (const entry of this.ctx.loader.entries()) {
+				if (entry.options.name !== "@deepseek-ai/dsh-mcp-client") continue;
+				const serverName = serverNameOf(entry.options.config, `entry:${entry.options.id}`);
+				const target = this.rawEndpoint(serverName);
+				if (target === void 0) continue;
+				const outcome = await probeEndpoint(target.url, target.headers, this.config.probeTimeoutMs, AbortSignal.timeout(this.config.probeTimeoutMs));
+				this.probeStates.set(serverName, {
+					state: outcome.status === "completed" ? "reachable" : "unreachable",
+					checkedAt: Date.now()
+				});
+			}
+		} finally {
+			this.passiveRunning = false;
+		}
+	}
+	/**
+	* Resolve one server's raw endpoint for the probe tool. Credentials stay
+	* inside this return value and are used for the request only — they never
+	* reach a snapshot, a log, or a display.
+	*
+	* @param serverName - configured namespace.
+	* @returns the raw URL + configured headers, or `undefined` when the server
+	*   is not a configured streamable-http row.
+	*/
+	rawEndpoint(serverName) {
+		for (const entry of this.ctx.loader.entries()) {
+			if (entry.options.name !== "@deepseek-ai/dsh-mcp-client") continue;
+			const config = entry.options.config;
+			if (serverNameOf(config, `entry:${entry.id}`) !== serverName) continue;
+			if (typeof config !== "object" || config === null || Array.isArray(config)) return void 0;
+			const row = config;
+			if (row["transport"] !== "streamable-http") return void 0;
+			const url = row["url"];
+			if (typeof url !== "string" || url === "") return void 0;
+			const headersValue = row["headers"];
+			const headers = {};
+			if (typeof headersValue === "object" && headersValue !== null && !Array.isArray(headersValue)) {
+				for (const [name, value] of Object.entries(headersValue)) if (typeof value === "string") headers[name] = value;
+			}
+			return {
+				url,
+				headers
+			};
+		}
+	}
+	/** Unowned `mcp-probe` background jobs, newest first, sanitized for display. */
+	probeViews() {
+		const jobs = this.ctx.get("jobs");
+		if (jobs === void 0) return [];
+		return jobs.list().filter((job) => job.kind === PROBE_KIND).map((job) => ({
+			id: job.id,
+			serverName: job.label.startsWith(PROBE_LABEL_PREFIX) ? job.label.slice(10) : job.label,
+			status: job.status,
+			startedAt: job.startedAt,
+			finishedAt: job.finishedAt ?? null,
+			detail: job.detail === void 0 ? null : sanitizeText(job.detail)
+		})).reverse().slice(0, this.config.maxProbes);
+	}
+	/** Absolute path of the profile patch layer the suggestions name, or null. */
+	patchFile() {
+		const base = this.ctx.baseUrl;
+		if (typeof base !== "string" || base === "") return null;
+		const dir = base.startsWith("file://") ? fileURLToPath(base) : base;
+		return join(dir, PROFILE_PATCH_FILENAME);
+	}
+};
+//#endregion
+//#region src/upstream.ts
+/** Exact event name, exported so consumers never hardcode the literal twice. */
+const MCP_STATUS_EVENT = "mcp/status";
+//#endregion
+//#region src/index.ts
+const name = "mcp-panel";
+/** Hard services: the facts the panel reads. `commands`/`jobs` are optional children. */
+const inject = ["tools", "loader"];
+/**
+* Mount the panel: the snapshot service, the upstream status seam consumer,
+* the `/mcp` command (when commands exist), and the probe tool (when enabled
+* and a job registry exists).
+*
+* @param ctx - context carrying tools + loader.
+* @param config - raw loader config; defaults applied through {@link resolveConfig}.
+*/
+async function apply(ctx, config) {
+	const resolved = resolveConfig(config);
+	await ctx.plugin(McpPanelService, {
+		probeTimeoutMs: resolved.probeTimeoutMs,
+		maxProbes: resolved.maxProbes,
+		refreshIntervalMs: resolved.refreshIntervalMs,
+		passiveProbeEnabled: resolved.passiveProbeEnabled,
+		passiveProbeIntervalMs: resolved.passiveProbeIntervalMs
+	});
+	const service = ctx.get("mcpPanel");
+	ctx.on(MCP_STATUS_EVENT, (payload) => {
+		service.observe(payload);
+	});
+	const query = ctx.get("mcpStatus");
+	if (query !== void 0) for (const status of query.list()) service.observe(status);
+	ctx.inject(["commands"], (scope) => {
+		scope.effect(() => scope.commands.register(mcpCommand(service, resolved.outputLanguage)), "dsh-mcp-panel: /mcp command");
+	});
+	ctx.inject(["jobs"], (scope) => {
+		scope.effect(() => scope.jobs.attachController("dsh-mcp-panel"), "dsh-mcp-panel: jobs controller");
+		if (resolved.probeEnabled) scope.effect(() => scope.tools.register(mcpProbeTool(service, scope.jobs, resolved.probeTimeoutMs)), "dsh-mcp-panel: probe tool");
+	});
+}
+//#endregion
+export { Config, MCP_STATUS_EVENT, McpPanelService, aggregateServerView, aggregateSnapshot, apply, countServerTools, deriveTarget, groupMcpTools, inject, mcpCommand, mcpProbeTool, name, parseMcpArgs, probeEndpoint, probeJob, renderList, renderPatchSuggestion, renderServer, renderTools, resolveConfig, sanitizeError, sanitizeText, sanitizeUrl, serverNameOf };