codex-plugin-doctor 1.51.0 → 1.53.0

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,17 @@
-import type { DiscoveredPackage, RuntimeProbeResult, RuntimeSandboxMode } from "../domain/types.js";
+import type { DiscoveredPackage, RuntimeProbeResult, RuntimeSandboxMode, RuntimeScorecard } 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;
+    allowSessionLifecycle?: boolean;
+    remoteRequestTimeoutMs?: number;
+    remoteLookup?: RemoteLookup;
+    remoteRequest?: RemoteMcpRequest;
 }
+export declare function remoteReliabilityGatePassed(scorecard: RuntimeScorecard | undefined): boolean;
 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,39 @@ 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
+    };
+    const reliability = left.reliability && right.reliability
+        ? {
+            getSse: worstRuntimeStatus(left.reliability.getSse, right.reliability.getSse),
+            sessionPropagation: worstRuntimeStatus(left.reliability.sessionPropagation, right.reliability.sessionPropagation),
+            resumability: worstRuntimeStatus(left.reliability.resumability, right.reliability.resumability),
+            disconnectSafety: worstRuntimeStatus(left.reliability.disconnectSafety, right.reliability.disconnectSafety),
+            sessionRestart: worstRuntimeStatus(left.reliability.sessionRestart, right.reliability.sessionRestart),
+            termination: worstRuntimeStatus(left.reliability.termination, right.reliability.termination),
+            overall: worstRuntimeStatus(left.reliability.overall, right.reliability.overall)
+        }
+        : left.reliability ?? right.reliability;
+    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),
+        ...(reliability ? { reliability } : {})
     };
 }
 function supportsTasksListProbe(protocolVersion, capabilities) {
@@ -1227,6 +1263,10 @@ export async function probeRuntime(discoveredPackage, options = {}) {
     }
     return probeRuntimeConfig(rootPath, manifest.mcpServers, options);
 }
+export function remoteReliabilityGatePassed(scorecard) {
+    return scorecard !== undefined &&
+        (scorecard.remote === undefined || scorecard.remote.reliability?.overall === "pass");
+}
 export async function probeRuntimeConfig(rootPath, mcpConfigPath, options = {}) {
     const resolvedRootPath = path.resolve(rootPath);
     const resolvedMcpConfigPath = path.resolve(resolvedRootPath, mcpConfigPath);
@@ -1266,35 +1306,55 @@ 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,
+                allowSessionLifecycle: options.allowSessionLifecycle,
+                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/sse-observation.d.ts

@@ -0,0 +1,7 @@
+export interface SseObservation {
+    complete: boolean;
+    eventId: string | null;
+    retryMs: number | null;
+    malformed: boolean;
+}
+export declare function observeFirstSseEvent(body: Buffer): SseObservation;

package/dist/core/sse-observation.js

@@ -0,0 +1,67 @@
+const MAX_SSE_FIELD_BYTES = 1_024;
+function isSafeEventId(value) {
+    return value.length > 0
+        && value.length <= MAX_SSE_FIELD_BYTES
+        && value.every((byte) => byte >= 0x21 && byte <= 0x7e);
+}
+function parseRetry(value) {
+    if (value.length === 0 || value.length > MAX_SSE_FIELD_BYTES) {
+        return null;
+    }
+    for (const byte of value) {
+        if (byte < 0x30 || byte > 0x39) {
+            return null;
+        }
+    }
+    const retryMs = Number(value.toString("ascii"));
+    return Number.isSafeInteger(retryMs) ? retryMs : null;
+}
+export function observeFirstSseEvent(body) {
+    let eventId = null;
+    let retryMs = null;
+    let malformed = false;
+    let lineStart = 0;
+    for (let index = 0; index < body.length; index += 1) {
+        if (body[index] !== 0x0a && body[index] !== 0x0d) {
+            continue;
+        }
+        const line = body.subarray(lineStart, index);
+        if (body[index] === 0x0d && body[index + 1] === 0x0a) {
+            index += 1;
+        }
+        lineStart = index + 1;
+        if (line.length === 0) {
+            return {
+                complete: true,
+                eventId: malformed ? null : eventId,
+                retryMs: malformed ? null : retryMs,
+                malformed
+            };
+        }
+        if (line[0] === 0x3a) {
+            continue;
+        }
+        const separator = line.indexOf(0x3a);
+        const field = separator === -1 ? line : line.subarray(0, separator);
+        const valueStart = separator === -1 ? line.length : separator + 1;
+        const value = line.subarray(valueStart + (line[valueStart] === 0x20 ? 1 : 0));
+        if (field.equals(Buffer.from("id"))) {
+            if (value.length === 0) {
+                eventId = null;
+            }
+            else if (isSafeEventId(value)) {
+                eventId = value.toString("ascii");
+            }
+            else {
+                malformed = true;
+            }
+        }
+        else if (field.equals(Buffer.from("retry"))) {
+            const parsedRetryMs = parseRetry(value);
+            if (parsedRetryMs !== null) {
+                retryMs = parsedRetryMs;
+            }
+        }
+    }
+    return { complete: false, eventId: null, retryMs: null, malformed: false };
+}

package/dist/core/validate-plugin.js

@@ -2,7 +2,8 @@ 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 { probeRuntime } from "./runtime-probe.js";
+import { inspectRemoteMcpUrl } from "./remote-url-policy.js";
+import { probeRuntime, remoteReliabilityGatePassed } from "./runtime-probe.js";
 function buildFailure(id, message, impact, suggestedFix, evidence) {
     return {
         id,
@@ -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,10 @@ 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,
+            allowSessionLifecycle: options.allowSessionLifecycle
         })
         : null;
     const findings = [
@@ -423,7 +455,7 @@ export async function validatePlugin(targetPath, options = {}) {
         ...(runtimeResult?.findings ?? [])
     ];
     const fingerprintedFindings = withFindingFingerprints(findings, discoveredPackage.rootPath);
-    const hasFailures = fingerprintedFindings.some((finding) => finding.severity === "fail");
+    const hasFailures = fingerprintedFindings.some((finding) => finding.severity === "fail") || (options.requireRemoteReliability === true && !remoteReliabilityGatePassed(runtimeResult?.scorecard));
     const hasWarnings = fingerprintedFindings.some((finding) => finding.severity === "warn");
     if (!hasFailures && !hasWarnings) {
         return {

package/dist/domain/types.d.ts

@@ -41,6 +41,10 @@ export interface BaselineSummary {
 }
 export interface CheckOptions {
     runtime?: boolean;
+    allowNetwork?: boolean;
+    allowLocalNetwork?: boolean;
+    allowSessionLifecycle?: boolean;
+    requireRemoteReliability?: boolean;
     runtimeTranscript?: (line: string) => void;
     runtimeStartupTimeoutMs?: number;
     runtimeSandbox?: RuntimeSandboxMode;
@@ -91,6 +95,28 @@ 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;
+    reliability?: RemoteTransportReliabilityScorecard;
+    overall: "pass" | "warn" | "fail" | "skipped";
+}
+export type RemoteTransportReliabilityStatus = "pass" | "warn" | "fail" | "skipped";
+export interface RemoteTransportReliabilityScorecard {
+    getSse: RemoteTransportReliabilityStatus;
+    sessionPropagation: RemoteTransportReliabilityStatus;
+    resumability: RemoteTransportReliabilityStatus;
+    disconnectSafety: RemoteTransportReliabilityStatus;
+    sessionRestart: RemoteTransportReliabilityStatus;
+    termination: RemoteTransportReliabilityStatus;
+    overall: RemoteTransportReliabilityStatus;
 }
 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,10 @@ export interface GenericMcpDoctorReport {
 }
 export interface GenericMcpDoctorOptions {
     runtime?: boolean;
+    allowNetwork?: boolean;
+    allowLocalNetwork?: boolean;
+    allowSessionLifecycle?: boolean;
+    requireRemoteReliability?: boolean;
     runtimeStartupTimeoutMs?: number;
 }
 export declare function buildGenericMcpDoctor(targetPath: string, environment?: CompatibilityEnvironment, options?: GenericMcpDoctorOptions): Promise<GenericMcpDoctorReport>;

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

@@ -2,7 +2,7 @@ import { realpath, stat } from "node:fs/promises";
 import path from "node:path";
 import { buildCompatibilityMatrix, readMcpConfigPath } from "../compatibility/compatibility-matrix.js";
 import { readJsonFile } from "../core/read-json-file.js";
-import { probeRuntimeConfig } from "../core/runtime-probe.js";
+import { probeRuntimeConfig, remoteReliabilityGatePassed } from "../core/runtime-probe.js";
 import { formatFindingFingerprintLine, withFindingFingerprints } from "../reporting/finding-fingerprint.js";
 import { auditMcpServerConfig, buildSecurityAuditFromFindings } from "../security/security-audit.js";
 function buildFinding(severity, id, message, impact, suggestedFix, evidence) {
@@ -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,11 +140,16 @@ 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,
+            allowSessionLifecycle: options.allowSessionLifecycle
         })
         : null;
     const fingerprintedFindings = withFindingFingerprints([...staticFindings, ...(runtimeResult?.findings ?? [])], rootPath);
-    const status = mergeReportStatus(fingerprintedFindings, security);
+    const status = options.requireRemoteReliability === true && !remoteReliabilityGatePassed(runtimeResult?.scorecard)
+        ? "fail"
+        : mergeReportStatus(fingerprintedFindings, security);
     return {
         targetPath: rootPath,
         status,

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

@@ -17,19 +17,45 @@ 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()} |`);
+        if (remote.reliability) {
+            const reliability = remote.reliability;
+            lines.push("", "## Remote Transport Reliability", "");
+            lines.push("| Check | Status |");
+            lines.push("| --- | --- |");
+            lines.push(`| GET SSE | ${reliability.getSse.toUpperCase()} |`);
+            lines.push(`| Session propagation | ${reliability.sessionPropagation.toUpperCase()} |`);
+            lines.push(`| Resumability | ${reliability.resumability.toUpperCase()} |`);
+            lines.push(`| Disconnect safety | ${reliability.disconnectSafety.toUpperCase()} |`);
+            lines.push(`| Session restart | ${reliability.sessionRestart.toUpperCase()} |`);
+            lines.push(`| Termination | ${reliability.termination.toUpperCase()} |`);
+            lines.push(`| Overall | ${reliability.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;