codex-plugin-doctor 1.69.1 → 1.71.0

package/dist/core/mcp-discovery.d.ts

@@ -26,4 +26,23 @@ export interface McpDiscoveryReport {
 export declare function findMcpSseResponse(body: Buffer, requestId?: string): McpJsonObject | null;
 export declare function parseMcpResponse(response: BoundedHttpResponse, requestId?: string): McpJsonObject | null;
 export declare function discoverMcpCapabilities(response: BoundedHttpResponse, requestId?: string): McpJsonObject | null;
+export declare function serializeMcpDiscoverRequest(requestId?: string): string;
+export type McpDiscoverOutcome = {
+    kind: "discovered";
+    supportedVersions: string[];
+    capabilities: McpJsonObject;
+} | {
+    kind: "version-not-listed";
+    supportedVersions: string[];
+} | {
+    kind: "version-unsupported";
+    supportedVersions: string[];
+} | {
+    kind: "result-invalid";
+} | {
+    kind: "envelope-invalid";
+} | {
+    kind: "other-error";
+};
+export declare function classifyMcpDiscoverMessage(message: McpJsonObject, requestId?: string): McpDiscoverOutcome;
 export declare function discoverMcpServer(rawUrl: string, options?: McpDiscoveryOptions): Promise<McpDiscoveryReport>;

package/dist/core/mcp-discovery.js

@@ -102,6 +102,29 @@ export function discoverMcpCapabilities(response, requestId = REQUEST_ID) {
         return null;
     return result.supportedVersions.includes(REQUESTED_VERSION) ? capabilities : null;
 }
+export function serializeMcpDiscoverRequest(requestId = REQUEST_ID) {
+    return JSON.stringify({ jsonrpc: "2.0", id: requestId, method: "server/discover", params: { _meta: {
+                "io.modelcontextprotocol/protocolVersion": REQUESTED_VERSION,
+                "io.modelcontextprotocol/clientInfo": { name: "Codex Plugin Doctor", version: packageVersion },
+                "io.modelcontextprotocol/clientCapabilities": {}
+            } } });
+}
+// Classifies a transport-neutral server/discover reply. Only a valid result or a valid
+// UnsupportedProtocolVersionError identifies a modern server; other errors do not.
+export function classifyMcpDiscoverMessage(message, requestId = REQUEST_ID) {
+    if (!hasMatchingResponseEnvelope(message, requestId))
+        return { kind: "envelope-invalid" };
+    if (Object.hasOwn(message, "error")) {
+        const versions = unsupportedVersions(message.error);
+        return versions === null ? { kind: "other-error" } : { kind: "version-unsupported", supportedVersions: versions };
+    }
+    const result = message.result;
+    if (!validDiscoverResult(result))
+        return { kind: "result-invalid" };
+    return result.supportedVersions.includes(REQUESTED_VERSION)
+        ? { kind: "discovered", supportedVersions: result.supportedVersions, capabilities: result.capabilities }
+        : { kind: "version-not-listed", supportedVersions: result.supportedVersions };
+}
 function failureReport(id, message) {
     return report("failed", "fail", [finding(id, "fail", message, "The discovery response cannot safely establish modern MCP discovery support.", "Verify the endpoint returns a valid server/discover response for the requested protocol version.")]);
 }
@@ -116,11 +139,7 @@ export async function discoverMcpServer(rawUrl, options = {}) {
         return report("blocked", "skipped", [finding("plugin.discovery.url.invalid", "warn", "The MCP discovery endpoint is unsafe or unsupported.", "Unsafe endpoint URLs can bypass network controls or expose credentials.", "Use an absolute HTTP or HTTPS endpoint without credentials, query parameters, fragments, or IP literals.")]);
     }
     const request = options.request ?? requestBoundedHttp;
-    const body = JSON.stringify({ jsonrpc: "2.0", id: REQUEST_ID, method: "server/discover", params: { _meta: {
-                "io.modelcontextprotocol/protocolVersion": REQUESTED_VERSION,
-                "io.modelcontextprotocol/clientInfo": { name: "Codex Plugin Doctor", version: packageVersion },
-                "io.modelcontextprotocol/clientCapabilities": {}
-            } } });
+    const body = serializeMcpDiscoverRequest();
     let response;
     try {
         response = await request(rawUrl, {

package/dist/core/mcp-stdio-tool-catalog.d.ts

@@ -0,0 +1,31 @@
+import { spawn } from "node:child_process";
+import type { RuntimeSandboxMode } from "../domain/types.js";
+import { type McpToolCatalogSnapshot } from "./mcp-tool-catalog.js";
+export interface McpStdioServer {
+    packageRoot: string;
+    command: string;
+    args: string[];
+    cwd: string;
+    source: "manifest" | "mcp-json";
+}
+export type McpStdioServerResolution = {
+    ok: true;
+    server: McpStdioServer;
+} | {
+    ok: false;
+    message: string;
+};
+export interface McpStdioToolCatalogOptions {
+    sandbox?: RuntimeSandboxMode;
+    now?: () => number;
+    spawnImpl?: typeof spawn;
+    removeContainerImpl?: (containerName: string) => Promise<boolean>;
+    timeouts?: {
+        startupMs?: number;
+        requestMs?: number;
+        totalMs?: number;
+        shutdownMs?: number;
+    };
+}
+export declare function resolveMcpStdioServer(targetPath: string, serverName: string): Promise<McpStdioServerResolution>;
+export declare function captureStdioMcpToolCatalog(server: McpStdioServer, options?: McpStdioToolCatalogOptions): Promise<McpToolCatalogSnapshot>;