pi-soly 1.9.3 → 1.11.0

package/mcp/metadata-cache.ts

@@ -0,0 +1,201 @@
+// metadata-cache.ts - Persistent MCP metadata cache
+import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { getAgentPath } from "./agent-dir.ts";
+import { createHash } from "node:crypto";
+import { getToolUiResourceUri } from "@modelcontextprotocol/ext-apps/app-bridge";
+import type { McpTool, McpResource, ServerEntry, ToolMetadata } from "./types.ts";
+import { formatToolName, isToolExcluded } from "./types.ts";
+import { resourceNameToToolName } from "./resource-tools.ts";
+import { extractToolUiStreamMode, interpolateEnvRecord, resolveBearerToken, resolveConfigPath } from "./utils.ts";
+
+const CACHE_VERSION = 1;
+const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+
+export interface CachedTool {
+  name: string;
+  description?: string;
+  inputSchema?: unknown;
+  uiResourceUri?: string;
+  uiStreamMode?: "eager" | "stream-first";
+}
+
+export interface CachedResource {
+  uri: string;
+  name: string;
+  description?: string;
+}
+
+export interface ServerCacheEntry {
+  configHash: string;
+  tools: CachedTool[];
+  resources: CachedResource[];
+  cachedAt: number;
+}
+
+export interface MetadataCache {
+  version: number;
+  servers: Record<string, ServerCacheEntry>;
+}
+
+export function getMetadataCachePath(): string {
+  return getAgentPath("mcp-cache.json");
+}
+
+export function loadMetadataCache(): MetadataCache | null {
+  const cachePath = getMetadataCachePath();
+  if (!existsSync(cachePath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(cachePath, "utf-8"));
+    if (!raw || typeof raw !== "object") return null;
+    if (raw.version !== CACHE_VERSION) return null;
+    if (!raw.servers || typeof raw.servers !== "object") return null;
+    return raw as MetadataCache;
+  } catch {
+    return null;
+  }
+}
+
+export function saveMetadataCache(cache: MetadataCache): void {
+  const cachePath = getMetadataCachePath();
+  const dir = dirname(cachePath);
+  mkdirSync(dir, { recursive: true });
+
+  let merged: MetadataCache = { version: CACHE_VERSION, servers: {} };
+  try {
+    if (existsSync(cachePath)) {
+      const existing = JSON.parse(readFileSync(cachePath, "utf-8")) as MetadataCache;
+      if (existing && existing.version === CACHE_VERSION && existing.servers) {
+        merged.servers = { ...existing.servers };
+      }
+    }
+  } catch {
+    // Ignore parse errors and proceed with empty cache
+  }
+
+  merged.version = CACHE_VERSION;
+  merged.servers = { ...merged.servers, ...cache.servers };
+
+  const tmpPath = `${cachePath}.${process.pid}.tmp`;
+  writeFileSync(tmpPath, JSON.stringify(merged, null, 2), "utf-8");
+  renameSync(tmpPath, cachePath);
+}
+
+export function computeServerHash(definition: ServerEntry): string {
+  // Hash only fields that affect server identity and tool/resource output.
+  // Exclude lifecycle, idleTimeout, debug — those are runtime behavior settings
+  // that don't change which tools a server exposes.
+  const identity: Record<string, unknown> = {
+    command: definition.command,
+    args: definition.args,
+    env: interpolateEnvRecord(definition.env),
+    cwd: resolveConfigPath(definition.cwd),
+    url: definition.url,
+    headers: interpolateEnvRecord(definition.headers),
+    auth: definition.auth,
+    bearerToken: resolveBearerToken(definition),
+    bearerTokenEnv: definition.bearerTokenEnv,
+    exposeResources: definition.exposeResources,
+    excludeTools: definition.excludeTools,
+  };
+  const normalized = stableStringify(identity);
+  return createHash("sha256").update(normalized).digest("hex");
+}
+
+export function isServerCacheValid(
+  entry: ServerCacheEntry,
+  definition: ServerEntry,
+  maxAgeMs: number = CACHE_MAX_AGE_MS
+): boolean {
+  if (!entry || entry.configHash !== computeServerHash(definition)) return false;
+  if (!entry.cachedAt || typeof entry.cachedAt !== "number") return false;
+  if (maxAgeMs > 0 && Date.now() - entry.cachedAt > maxAgeMs) return false;
+  return true;
+}
+
+export function reconstructToolMetadata(
+  serverName: string,
+  entry: ServerCacheEntry,
+  prefix: "server" | "none" | "short",
+  definition: Pick<ServerEntry, "exposeResources" | "excludeTools">
+): ToolMetadata[] {
+  const metadata: ToolMetadata[] = [];
+
+  for (const tool of entry.tools ?? []) {
+    if (!tool?.name) continue;
+    if (isToolExcluded(tool.name, serverName, prefix, definition.excludeTools)) {
+      continue;
+    }
+
+    metadata.push({
+      name: formatToolName(tool.name, serverName, prefix),
+      originalName: tool.name,
+      description: tool.description ?? "",
+      inputSchema: tool.inputSchema,
+      uiResourceUri: tool.uiResourceUri,
+      uiStreamMode: tool.uiStreamMode,
+    });
+  }
+
+  if (definition.exposeResources !== false) {
+    for (const resource of entry.resources ?? []) {
+      if (!resource?.name || !resource?.uri) continue;
+      const baseName = `get_${resourceNameToToolName(resource.name)}`;
+      if (isToolExcluded(baseName, serverName, prefix, definition.excludeTools)) {
+        continue;
+      }
+
+      metadata.push({
+        name: formatToolName(baseName, serverName, prefix),
+        originalName: baseName,
+        description: resource.description ?? `Read resource: ${resource.uri}`,
+        resourceUri: resource.uri,
+      });
+    }
+  }
+
+  return metadata;
+}
+
+export function serializeTools(tools: McpTool[]): CachedTool[] {
+  return tools
+    .filter(t => t?.name)
+    .map(t => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.inputSchema,
+      uiResourceUri: tryGetToolUiResourceUri(t),
+      uiStreamMode: extractToolUiStreamMode(t._meta),
+    }));
+}
+
+export function serializeResources(resources: McpResource[]): CachedResource[] {
+  return resources
+    .filter(r => r?.name && r?.uri)
+    .map(r => ({
+      uri: r.uri,
+      name: r.name,
+      description: r.description,
+    }));
+}
+
+function stableStringify(value: unknown): string {
+  if (value === null || value === undefined || typeof value !== "object") {
+    const serialized = JSON.stringify(value);
+    return serialized === undefined ? "undefined" : serialized;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(v => stableStringify(v)).join(",")}]`;
+  }
+  const obj = value as Record<string, unknown>;
+  const keys = Object.keys(obj).sort();
+  return `{${keys.map(k => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
+}
+
+function tryGetToolUiResourceUri(tool: McpTool): string | undefined {
+  try {
+    return getToolUiResourceUri({ _meta: tool._meta });
+  } catch {
+    return undefined;
+  }
+}

package/mcp/notify.ts

@@ -0,0 +1,111 @@
+// =============================================================================
+// notify.ts — MCP-specific notification wrappers
+// =============================================================================
+//
+// Thin layer over soly's notifyFramed() that:
+// - Falls back gracefully if the UI doesn't have setWidget (print mode)
+// - Adds MCP-specific keys so multiple MCP notifications don't clobber each other
+//   or soly's other widgets
+// - Provides typed helpers for the most common MCP events: reconnect fail,
+//   session auto-recovery (UE5 bug workaround), tool errors
+//
+// Keys are namespaced (mcp-reconnect-<name>, mcp-session-recover-<name>) so
+// they don't collide with soly's default "soly-notif" key.
+
+import { notifyFramed, type NotifBg } from "../notification.ts";
+import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+
+const MCP_KEY_PREFIX = "mcp-";
+
+function notifyBox(
+	ui: ExtensionUIContext,
+	key: string,
+	title: string,
+	lines: readonly string[],
+	bg: NotifBg,
+	autoClearMs = 8000,
+): void {
+	try {
+		notifyFramed(ui, title, lines, {
+			key: MCP_KEY_PREFIX + key,
+			bg,
+			autoClearMs,
+		});
+	} catch {
+		// Fallback: setWidget may fail in print mode / RPC. Use plain notify
+		// with a short title-only message. Don't crash the MCP handler.
+		const plain = lines.length > 0 ? `${title} — ${lines.join(" ")}` : title;
+		try {
+			ui.notify(plain, bg === "toolErrorBg" ? "error" : bg === "toolPendingBg" ? "warning" : "info");
+		} catch {
+			// no UI at all — silent
+		}
+	}
+}
+
+/** Reconnect failed — red box. Auto-clears after 10s (longer for errors). */
+export function notifyReconnectFailed(
+	ui: ExtensionUIContext,
+	serverName: string,
+	error: string,
+): void {
+	notifyBox(
+		ui,
+		`reconnect-${serverName}`,
+		`🔌 MCP: ${serverName} reconnect failed`,
+		[error.length > 200 ? `${error.slice(0, 200)}…` : error],
+		"toolErrorBg",
+		10_000,
+	);
+}
+
+/** Session auto-recovery succeeded (UE5 workaround worked). Green box. */
+export function notifySessionRecovered(
+	ui: ExtensionUIContext,
+	serverName: string,
+	fromMethod: string,
+): void {
+	notifyBox(
+		ui,
+		`session-recover-${serverName}`,
+		`🔄 MCP: ${serverName} session auto-recovered`,
+		[
+			`${fromMethod} hit "Unknown session id"`,
+			`Reconnected silently — retry succeeded`,
+		],
+		"toolSuccessBg",
+		6_000,
+	);
+}
+
+/** Session auto-recovery failed after retry. Red box. */
+export function notifySessionRecoveryFailed(
+	ui: ExtensionUIContext,
+	serverName: string,
+	error: string,
+): void {
+	notifyBox(
+		ui,
+		`session-recover-${serverName}`,
+		`🔄 MCP: ${serverName} session recovery failed`,
+		[error.length > 200 ? `${error.slice(0, 200)}…` : error],
+		"toolErrorBg",
+		10_000,
+	);
+}
+
+/** Generic MCP info/warning (yellow) — for status updates like connecting. */
+export function notifyMcpStatus(
+	ui: ExtensionUIContext,
+	serverName: string,
+	message: string,
+): void {
+	notifyBox(
+		ui,
+		`status-${serverName}`,
+		`🔌 MCP: ${serverName}`,
+		[message],
+		"toolPendingBg",
+		5_000,
+	);
+}