codex-plugin-doctor 1.51.0 → 1.52.0

package/dist/core/remote-url-policy.d.ts

@@ -0,0 +1,7 @@
+export interface RemoteUrlInspection {
+    parsedUrl: URL | null;
+    sanitizedUrl: string | null;
+    isLoopbackHost: boolean;
+    issues: Array<"invalid" | "unsupported_scheme" | "credentials" | "query" | "fragment" | "ip_literal" | "insecure_non_loopback">;
+}
+export declare function inspectRemoteMcpUrl(rawUrl: string): RemoteUrlInspection;

package/dist/core/remote-url-policy.js

@@ -0,0 +1,49 @@
+function isIpLiteral(hostname) {
+    return (/^\d{1,3}(?:\.\d{1,3}){3}$/.test(hostname) ||
+        /^\[[0-9a-f:.]+\]$/i.test(hostname));
+}
+export function inspectRemoteMcpUrl(rawUrl) {
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(rawUrl);
+    }
+    catch {
+        return {
+            parsedUrl: null,
+            sanitizedUrl: null,
+            isLoopbackHost: false,
+            issues: ["invalid"]
+        };
+    }
+    const issues = [];
+    const isSupportedScheme = parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:";
+    const isAbsoluteHttpUrl = /^https?:\/\//i.test(rawUrl);
+    const isLoopbackHost = parsedUrl.hostname.toLowerCase() === "localhost";
+    if (!isSupportedScheme) {
+        issues.push("unsupported_scheme");
+    }
+    else if (!isAbsoluteHttpUrl || !parsedUrl.hostname) {
+        issues.push("invalid");
+    }
+    if (parsedUrl.username || parsedUrl.password) {
+        issues.push("credentials");
+    }
+    if (parsedUrl.search || rawUrl.includes("?")) {
+        issues.push("query");
+    }
+    if (parsedUrl.hash || rawUrl.includes("#")) {
+        issues.push("fragment");
+    }
+    if (isIpLiteral(parsedUrl.hostname)) {
+        issues.push("ip_literal");
+    }
+    if (parsedUrl.protocol === "http:" && !isLoopbackHost) {
+        issues.push("insecure_non_loopback");
+    }
+    return {
+        parsedUrl,
+        sanitizedUrl: `${parsedUrl.origin}${parsedUrl.pathname}`,
+        isLoopbackHost,
+        issues
+    };
+}

package/dist/core/runtime-plan.d.ts

@@ -4,6 +4,7 @@ import type { RuntimeExecutionEvidence, RuntimeSandboxMode } from "../domain/typ
 type RuntimePlanStatus = "pass" | "warn" | "fail";
 type RuntimePlanRiskLevel = "low" | "medium" | "high";
 type RuntimePlanTransport = "stdio" | "http";
+type RemoteNetworkClass = "public_https" | "loopback_http" | "loopback_https" | "invalid";
 export interface RuntimePlanServer {
     name: string;
     transport: RuntimePlanTransport;
@@ -11,7 +12,9 @@ export interface RuntimePlanServer {
     args: string[];
     cwd: string | null;
     url: string | null;
+    networkClass?: RemoteNetworkClass;
     probeMethods: string[];
+    approvalRequirements?: string[];
     riskLevel: RuntimePlanRiskLevel;
     riskReasons: string[];
 }

package/dist/core/runtime-plan.js

@@ -5,6 +5,7 @@ import { discoverPackage } from "./discover-package.js";
 import { readJsonFile } from "./read-json-file.js";
 import { buildSecurityAudit } from "../security/security-audit.js";
 import { DOCKER_RUNTIME_IMAGE } from "./runtime-sandbox.js";
+import { inspectRemoteMcpUrl } from "./remote-url-policy.js";
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -47,6 +48,26 @@ function buildRisk(serverName, serverConfig, findings) {
         riskReasons: [...new Set(riskReasons)]
     };
 }
+function remoteProbeMethods() {
+    return [
+        "POST initialize",
+        "POST notifications/initialized",
+        "GET OAuth protected-resource metadata (401 only)",
+        "GET OAuth authorization-server metadata (401 only)"
+    ];
+}
+function remoteNetworkClass(rawUrl) {
+    const inspection = inspectRemoteMcpUrl(rawUrl);
+    if (inspection.parsedUrl === null ||
+        (inspection.parsedUrl.protocol !== "http:" && inspection.parsedUrl.protocol !== "https:") ||
+        !inspection.parsedUrl.hostname) {
+        return "invalid";
+    }
+    if (inspection.isLoopbackHost) {
+        return inspection.parsedUrl.protocol === "http:" ? "loopback_http" : "loopback_https";
+    }
+    return "public_https";
+}
 function planDigestPayload(plan) {
     return {
         schemaVersion: plan.schemaVersion,
@@ -119,6 +140,8 @@ export async function buildDoctorRuntimePlan(targetPath, generatedAt = new Date(
         const command = typeof serverConfig.command === "string" ? serverConfig.command : null;
         const url = typeof serverConfig.url === "string" ? serverConfig.url : null;
         const { riskLevel, riskReasons } = buildRisk(serverName, serverConfig, security.findings);
+        const networkClass = url ? remoteNetworkClass(url) : undefined;
+        const sanitizedUrl = url ? inspectRemoteMcpUrl(url).sanitizedUrl : null;
         return {
             name: serverName,
             transport: command ? "stdio" : "http",
@@ -127,7 +150,8 @@ export async function buildDoctorRuntimePlan(targetPath, generatedAt = new Date(
                 ? serverConfig.args.filter((arg) => typeof arg === "string")
                 : [],
             cwd: command ? normalizeCwd(discoveredPackage.rootPath, serverConfig.cwd) : null,
-            url,
+            url: sanitizedUrl,
+            ...(networkClass ? { networkClass } : {}),
             probeMethods: command
                 ? [
                     "initialize",
@@ -140,7 +164,14 @@ export async function buildDoctorRuntimePlan(targetPath, generatedAt = new Date(
                     "prompts/list",
                     "prompts/get:first-prompt-only"
                 ]
-                : [],
+                : url ? remoteProbeMethods() : [],
+            ...(url
+                ? {
+                    approvalRequirements: networkClass === "loopback_http" || networkClass === "loopback_https"
+                        ? ["--runtime", "--allow-network", "--allow-local-network"]
+                        : ["--runtime", "--allow-network"]
+                }
+                : {}),
             riskLevel,
             riskReasons
         };
@@ -247,6 +278,7 @@ export function renderDoctorRuntimePlanMarkdown(plan) {
         "- This plan is non-executing.",
         "- Probe methods explicitly exclude task create, get, result, and cancel operations, plus sampling and elicitation requests.",
         "- Runtime probes require explicit operator approval before local MCP servers are started.",
+        "- Any remote target whose DNS resolves to loopback requires `--allow-local-network`, even if its URL looks public.",
         "- The approval digest changes when command, args, cwd, probe methods, risk reasons, or findings change.",
         "- Runtime approval is a review gate, not an OS, VM, or container sandbox.",
         "",

package/dist/core/runtime-policy.js

@@ -38,7 +38,8 @@ function strongestDecision(decisions) {
     return "allow";
 }
 function buildRecommendation(plan, decision, reasons) {
-    if (plan.summary.executableServerCount === 0) {
+    const hasRemoteServer = plan.servers.some((server) => server.transport === "http");
+    if (plan.summary.executableServerCount === 0 && !hasRemoteServer) {
         return {
             decision: "allow",
             reason: "No executable local MCP runtime servers were found.",
@@ -78,6 +79,9 @@ function buildRecommendation(plan, decision, reasons) {
             actions: [
                 "Review command, args, cwd, URL, probe methods, and risk reasons before execution.",
                 "Approve the exact plan digest with `check --runtime --require-runtime-approval --runtime-approval-digest <digest>`.",
+                ...(hasRemoteServer
+                    ? ["Remote MCP probing also requires `--runtime --allow-network`; any target that DNS resolves to loopback additionally requires `--allow-local-network`."]
+                    : []),
                 "Use `doctor runtime-plan --markdown` when the approval needs to be preserved with release evidence."
             ]
         };

package/dist/core/runtime-probe.d.ts

@@ -1,8 +1,15 @@
 import type { DiscoveredPackage, RuntimeProbeResult, RuntimeSandboxMode } from "../domain/types.js";
+import { type RemoteMcpRequest } from "./remote-mcp-probe.js";
+import type { RemoteLookup } from "./remote-network-policy.js";
 export declare function probeRuntime(discoveredPackage: DiscoveredPackage, options?: RuntimeProbeOptions): Promise<RuntimeProbeResult>;
 export interface RuntimeProbeOptions {
     startupTimeoutMs?: number;
     sandbox?: RuntimeSandboxMode;
     transcript?: (line: string) => void;
+    allowNetwork?: boolean;
+    allowLocalNetwork?: boolean;
+    remoteRequestTimeoutMs?: number;
+    remoteLookup?: RemoteLookup;
+    remoteRequest?: RemoteMcpRequest;
 }
 export declare function probeRuntimeConfig(rootPath: string, mcpConfigPath: string, options?: RuntimeProbeOptions): Promise<RuntimeProbeResult>;

package/dist/core/runtime-probe.js

@@ -4,6 +4,7 @@ import { readFile, realpath, stat } from "node:fs/promises";
 import path from "node:path";
 import readline from "node:readline";
 import { evaluateMcpConformance } from "./mcp-conformance.js";
+import { probeRemoteMcpServer } from "./remote-mcp-probe.js";
 import { buildRuntimeLaunch, DOCKER_RUNTIME_STARTUP_TIMEOUT_MS, RuntimeSandboxError } from "./runtime-sandbox.js";
 import { formatRequestTranscript as formatRequestTranscriptForLog, formatResponseTranscript as formatResponseTranscriptForLog } from "./runtime-transcript.js";
 const MCP_PROTOCOL_VERSION = "2025-11-25";
@@ -322,6 +323,9 @@ function mergeRuntimeScorecards(left, right) {
             overall: worstRuntimeStatus(leftConformance.overall, rightConformance.overall)
         }
         : leftConformance ?? rightConformance;
+    const remote = left.remote && right.remote
+        ? mergeRemoteRuntimeScorecards(left.remote, right.remote)
+        : left.remote ?? right.remote;
     return {
         initialize: worstRuntimeStatus(left.initialize, right.initialize),
         toolsList: worstRuntimeStatus(left.toolsList, right.toolsList),
@@ -331,7 +335,27 @@ function mergeRuntimeScorecards(left, right) {
         resourceTemplatesList: worstRuntimeStatus(left.resourceTemplatesList, right.resourceTemplatesList),
         promptsList: worstRuntimeStatus(left.promptsList, right.promptsList),
         promptGet: worstRuntimeStatus(left.promptGet, right.promptGet),
-        ...(conformance ? { conformance } : {})
+        ...(conformance ? { conformance } : {}),
+        ...(remote ? { remote } : {})
+    };
+}
+function mergeRemoteRuntimeScorecards(left, right) {
+    const sessionSeverity = {
+        "present-invalid": 2,
+        "present-valid": 1,
+        absent: 0
+    };
+    return {
+        transport: worstRuntimeStatus(left.transport, right.transport),
+        networkSafety: worstRuntimeStatus(left.networkSafety, right.networkSafety),
+        initialize: worstRuntimeStatus(left.initialize, right.initialize),
+        contentType: worstRuntimeStatus(left.contentType, right.contentType),
+        session: sessionSeverity[left.session] >= sessionSeverity[right.session]
+            ? left.session
+            : right.session,
+        protocolHeaders: worstRuntimeStatus(left.protocolHeaders, right.protocolHeaders),
+        authorization: worstRuntimeStatus(left.authorization, right.authorization),
+        overall: worstRuntimeStatus(left.overall, right.overall)
     };
 }
 function supportsTasksListProbe(protocolVersion, capabilities) {
@@ -1266,35 +1290,54 @@ export async function probeRuntimeConfig(rootPath, mcpConfigPath, options = {})
         if (!isPlainObject(config)) {
             continue;
         }
-        const command = config.command;
-        if (typeof command !== "string") {
-            continue;
-        }
-        const args = Array.isArray(config.args)
-            ? config.args.filter((value) => typeof value === "string")
-            : [];
-        const cwd = await resolveRuntimeCwd(canonicalRootPath, config.cwd);
-        const result = cwd === null
-            ? (() => {
-                const invalidCwdScorecard = createRuntimeScorecard();
-                invalidCwdScorecard.initialize = "fail";
-                return {
-                    findings: [
-                        withRuntimeEvidence(buildFailure("plugin.runtime.startup.invalid_cwd", `The MCP server \`${serverName}\` has an invalid runtime working directory.`, "Runtime validation must not start a server from a missing, non-directory, or out-of-package working directory.", "Set the MCP server cwd to an existing directory inside the plugin package root, or remove it."), serverName)
-                    ],
-                    scorecard: invalidCwdScorecard
-                };
-            })()
-            : await probeCommandServer({
-                serverName,
-                packageRoot: canonicalRootPath,
-                command,
-                args,
-                cwd,
-                startupTimeoutMs,
-                sandbox: options.sandbox,
-                transcript: options.transcript
+        const url = config.url;
+        let result;
+        if (typeof url === "string") {
+            const remote = await probeRemoteMcpServer(serverName, url, {
+                allowNetwork: options.allowNetwork,
+                allowLocalNetwork: options.allowLocalNetwork,
+                requestTimeoutMs: options.remoteRequestTimeoutMs,
+                lookup: options.remoteLookup,
+                request: options.remoteRequest
             });
+            const remoteScorecard = createRuntimeScorecard();
+            remoteScorecard.remote = remote.scorecard;
+            result = {
+                findings: remote.findings.map((finding) => withRuntimeEvidence(finding, serverName)),
+                scorecard: remoteScorecard
+            };
+        }
+        else {
+            const command = config.command;
+            if (typeof command !== "string") {
+                continue;
+            }
+            const args = Array.isArray(config.args)
+                ? config.args.filter((value) => typeof value === "string")
+                : [];
+            const cwd = await resolveRuntimeCwd(canonicalRootPath, config.cwd);
+            result = cwd === null
+                ? (() => {
+                    const invalidCwdScorecard = createRuntimeScorecard();
+                    invalidCwdScorecard.initialize = "fail";
+                    return {
+                        findings: [
+                            withRuntimeEvidence(buildFailure("plugin.runtime.startup.invalid_cwd", `The MCP server \`${serverName}\` has an invalid runtime working directory.`, "Runtime validation must not start a server from a missing, non-directory, or out-of-package working directory.", "Set the MCP server cwd to an existing directory inside the plugin package root, or remove it."), serverName)
+                        ],
+                        scorecard: invalidCwdScorecard
+                    };
+                })()
+                : await probeCommandServer({
+                    serverName,
+                    packageRoot: canonicalRootPath,
+                    command,
+                    args,
+                    cwd,
+                    startupTimeoutMs,
+                    sandbox: options.sandbox,
+                    transcript: options.transcript
+                });
+        }
         scorecard = hasProbedServer
             ? mergeRuntimeScorecards(scorecard, result.scorecard)
             : result.scorecard;

package/dist/core/validate-plugin.js

@@ -2,6 +2,7 @@ import { readFile, readdir, stat } from "node:fs/promises";
 import path from "node:path";
 import { withFindingFingerprints } from "../reporting/finding-fingerprint.js";
 import { discoverPackage } from "./discover-package.js";
+import { inspectRemoteMcpUrl } from "./remote-url-policy.js";
 import { probeRuntime } from "./runtime-probe.js";
 function buildFailure(id, message, impact, suggestedFix, evidence) {
     return {
@@ -23,6 +24,16 @@ function buildWarning(id, message, impact, suggestedFix, evidence) {
         ...(evidence ? { evidence } : {})
     };
 }
+function remoteUrlIssueFindingId(issue) {
+    return issue === "insecure_non_loopback"
+        ? "plugin.security.insecure_http_url"
+        : `plugin.security.remote_mcp_url.${issue}`;
+}
+function remoteUrlIssueMessage(issue) {
+    return issue === "insecure_non_loopback"
+        ? "uses an insecure public HTTP URL"
+        : `uses a remote MCP URL with ${issue.replaceAll("_", " ")}`;
+}
 async function directoryExists(targetPath) {
     try {
         const details = await stat(targetPath);
@@ -376,6 +387,24 @@ async function validateMcpConfig(discoveredPackage) {
                 field: "transport"
             }));
         }
+        if (typeof command === "string" && typeof url === "string") {
+            findings.push(buildFailure("plugin.mcp.server.transport.conflict", `The MCP server \`${serverName}\` must not define both \`command\` and \`url\`.`, "A server with two transports cannot be selected deterministically by MCP clients.", `Keep either \`command\` or \`url\` for the \`${serverName}\` entry in \`${mcpConfigPath}\`.`, {
+                configPath: relativePackagePath(rootPath, mcpConfigPath),
+                serverName,
+                field: "transport"
+            }));
+        }
+        if (typeof url === "string") {
+            const inspection = inspectRemoteMcpUrl(url);
+            for (const issue of inspection.issues) {
+                findings.push(buildFailure(remoteUrlIssueFindingId(issue), `The MCP server \`${serverName}\` ${remoteUrlIssueMessage(issue)}.`, "Unsafe or ambiguous remote transport configuration can expose credentials or prevent reliable MCP connectivity.", "Use an absolute HTTPS URL without credentials, query parameters, fragments, or numeric IP literals; HTTP is only supported for localhost development.", {
+                    configPath: relativePackagePath(rootPath, mcpConfigPath),
+                    serverName,
+                    field: "url",
+                    url: inspection.sanitizedUrl
+                }));
+            }
+        }
         if (isPlainObject(env)) {
             for (const [envKey, envValue] of Object.entries(env)) {
                 if (isSensitiveKey(envKey) &&
@@ -415,7 +444,9 @@ export async function validatePlugin(targetPath, options = {}) {
         ? await probeRuntime(discoveredPackage, {
             startupTimeoutMs: options.runtimeStartupTimeoutMs,
             sandbox: options.runtimeSandbox,
-            transcript: options.runtimeTranscript
+            transcript: options.runtimeTranscript,
+            allowNetwork: options.allowNetwork,
+            allowLocalNetwork: options.allowLocalNetwork
         })
         : null;
     const findings = [

package/dist/domain/types.d.ts

@@ -41,6 +41,8 @@ export interface BaselineSummary {
 }
 export interface CheckOptions {
     runtime?: boolean;
+    allowNetwork?: boolean;
+    allowLocalNetwork?: boolean;
     runtimeTranscript?: (line: string) => void;
     runtimeStartupTimeoutMs?: number;
     runtimeSandbox?: RuntimeSandboxMode;
@@ -91,6 +93,17 @@ export interface RuntimeScorecard {
     promptsList: RuntimeCapabilityStatus;
     promptGet: RuntimeCapabilityStatus;
     conformance?: RuntimeConformanceScorecard;
+    remote?: RemoteRuntimeScorecard;
+}
+export interface RemoteRuntimeScorecard {
+    transport: RuntimeCapabilityStatus;
+    networkSafety: RuntimeCapabilityStatus;
+    initialize: RuntimeCapabilityStatus;
+    contentType: RuntimeCapabilityStatus;
+    session: "absent" | "present-valid" | "present-invalid";
+    protocolHeaders: RuntimeCapabilityStatus;
+    authorization: RuntimeCapabilityStatus;
+    overall: "pass" | "warn" | "fail" | "skipped";
 }
 export type McpConformanceProfile = "legacy" | "2025-11-25" | "future-compatible";
 export interface RuntimeConformanceScorecard {

package/dist/index.d.ts

@@ -18,6 +18,10 @@ export { buildDoctorExportBundleFromAnalysis, buildDoctorRecommendationsFromAnal
 export { buildDoctorPerformanceReport, renderDoctorPerformanceReport, renderDoctorPerformanceReportJson, type BuildDoctorPerformanceReportOptions, type DoctorPerformanceReport, type DoctorPerformanceStage, type DoctorPerformanceStageName } from "./core/performance-report.js";
 export { buildDoctorRuntimePlan, evaluateRuntimeApproval, renderDoctorRuntimePlan, renderDoctorRuntimePlanMarkdown, renderDoctorRuntimePlanJson, runtimeApprovalPassed, type DoctorRuntimePlan, type RuntimeApprovalReport, type RuntimePlanServer } from "./core/runtime-plan.js";
 export { buildDoctorRuntimePolicyReport, renderDoctorRuntimePolicy, renderDoctorRuntimePolicyJson, type DoctorRuntimePolicyReport, type RuntimePolicyDecision, type RuntimePolicyRecommendation } from "./core/runtime-policy.js";
+export { inspectRemoteMcpUrl, type RemoteUrlInspection } from "./core/remote-url-policy.js";
+export { resolveRemoteTarget, RemoteNetworkPolicyError, type ResolvedRemoteTarget, type ResolveRemoteTargetOptions } from "./core/remote-network-policy.js";
+export { probeRemoteMcpServer, type RemoteMcpProbeOptions, type RemoteMcpProbeResult } from "./core/remote-mcp-probe.js";
+export { checkRemoteOAuthReadiness, type RemoteOAuthReadinessOptions, type RemoteOAuthReadinessResult } from "./core/remote-oauth-readiness.js";
 export { buildDoctorReviewBundle, diffDoctorReviewBundles, renderDoctorReviewBundle, renderDoctorReviewBundleDiff, renderDoctorReviewBundleDiffJson, renderDoctorReviewBundleJson, renderDoctorReviewBundleVerification, renderDoctorReviewBundleVerificationJson, verifyDoctorReviewBundle, type BuildDoctorReviewBundleOptions, type DoctorReviewBundle, type DoctorReviewBundleDiffChange, type DoctorReviewBundleDiffReport, type DoctorReviewBundleDiffSnapshot, type DoctorReviewBundleManifest, type DoctorReviewBundleVerificationReport } from "./core/review-bundle.js";
 export { buildDoctorReleaseEvidenceAssetReport, buildDoctorReleaseEvidenceReport, renderDoctorReleaseEvidenceAsset, renderDoctorReleaseEvidenceAssetJson, renderDoctorReleaseEvidence, renderDoctorReleaseEvidenceJson, renderDoctorReleaseEvidenceVerification, renderDoctorReleaseEvidenceVerificationJson, verifyDoctorReleaseEvidence, type BuildDoctorReleaseEvidenceOptions, type DoctorReleaseEvidenceAssetReport, type DoctorReleaseEvidenceGitMetadata, type DoctorReleaseEvidencePackageMetadata, type DoctorReleaseEvidenceReport, type DoctorReleaseEvidenceVerificationReport } from "./core/release-evidence.js";
 export { buildDoctorNpmPackageReport, renderDoctorNpmPackageReport, renderDoctorNpmPackageReportJson, type BuildDoctorNpmPackageReportOptions, type DoctorNpmPackageReport } from "./core/npm-package-doctor.js";

package/dist/index.js

@@ -18,6 +18,10 @@ export { buildDoctorExportBundleFromAnalysis, buildDoctorRecommendationsFromAnal
 export { buildDoctorPerformanceReport, renderDoctorPerformanceReport, renderDoctorPerformanceReportJson } from "./core/performance-report.js";
 export { buildDoctorRuntimePlan, evaluateRuntimeApproval, renderDoctorRuntimePlan, renderDoctorRuntimePlanMarkdown, renderDoctorRuntimePlanJson, runtimeApprovalPassed } from "./core/runtime-plan.js";
 export { buildDoctorRuntimePolicyReport, renderDoctorRuntimePolicy, renderDoctorRuntimePolicyJson } from "./core/runtime-policy.js";
+export { inspectRemoteMcpUrl } from "./core/remote-url-policy.js";
+export { resolveRemoteTarget, RemoteNetworkPolicyError } from "./core/remote-network-policy.js";
+export { probeRemoteMcpServer } from "./core/remote-mcp-probe.js";
+export { checkRemoteOAuthReadiness } from "./core/remote-oauth-readiness.js";
 export { buildDoctorReviewBundle, diffDoctorReviewBundles, renderDoctorReviewBundle, renderDoctorReviewBundleDiff, renderDoctorReviewBundleDiffJson, renderDoctorReviewBundleJson, renderDoctorReviewBundleVerification, renderDoctorReviewBundleVerificationJson, verifyDoctorReviewBundle } from "./core/review-bundle.js";
 export { buildDoctorReleaseEvidenceAssetReport, buildDoctorReleaseEvidenceReport, renderDoctorReleaseEvidenceAsset, renderDoctorReleaseEvidenceAssetJson, renderDoctorReleaseEvidence, renderDoctorReleaseEvidenceJson, renderDoctorReleaseEvidenceVerification, renderDoctorReleaseEvidenceVerificationJson, verifyDoctorReleaseEvidence } from "./core/release-evidence.js";
 export { buildDoctorNpmPackageReport, renderDoctorNpmPackageReport, renderDoctorNpmPackageReportJson } from "./core/npm-package-doctor.js";

package/dist/mcp/generic-mcp-doctor.d.ts

@@ -15,6 +15,8 @@ export interface GenericMcpDoctorReport {
 }
 export interface GenericMcpDoctorOptions {
     runtime?: boolean;
+    allowNetwork?: boolean;
+    allowLocalNetwork?: boolean;
     runtimeStartupTimeoutMs?: number;
 }
 export declare function buildGenericMcpDoctor(targetPath: string, environment?: CompatibilityEnvironment, options?: GenericMcpDoctorOptions): Promise<GenericMcpDoctorReport>;

package/dist/mcp/generic-mcp-doctor.js

@@ -64,9 +64,14 @@ function buildStaticMcpFindings(configPath, parsedConfig) {
             findings.push(buildFinding("fail", "mcp.server.invalid", `The MCP server \`${serverName}\` must be configured as an object.`, "MCP clients cannot interpret a server entry unless it is represented as an object with server options.", `Change the \`${serverName}\` entry in \`${configPath}\` to an object.`, { configPath, serverName, field: "server" }));
             continue;
         }
-        if (typeof serverConfig.command !== "string" && typeof serverConfig.url !== "string") {
+        const command = serverConfig.command;
+        const url = serverConfig.url;
+        if (typeof command !== "string" && typeof url !== "string") {
             findings.push(buildFinding("fail", "mcp.server.transport.missing", `The MCP server \`${serverName}\` must define either \`command\` or \`url\`.`, "MCP clients need a process command for stdio servers or a URL for remote servers.", `Add either \`command\` or \`url\` to the \`${serverName}\` entry in \`${configPath}\`.`, { configPath, serverName, field: "transport" }));
         }
+        if (typeof command === "string" && typeof url === "string") {
+            findings.push(buildFinding("fail", "mcp.server.transport.conflict", `The MCP server \`${serverName}\` must not define both \`command\` and \`url\`.`, "A server with two transports cannot be selected deterministically by MCP clients.", `Keep either \`command\` or \`url\` for the \`${serverName}\` entry in \`${configPath}\`.`, { configPath, serverName, field: "transport" }));
+        }
     }
     return {
         serverCount: Object.keys(servers).length,
@@ -124,7 +129,7 @@ export async function buildGenericMcpDoctor(targetPath, environment = {}, option
         }
     }
     const security = buildSecurityAuditFromFindings(rootPath, mcpConfigPath && parsedConfig !== null
-        ? auditMcpServerConfig(rootPath, parsedConfig)
+        ? auditMcpServerConfig(rootPath, parsedConfig, { configPath: mcpConfigPath })
         : []);
     const runtimeResult = options.runtime &&
         mcpConfigPath !== null &&
@@ -135,7 +140,9 @@ export async function buildGenericMcpDoctor(targetPath, environment = {}, option
         !staticFindings.some((finding) => finding.severity === "fail") &&
         security.status !== "fail"
         ? await probeRuntimeConfig(canonicalRootPath, canonicalMcpConfigPath, {
-            startupTimeoutMs: options.runtimeStartupTimeoutMs
+            startupTimeoutMs: options.runtimeStartupTimeoutMs,
+            allowNetwork: options.allowNetwork,
+            allowLocalNetwork: options.allowLocalNetwork
         })
         : null;
     const fingerprintedFindings = withFindingFingerprints([...staticFindings, ...(runtimeResult?.findings ?? [])], rootPath);

package/dist/reporting/render-markdown-report.js

@@ -17,19 +17,32 @@ function appendRuntimeScorecard(lines, result) {
     lines.push(`| prompts/list | ${result.runtimeScorecard.promptsList.toUpperCase()} |`);
     lines.push(`| prompts/get | ${result.runtimeScorecard.promptGet.toUpperCase()} |`);
     const conformance = result.runtimeScorecard.conformance;
-    if (!conformance) {
-        return;
+    if (conformance) {
+        lines.push("", "## MCP Conformance", "");
+        lines.push("| Check | Status |");
+        lines.push("| --- | --- |");
+        lines.push(`| Protocol version | ${conformance.protocolVersion ?? "unavailable"} |`);
+        lines.push(`| Profile | ${conformance.profile ?? "unavailable"} |`);
+        lines.push(`| Capability consistency | ${conformance.capabilityConsistency.toUpperCase()} |`);
+        lines.push(`| Task declarations | ${conformance.taskDeclarations.toUpperCase()} |`);
+        lines.push(`| Tasks list | ${conformance.tasksList.toUpperCase()} |`);
+        lines.push(`| Schema dialect | ${conformance.schemaDialect.toUpperCase()} |`);
+        lines.push(`| Overall | ${conformance.overall.toUpperCase()} |`);
+    }
+    const remote = result.runtimeScorecard.remote;
+    if (remote) {
+        lines.push("", "## Remote MCP Scorecard", "");
+        lines.push("| Check | Status |");
+        lines.push("| --- | --- |");
+        lines.push(`| Transport | ${remote.transport.toUpperCase()} |`);
+        lines.push(`| Network safety | ${remote.networkSafety.toUpperCase()} |`);
+        lines.push(`| Initialize | ${remote.initialize.toUpperCase()} |`);
+        lines.push(`| Content type | ${remote.contentType.toUpperCase()} |`);
+        lines.push(`| Session | ${remote.session.toUpperCase()} |`);
+        lines.push(`| Protocol headers | ${remote.protocolHeaders.toUpperCase()} |`);
+        lines.push(`| Authorization | ${remote.authorization.toUpperCase()} |`);
+        lines.push(`| Overall | ${remote.overall.toUpperCase()} |`);
     }
-    lines.push("", "## MCP Conformance", "");
-    lines.push("| Check | Status |");
-    lines.push("| --- | --- |");
-    lines.push(`| Protocol version | ${conformance.protocolVersion ?? "unavailable"} |`);
-    lines.push(`| Profile | ${conformance.profile ?? "unavailable"} |`);
-    lines.push(`| Capability consistency | ${conformance.capabilityConsistency.toUpperCase()} |`);
-    lines.push(`| Task declarations | ${conformance.taskDeclarations.toUpperCase()} |`);
-    lines.push(`| Tasks list | ${conformance.tasksList.toUpperCase()} |`);
-    lines.push(`| Schema dialect | ${conformance.schemaDialect.toUpperCase()} |`);
-    lines.push(`| Overall | ${conformance.overall.toUpperCase()} |`);
 }
 export function buildMarkdownReport(result, options) {
     const failCount = result.findings.filter((finding) => finding.severity === "fail").length;

package/dist/reporting/render-text-report.js

@@ -38,17 +38,28 @@ function appendRuntimeScorecard(lines, result) {
     lines.push(`prompts/list: ${result.runtimeScorecard.promptsList}`);
     lines.push(`prompts/get: ${result.runtimeScorecard.promptGet}`);
     const conformance = result.runtimeScorecard.conformance;
-    if (!conformance) {
-        return;
+    if (conformance) {
+        lines.push("", "MCP Conformance", "---------------");
+        lines.push(`Protocol version: ${conformance.protocolVersion ?? "unavailable"}`);
+        lines.push(`Profile: ${conformance.profile ?? "unavailable"}`);
+        lines.push(`Capability consistency: ${conformance.capabilityConsistency}`);
+        lines.push(`Task declarations: ${conformance.taskDeclarations}`);
+        lines.push(`Tasks list: ${conformance.tasksList}`);
+        lines.push(`Schema dialect: ${conformance.schemaDialect}`);
+        lines.push(`Overall: ${conformance.overall}`);
+    }
+    const remote = result.runtimeScorecard.remote;
+    if (remote) {
+        lines.push("", "Remote MCP Scorecard", "--------------------");
+        lines.push(`transport: ${remote.transport}`);
+        lines.push(`network safety: ${remote.networkSafety}`);
+        lines.push(`initialize: ${remote.initialize}`);
+        lines.push(`content type: ${remote.contentType}`);
+        lines.push(`session: ${remote.session}`);
+        lines.push(`protocol headers: ${remote.protocolHeaders}`);
+        lines.push(`authorization: ${remote.authorization}`);
+        lines.push(`overall: ${remote.overall}`);
     }
-    lines.push("", "MCP Conformance", "---------------");
-    lines.push(`Protocol version: ${conformance.protocolVersion ?? "unavailable"}`);
-    lines.push(`Profile: ${conformance.profile ?? "unavailable"}`);
-    lines.push(`Capability consistency: ${conformance.capabilityConsistency}`);
-    lines.push(`Task declarations: ${conformance.taskDeclarations}`);
-    lines.push(`Tasks list: ${conformance.tasksList}`);
-    lines.push(`Schema dialect: ${conformance.schemaDialect}`);
-    lines.push(`Overall: ${conformance.overall}`);
 }
 export function renderTextReport(result, options = {}) {
     const ascii = options.ascii ?? false;