@herbertgao/pi-extensions 2026.9.17 → 2026.9.19

package/node_modules/pi-mcp-adapter/mcp-probe.ts

@@ -1,201 +0,0 @@
-const PROBE_TIMEOUT_MS = 5_000;
-const MODERN_PROTOCOL_VERSION = "2026-07-28";
-const LEGACY_PROTOCOL_VERSION = "2025-06-18";
-const JSON_ACCEPT = "application/json, text/event-stream";
-const SSE_ACCEPT = "text/event-stream";
-const MODERN_FALLBACK_STATUSES = new Set([400, 401, 404, 405, 406, 415]);
-const POST_ENDPOINT_MISMATCH_STATUSES = new Set([404, 405, 406, 415]);
-const AMBIGUOUS_STATUSES = new Set([202, 401, 503]);
-
-export interface McpProbeResult {
-  isMcp: boolean;
-  classification: string;
-}
-
-const DISCOVER_REQUEST = {
-  jsonrpc: "2.0",
-  id: 1,
-  method: "server/discover",
-  params: {},
-};
-
-const INITIALIZE_REQUEST = {
-  jsonrpc: "2.0",
-  id: 1,
-  method: "initialize",
-  params: {
-    protocolVersion: LEGACY_PROTOCOL_VERSION,
-    capabilities: {},
-    clientInfo: { name: "pi-mcp-probe", version: "2.1.2" },
-  },
-};
-
-type ProbeStrategy =
-  | { kind: "modern"; request: RequestInit; allowJson: true }
-  | { kind: "legacy-post"; request: RequestInit; allowJson: true }
-  | { kind: "legacy-sse"; request: RequestInit; allowJson: false };
-
-const MODERN_STRATEGY: ProbeStrategy = {
-  kind: "modern",
-  request: {
-    method: "POST",
-    headers: {
-      Accept: JSON_ACCEPT,
-      "Content-Type": "application/json",
-      "MCP-Protocol-Version": MODERN_PROTOCOL_VERSION,
-      "Mcp-Method": "server/discover",
-    },
-    body: JSON.stringify(DISCOVER_REQUEST),
-  },
-  allowJson: true,
-};
-
-const LEGACY_POST_STRATEGY: ProbeStrategy = {
-  kind: "legacy-post",
-  request: {
-    method: "POST",
-    headers: {
-      Accept: JSON_ACCEPT,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(INITIALIZE_REQUEST),
-  },
-  allowJson: true,
-};
-
-const LEGACY_SSE_STRATEGY: ProbeStrategy = {
-  kind: "legacy-sse",
-  request: { headers: { Accept: SSE_ACCEPT } },
-  allowJson: false,
-};
-
-type JsonRpcEnvelopeInfo =
-  | { kind: "result"; protocolVersion: unknown }
-  | { kind: "error" };
-
-type ProbeOutcome =
-  | { kind: "mcp"; result: McpProbeResult }
-  | { kind: "unsupported-modern" }
-  | { kind: "unrecognized" };
-
-interface ProbeResult {
-  response: Response;
-  outcome: ProbeOutcome;
-}
-
-function jsonRpcEnvelopeInfo(value: unknown): JsonRpcEnvelopeInfo | null {
-  if (typeof value !== "object" || value === null || (value as { jsonrpc?: unknown }).jsonrpc !== "2.0") {
-    return null;
-  }
-  if ("result" in value) {
-    const result = (value as { result?: unknown }).result;
-    return {
-      kind: "result",
-      protocolVersion: typeof result === "object" && result !== null
-        ? (result as { protocolVersion?: unknown }).protocolVersion
-        : undefined,
-    };
-  }
-  if ("error" in value) return { kind: "error" };
-  return null;
-}
-
-function isBearerChallenge(response: Response): boolean {
-  return /(?:^|,)\s*Bearer\b/i.test(response.headers.get("www-authenticate") ?? "");
-}
-
-function responseKind(response: Response): string {
-  const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
-  if (contentType === "text/html") return "HTML";
-  if (contentType) return contentType;
-  return "an untyped response";
-}
-
-async function getJsonRpcEnvelopeInfo(response: Response): Promise<JsonRpcEnvelopeInfo | null> {
-  try {
-    return jsonRpcEnvelopeInfo(JSON.parse(await response.text()));
-  } catch {
-    return null;
-  }
-}
-
-async function classifyResponse(response: Response, strategy: ProbeStrategy): Promise<ProbeOutcome> {
-  const isSse = response.headers.get("content-type")?.toLowerCase().startsWith("text/event-stream");
-  if (response.ok && isSse) {
-    return { kind: "mcp", result: { isMcp: true, classification: "endpoint responded with an MCP event stream" } };
-  }
-
-  const envelope = (strategy.allowJson || response.status === 401) ? await getJsonRpcEnvelopeInfo(response) : null;
-  if (response.ok && strategy.allowJson && envelope) {
-    if (strategy.kind === "modern" && (envelope.kind === "error" || envelope.protocolVersion !== MODERN_PROTOCOL_VERSION)) {
-      return { kind: "unsupported-modern" };
-    }
-    return {
-      kind: "mcp",
-      result: {
-        isMcp: true,
-        classification: strategy.kind === "modern"
-          ? `endpoint supports stateless MCP ${MODERN_PROTOCOL_VERSION} server/discover`
-          : "endpoint responded with a JSON-RPC 2.0 envelope",
-      },
-    };
-  }
-  if (response.status === 401 && isBearerChallenge(response) && envelope) {
-    return {
-      kind: "mcp",
-      result: {
-        isMcp: true,
-        classification: strategy.kind === "modern"
-          ? `endpoint requires Bearer authentication during MCP ${MODERN_PROTOCOL_VERSION} server/discover probing`
-          : "endpoint requires Bearer authentication and responded with a JSON-RPC 2.0 error",
-      },
-    };
-  }
-
-  return { kind: "unrecognized" };
-}
-
-async function probe(url: string | URL, strategy: ProbeStrategy): Promise<ProbeResult> {
-  const response = await fetch(url, {
-    ...strategy.request,
-    signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
-  });
-  return { response, outcome: await classifyResponse(response, strategy) };
-}
-
-function notMcp(response: Response): McpProbeResult {
-  const responseDescription = `endpoint returned ${responseKind(response)} (${response.status})`;
-  return {
-    isMcp: false,
-    classification: response.status === 503
-      ? `${responseDescription} — server is temporarily unavailable; MCP endpoint shape could not be determined`
-      : response.status === 202
-        ? `${responseDescription} — MCP endpoint shape could not be determined`
-      : response.status === 401
-        ? `${responseDescription} — authentication may be required; MCP endpoint shape could not be determined`
-        : `${responseDescription} — this URL does not appear to speak MCP`,
-  };
-}
-
-function ambiguousNotMcp(response: Response): McpProbeResult | undefined {
-  return AMBIGUOUS_STATUSES.has(response.status) ? notMcp(response) : undefined;
-}
-
-/** Makes one unauthenticated metadata-only request to identify an HTTP endpoint's protocol shape. */
-export async function probeMcpEndpoint(url: string | URL): Promise<McpProbeResult> {
-  const { response: modernResponse, outcome: modernOutcome } = await probe(url, MODERN_STRATEGY);
-  if (modernOutcome.kind === "mcp") return modernOutcome.result;
-  let ambiguousResult = ambiguousNotMcp(modernResponse);
-
-  if (modernOutcome.kind !== "unsupported-modern" && !MODERN_FALLBACK_STATUSES.has(modernResponse.status)) {
-    return ambiguousResult ?? notMcp(modernResponse);
-  }
-
-  const { response: postResponse, outcome: postOutcome } = await probe(url, LEGACY_POST_STRATEGY);
-  if (postOutcome.kind === "mcp") return postOutcome.result;
-  ambiguousResult ??= ambiguousNotMcp(postResponse);
-  if (!POST_ENDPOINT_MISMATCH_STATUSES.has(postResponse.status)) return ambiguousNotMcp(postResponse) ?? ambiguousResult ?? notMcp(postResponse);
-
-  const { response: getResponse, outcome: getOutcome } = await probe(url, LEGACY_SSE_STRATEGY);
-  return getOutcome.kind === "mcp" ? getOutcome.result : ambiguousNotMcp(getResponse) ?? ambiguousResult ?? notMcp(getResponse);
-}

package/node_modules/pi-mcp-adapter/mcp-references.ts

@@ -1,373 +0,0 @@
-import { isUiToolVisibleToModel } from "./ui-tool-visibility.ts";
-import { resourceNameToToolName } from "./resource-tools.ts";
-import { createCachedToolSelectorCandidateIndex, isServerCacheValid, parseDirectToolSelectors, type MetadataCache } from "./metadata-cache.ts";
-import {
-  formatServerNamespace,
-  formatToolName,
-  isServerDisabled,
-  isToolAllowed,
-  resolveToolPrefix,
-  resolveUniqueNameOwnership,
-  type CachedTool,
-  type McpConfig,
-  type ServerCacheEntry,
-  type ServerEntry,
-  type ToolPrefix,
-  type ToolSelectorCandidateIndex,
-} from "./types.ts";
-
-export interface ParsedMcpReference {
-  raw: string;
-  server?: string;
-  tool?: string;
-}
-
-export interface McpReferenceResolution {
-  names: string[];
-  diagnostics: string[];
-}
-
-export type DirectToolSelectorOverride = { servers: Set<string>; tools: Map<string, Set<string>> };
-type DirectSelection = true | string[] | false;
-type DirectNameOwner = { serverName: string; originalName: string };
-type DirectNameEntry = { name: string; originalName: string };
-type CachedServer = { serverName: string; definition: ServerEntry; entry: ServerCacheEntry; prefix: ToolPrefix };
-
-const BUILTIN_NAMES = new Set(["read", "bash", "edit", "write", "grep", "find", "ls", "mcp"]);
-
-export function namespaceProxyName(serverName: string): string {
-  return `mcp__${formatServerNamespace(serverName)}`;
-}
-
-export function parseMcpReference(raw: string): ParsedMcpReference {
-  if (!raw.startsWith("mcp:")) return { raw };
-  const rest = raw.slice("mcp:".length).trim();
-  if (!rest) return { raw };
-
-  const slash = rest.indexOf("/");
-  if (slash === -1) return { raw, server: rest };
-
-  const server = rest.slice(0, slash).trim();
-  const tool = rest.slice(slash + 1).trim();
-  return {
-    raw,
-    ...(server ? { server } : {}),
-    ...(tool ? { tool } : {}),
-  };
-}
-
-function resolveDirectSelection(
-  config: McpConfig,
-  definition: Pick<ServerEntry, "directTools">,
-  serverName: string,
-  envOverride: DirectToolSelectorOverride | null,
-): DirectSelection {
-  if (envOverride) {
-    if (envOverride.servers.has(serverName)) return true;
-    const selectedTools = envOverride.tools.get(serverName);
-    return selectedTools ? [...selectedTools] : false;
-  }
-  // "search" registers the same tool set as `true`; only activation differs.
-  if (definition.directTools !== undefined) return definition.directTools === "search" ? true : definition.directTools;
-  return config.settings?.directTools === true || config.settings?.directTools === "search";
-}
-
-export function isMcpServerDirectlyRegistered(
-  definition: { directTools?: boolean | string[] | "search" } | undefined,
-  settings: McpConfig["settings"],
-  serverName: string,
-  envOverride: DirectToolSelectorOverride | null,
-): boolean {
-  if (envOverride) return envOverride.servers.has(serverName);
-  if (definition?.directTools !== undefined) {
-    return definition.directTools === true || definition.directTools === "search"
-      || (Array.isArray(definition.directTools) && definition.directTools.length > 0);
-  }
-  return settings?.directTools === true || settings?.directTools === "search";
-}
-
-export function hasCallableCachedTargets(entry: Pick<ServerCacheEntry, "tools" | "resources">, definition: Pick<ServerEntry, "exposeResources">): boolean {
-  return entry.tools.length > 0 || (definition.exposeResources !== false && (entry.resources?.length ?? 0) > 0);
-}
-
-function hasNamespaceProxy(
-  config: McpConfig,
-  cache: MetadataCache | null,
-  envOverride: DirectToolSelectorOverride | null,
-  collidingNamespaceNames: ReadonlySet<string>,
-  existingDirectNames: ReadonlySet<string>,
-  serverName: string,
-): boolean {
-  if (config.settings?.namespaceProxyTools === false) return false;
-  const definition = config.mcpServers[serverName];
-  if (!definition || isServerDisabled(definition)) return false;
-  if (isMcpServerDirectlyRegistered(definition, config.settings, serverName, envOverride)) return false;
-  const toolName = namespaceProxyName(serverName);
-  if (collidingNamespaceNames.has(toolName) || existingDirectNames.has(toolName)) return false;
-  const entry = resolveValidCache(definition, cache, serverName);
-  return !!entry && hasCallableCachedTargets(entry, definition);
-}
-
-function resolveValidCache(definition: ServerEntry | undefined, cache: MetadataCache | null, serverName: string): ServerCacheEntry | undefined {
-  const entry = cache?.servers[serverName];
-  if (!definition || !entry || !isServerCacheValid(entry, definition)) return undefined;
-  return entry;
-}
-
-function cachedServers(config: McpConfig, cache: MetadataCache | null): CachedServer[] {
-  const servers: CachedServer[] = [];
-  if (!cache) return servers;
-  for (const [serverName, definition] of Object.entries(config.mcpServers)) {
-    if (isServerDisabled(definition)) continue;
-    const entry = resolveValidCache(definition, cache, serverName);
-    if (!entry) continue;
-    servers.push({ serverName, definition, entry, prefix: resolveToolPrefix(definition, config.settings?.toolPrefix) });
-  }
-  return servers;
-}
-
-function namespaceCollisionNames(
-  config: McpConfig,
-  cache: MetadataCache | null,
-  envOverride: DirectToolSelectorOverride | null,
-  existingDirectNames: ReadonlySet<string>,
-): Set<string> {
-  const names = new Map<string, number>();
-  if (!cache) return new Set();
-  for (const serverName of Object.keys(config.mcpServers)) {
-    if (!hasNamespaceProxy(config, cache, envOverride, new Set(), existingDirectNames, serverName)) continue;
-    const toolName = namespaceProxyName(serverName);
-    names.set(toolName, (names.get(toolName) ?? 0) + 1);
-  }
-  return new Set([...names].filter(([, count]) => count > 1).map(([name]) => name));
-}
-
-function registeredDirectNames(
-  config: McpConfig,
-  cache: MetadataCache | null,
-  envOverride: DirectToolSelectorOverride | null,
-  selectorIndex: ToolSelectorCandidateIndex | undefined,
-): Map<string, DirectNameOwner> {
-  const entries: Array<{ name: string; owner: DirectNameOwner }> = [];
-  for (const { serverName, definition, entry, prefix } of cachedServers(config, cache)) {
-    const selection = resolveDirectSelection(config, definition, serverName, envOverride);
-    for (const { name, originalName } of directNameEntries(entry, serverName, definition, prefix, selection, selectorIndex)) {
-      entries.push({ name, owner: { serverName, originalName } });
-    }
-  }
-  return new Map(resolveUniqueNameOwnership(entries, (entry) => entry.name).unique.map(({ name, owner }) => [name, owner]));
-}
-
-function allCurrentCandidates(config: McpConfig, cache: MetadataCache | null): ToolSelectorCandidateIndex | undefined {
-  if (!cache) return undefined;
-  return createCachedToolSelectorCandidateIndex(config.mcpServers, cache, config.settings?.toolPrefix ?? "server");
-}
-
-function directToolName(
-  toolName: string,
-  serverName: string,
-  definition: ServerEntry,
-  prefix: ToolPrefix,
-  selectorIndex: ToolSelectorCandidateIndex | undefined,
-): string | undefined {
-  if (!isToolAllowed(toolName, serverName, prefix, definition.includeTools, definition.excludeTools, selectorIndex)) return undefined;
-  return formatToolName(toolName, serverName, prefix);
-}
-
-function directNameEntries(
-  entry: ServerCacheEntry,
-  serverName: string,
-  definition: ServerEntry,
-  prefix: ToolPrefix,
-  selection: DirectSelection,
-  selectorIndex: ToolSelectorCandidateIndex | undefined,
-  onlyTool?: string,
-): DirectNameEntry[] {
-  if (!selection) return [];
-  const names: DirectNameEntry[] = [];
-  const addTool = (toolName: string): void => {
-    if (selection !== true && !selection.includes(toolName)) return;
-    const name = directToolName(toolName, serverName, definition, prefix, selectorIndex);
-    if (!name) return;
-    if (BUILTIN_NAMES.has(name)) return;
-    if (onlyTool !== undefined && toolName !== onlyTool && name !== onlyTool) return;
-    names.push({ name, originalName: toolName });
-  };
-
-  for (const tool of entry.tools) {
-    if (!isUiToolVisibleToModel(tool.uiVisibility)) continue;
-    addTool(tool.name);
-  }
-  if (definition.exposeResources !== false) {
-    for (const resource of entry.resources ?? []) addTool(`read_${resourceNameToToolName(resource.name)}`);
-  }
-  return names;
-}
-
-function ownedDirectToolNames(names: DirectNameEntry[], serverName: string, directNameOwners: ReadonlyMap<string, DirectNameOwner>): string[] {
-  return names
-    .filter(({ name, originalName }) => {
-      const owner = directNameOwners.get(name);
-      return owner?.serverName === serverName && owner.originalName === originalName;
-    })
-    .map(({ name }) => name);
-}
-
-function hasAllowedProxyTool(
-  entry: Pick<ServerCacheEntry, "tools" | "resources">,
-  serverName: string,
-  definition: ServerEntry,
-  prefix: ToolPrefix,
-  selectorIndex: ToolSelectorCandidateIndex | undefined,
-  toolName: string | undefined,
-): boolean {
-  if (toolName === undefined) return true;
-  const matchesAllowedName = (baseName: string) => {
-    if (!isToolAllowed(baseName, serverName, prefix, definition.includeTools, definition.excludeTools, selectorIndex)) return false;
-    return toolName === formatToolName(baseName, serverName, prefix);
-  };
-  if (entry.tools.some((tool: CachedTool) =>
-    isUiToolVisibleToModel(tool.uiVisibility) &&
-    matchesAllowedName(tool.name)
-  )) return true;
-  if (definition.exposeResources === false) return false;
-  return (entry.resources ?? []).some((resource) => {
-    const baseName = `read_${resourceNameToToolName(resource.name)}`;
-    return matchesAllowedName(baseName);
-  });
-}
-
-function addName(names: string[], seen: Set<string>, name: string): void {
-  if (seen.has(name)) return;
-  seen.add(name);
-  names.push(name);
-}
-
-function resolveKnownServerReference(
-  parsed: ParsedMcpReference,
-  config: McpConfig,
-  cache: MetadataCache | null,
-  envOverride: DirectToolSelectorOverride | null,
-  collidingNamespaceNames: ReadonlySet<string>,
-  existingDirectNames: ReadonlySet<string>,
-  directNameOwners: ReadonlyMap<string, DirectNameOwner>,
-  selectorIndex: ToolSelectorCandidateIndex | undefined,
-  names: string[],
-  seen: Set<string>,
-  diagnostics: string[],
-): void {
-  const serverName = parsed.server!;
-  const definition = config.mcpServers[serverName];
-  if (!definition || isServerDisabled(definition)) {
-    diagnostics.push(`MCP reference "${parsed.raw}" refers to disabled or unknown server "${serverName}"`);
-    return;
-  }
-  const entry = resolveValidCache(definition, cache, serverName);
-  if (!entry) {
-    diagnostics.push(`MCP reference "${parsed.raw}" cannot be resolved: no valid cached metadata for server "${serverName}"`);
-    return;
-  }
-
-  const prefix = resolveToolPrefix(definition, config.settings?.toolPrefix);
-  const selection = resolveDirectSelection(config, definition, serverName, envOverride);
-  const directNames = ownedDirectToolNames(
-    directNameEntries(entry, serverName, definition, prefix, selection, selectorIndex, parsed.tool),
-    serverName,
-    directNameOwners,
-  );
-  if (directNames.length > 0) {
-    for (const name of directNames) addName(names, seen, name);
-    return;
-  }
-
-  if (hasNamespaceProxy(config, cache, envOverride, collidingNamespaceNames, existingDirectNames, serverName)) {
-    if (hasAllowedProxyTool(entry, serverName, definition, prefix, selectorIndex, parsed.tool)) {
-      addName(names, seen, namespaceProxyName(serverName));
-      return;
-    }
-    diagnostics.push(`MCP reference "${parsed.raw}" refers to unknown or hidden tool "${parsed.tool}" on server "${serverName}"`);
-    return;
-  }
-
-  diagnostics.push(`MCP reference "${parsed.raw}" resolves to no registered tool`);
-}
-
-function resolveBareToolReference(
-  raw: string,
-  toolName: string,
-  config: McpConfig,
-  cache: MetadataCache | null,
-  envOverride: DirectToolSelectorOverride | null,
-  collidingNamespaceNames: ReadonlySet<string>,
-  existingDirectNames: ReadonlySet<string>,
-  directNameOwners: ReadonlyMap<string, DirectNameOwner>,
-  selectorIndex: ToolSelectorCandidateIndex | undefined,
-  names: string[],
-  seen: Set<string>,
-  diagnostics: string[],
-): void {
-  let matched = false;
-  for (const { serverName, definition, entry, prefix } of cachedServers(config, cache)) {
-    const selection = resolveDirectSelection(config, definition, serverName, envOverride);
-    const directNames = ownedDirectToolNames(
-      directNameEntries(entry, serverName, definition, prefix, selection, selectorIndex, toolName),
-      serverName,
-      directNameOwners,
-    );
-    for (const name of directNames) {
-      addName(names, seen, name);
-      matched = true;
-    }
-    if (hasNamespaceProxy(config, cache, envOverride, collidingNamespaceNames, existingDirectNames, serverName) &&
-        hasAllowedProxyTool(entry, serverName, definition, prefix, selectorIndex, toolName)) {
-      addName(names, seen, namespaceProxyName(serverName));
-      matched = true;
-    }
-  }
-  if (!matched) diagnostics.push(`MCP reference "${raw}" does not match a configured server or cached tool`);
-}
-
-export function resolveMcpToolReferences(
-  refs: string[],
-  config: McpConfig | null,
-  cache: MetadataCache | null,
-  envOverride?: string[],
-): McpReferenceResolution {
-  const names: string[] = [];
-  const diagnostics: string[] = [];
-  const seen = new Set<string>();
-
-  if (!config) {
-    return {
-      names: refs.filter((ref) => !ref.startsWith("mcp:")),
-      diagnostics: refs.filter((ref) => ref.startsWith("mcp:")).map((ref) => `MCP reference "${ref}" cannot be resolved: no MCP config`),
-    };
-  }
-
-  const parsedOverride = envOverride ? parseDirectToolSelectors(envOverride) : null;
-  const selectorIndex = allCurrentCandidates(config, cache);
-  const directNameOwners = registeredDirectNames(config, cache, parsedOverride, selectorIndex);
-  const directNames = new Set(directNameOwners.keys());
-  const collidingNamespaceNames = namespaceCollisionNames(config, cache, parsedOverride, directNames);
-
-  for (const ref of refs) {
-    if (!ref.startsWith("mcp:")) {
-      addName(names, seen, ref);
-      continue;
-    }
-    const parsed = parseMcpReference(ref);
-    if (!parsed.server) {
-      diagnostics.push(`MCP reference "${ref}" is empty after the "mcp:" prefix`);
-      continue;
-    }
-    if (config.mcpServers[parsed.server]) {
-      resolveKnownServerReference(parsed, config, cache, parsedOverride, collidingNamespaceNames, directNames, directNameOwners, selectorIndex, names, seen, diagnostics);
-    } else if (parsed.tool === undefined) {
-      resolveBareToolReference(ref, parsed.server, config, cache, parsedOverride, collidingNamespaceNames, directNames, directNameOwners, selectorIndex, names, seen, diagnostics);
-    } else {
-      diagnostics.push(`MCP reference "${ref}" refers to unknown server "${parsed.server}"`);
-    }
-  }
-
-  return { names, diagnostics };
-}