codex-plugin-doctor 1.50.0 → 1.52.0

package/dist/core/output-contract.js

@@ -1,11 +1,101 @@
 import { createHash } from "node:crypto";
 import { packageVersion } from "../version.js";
 import { ruleCatalog } from "../rules/rule-catalog.js";
+const runtimeCapabilityStatusSchema = {
+    type: "string",
+    enum: ["pass", "fail", "warn", "skipped", "unsupported"]
+};
+const runtimeConformanceSchema = {
+    type: "object",
+    properties: {
+        protocolVersion: {
+            type: ["string", "null"]
+        },
+        profile: {
+            type: ["string", "null"],
+            enum: ["legacy", "2025-11-25", "future-compatible", null]
+        },
+        capabilityConsistency: runtimeCapabilityStatusSchema,
+        taskDeclarations: runtimeCapabilityStatusSchema,
+        tasksList: runtimeCapabilityStatusSchema,
+        schemaDialect: runtimeCapabilityStatusSchema,
+        overall: {
+            type: "string",
+            enum: ["pass", "warn", "fail", "skipped"]
+        }
+    },
+    required: [
+        "protocolVersion",
+        "profile",
+        "capabilityConsistency",
+        "taskDeclarations",
+        "tasksList",
+        "schemaDialect",
+        "overall"
+    ],
+    additionalProperties: false
+};
+const remoteRuntimeScorecardSchema = {
+    type: "object",
+    properties: {
+        transport: runtimeCapabilityStatusSchema,
+        networkSafety: runtimeCapabilityStatusSchema,
+        initialize: runtimeCapabilityStatusSchema,
+        contentType: runtimeCapabilityStatusSchema,
+        session: {
+            type: "string",
+            enum: ["absent", "present-valid", "present-invalid"]
+        },
+        protocolHeaders: runtimeCapabilityStatusSchema,
+        authorization: runtimeCapabilityStatusSchema,
+        overall: {
+            type: "string",
+            enum: ["pass", "warn", "fail", "skipped"]
+        }
+    },
+    required: ["transport", "networkSafety", "initialize", "contentType", "session", "protocolHeaders", "authorization", "overall"],
+    additionalProperties: false
+};
+const runtimeScorecardSchema = {
+    type: "object",
+    properties: {
+        initialize: runtimeCapabilityStatusSchema,
+        toolsList: runtimeCapabilityStatusSchema,
+        toolsCall: runtimeCapabilityStatusSchema,
+        resourcesList: runtimeCapabilityStatusSchema,
+        resourceRead: runtimeCapabilityStatusSchema,
+        resourceTemplatesList: runtimeCapabilityStatusSchema,
+        promptsList: runtimeCapabilityStatusSchema,
+        promptGet: runtimeCapabilityStatusSchema,
+        conformance: runtimeConformanceSchema,
+        remote: remoteRuntimeScorecardSchema
+    },
+    required: [
+        "initialize",
+        "toolsList",
+        "toolsCall",
+        "resourcesList",
+        "resourceRead",
+        "resourceTemplatesList",
+        "promptsList",
+        "promptGet"
+    ],
+    additionalProperties: false
+};
 const publicSchemaDefinitions = [
     {
         id: "doctor.check.json",
         command: "codex-plugin-doctor check <path> --json",
-        required: ["schemaVersion", "generatedAt", "summary", "findings"]
+        required: ["schemaVersion", "generatedAt", "summary", "findings"],
+        properties: {
+            summary: {
+                type: "object",
+                properties: {
+                    runtimeScorecard: runtimeScorecardSchema
+                },
+                additionalProperties: true
+            }
+        }
     },
     {
         id: "doctor.installed.check.json",
@@ -27,7 +117,13 @@ const publicSchemaDefinitions = [
         id: "doctor.mcp.json",
         command: "codex-plugin-doctor mcp <path> --json",
         outputKind: "doctor.mcp.healthcheck",
-        required: ["schemaVersion", "kind", "generatedAt", "targetPath", "status", "serverCount", "findings", "security", "compatibility"]
+        required: ["schemaVersion", "kind", "generatedAt", "targetPath", "status", "serverCount", "findings", "security", "compatibility"],
+        properties: {
+            runtimeScorecard: {
+                ...runtimeScorecardSchema,
+                description: "Present only when codex-plugin-doctor mcp <path> --runtime is used."
+            }
+        }
     },
     {
         id: "doctor.audit.json",
@@ -271,7 +367,7 @@ function contractRules(rules) {
     }))
         .sort((left, right) => left.id.localeCompare(right.id));
 }
-function buildSchema(id, outputKind, required) {
+function buildSchema(id, outputKind, required, schemaProperties = {}) {
     const properties = {
         schemaVersion: {
             const: "1.0.0"
@@ -288,7 +384,10 @@ function buildSchema(id, outputKind, required) {
         title: id,
         type: "object",
         required: [...new Set(["schemaVersion", ...required])],
-        properties,
+        properties: {
+            ...properties,
+            ...schemaProperties
+        },
         additionalProperties: true
     };
 }
@@ -301,7 +400,7 @@ function buildSchemas() {
             schemaVersion: "1.0.0",
             stability: "stable-through-1.0",
             outputKind,
-            schema: buildSchema(definition.id, outputKind, definition.required ?? [])
+            schema: buildSchema(definition.id, outputKind, definition.required ?? [], definition.properties)
         };
     });
 }

package/dist/core/release-check.d.ts

@@ -41,6 +41,8 @@ export interface BuildReleaseCheckOptions {
     env?: Record<string, string | undefined>;
     platform?: NodeJS.Platform;
     runtime?: boolean;
+    allowNetwork?: boolean;
+    allowLocalNetwork?: boolean;
     runtimeSandbox?: RuntimeSandboxMode;
     runCheck?: (targetPath: string, options: CheckOptions) => Promise<CheckResult>;
 }

package/dist/core/release-check.js

@@ -106,6 +106,8 @@ export async function buildReleaseCheck(targetPath, options = {}) {
     const runtimeProbeEnabled = options.runtime ?? false;
     const validationResult = await (options.runCheck ?? validatePlugin)(resolvedPath, {
         runtime: runtimeProbeEnabled,
+        ...(options.allowNetwork ? { allowNetwork: true } : {}),
+        ...(options.allowLocalNetwork ? { allowLocalNetwork: true } : {}),
         ...(options.runtimeSandbox ? { runtimeSandbox: options.runtimeSandbox } : {})
     });
     const securityResult = await buildSecurityAudit(resolvedPath);

package/dist/core/release-evidence.d.ts

@@ -111,6 +111,8 @@ export interface BuildDoctorReleaseEvidenceOptions {
     requireRuntimeApproval?: boolean;
     runtimeApprovalDigest?: string | null;
     runtime?: boolean;
+    allowNetwork?: boolean;
+    allowLocalNetwork?: boolean;
     sandbox?: RuntimeSandboxMode;
     environment?: CompatibilityEnvironment;
     runCheck?: (targetPath: string, options?: CheckOptions) => Promise<CheckResult>;

package/dist/core/release-evidence.js

@@ -192,17 +192,126 @@ function signReleaseEvidence(report, signingKey, keyHint) {
         keyHint
     };
 }
+function buildRuntimeApprovalFailureReport(rootPath, runtimePlan, runtimeApproval, options) {
+    const generatedAt = new Date().toISOString();
+    const emptyDigest = sha256("");
+    const failureMessage = "Release evidence checks were not run because runtime approval did not pass.";
+    const report = {
+        schemaVersion: "1.0.0",
+        kind: "doctor.release.evidence",
+        generatedAt,
+        version: packageVersion,
+        targetPath: rootPath,
+        status: "fail",
+        exitCode: 1,
+        releaseReady: false,
+        summary: {
+            attestation: "fail",
+            attestationVerification: "fail",
+            corpus: "fail",
+            performance: "fail",
+            releaseGates: "fail",
+            runtimeApproval: "fail",
+            security: "fail",
+            trust: "fail"
+        },
+        releaseGates: {
+            status: "fail",
+            checks: [{ id: "runtime.approval", status: "fail", message: runtimeApproval.message }]
+        },
+        runtimeApproval,
+        ...(options.runtime ? { execution: runtimePlan.execution } : {}),
+        package: { name: null, version: null, private: null },
+        git: { commit: null, tag: null, dirty: null },
+        attestation: {
+            schemaVersion: "1.0.0",
+            kind: "doctor.attestation",
+            generatedAt,
+            version: packageVersion,
+            targetPath: rootPath,
+            subject: { name: "unavailable", version: null, description: null },
+            packageFingerprint: { algorithm: "sha256", digest: emptyDigest, files: { total: 0, bytes: 0 } },
+            reportDigest: { algorithm: "sha256", digest: emptyDigest },
+            summary: {
+                status: "fail",
+                validation: { status: "fail", findingCount: 0 },
+                security: { status: "fail", score: 0, findingCount: 0 },
+                compatibility: { failedClients: [] },
+                trust: { status: "fail", score: 0, findingCount: 0 },
+                recommendations: { actionCount: 0 }
+            },
+            verification: { recomputeCommand: "", notes: [failureMessage] },
+            signature: { status: "unsigned", reason: failureMessage }
+        },
+        attestationVerification: {
+            schemaVersion: "1.0.0",
+            kind: "doctor.attestation.verification",
+            generatedAt,
+            artifactPath: "inline:doctor.release-evidence.attestation",
+            targetPath: rootPath,
+            status: "fail",
+            exitCode: 1,
+            summary: { packageFingerprint: "fail", reportDigest: "fail", signature: "fail" },
+            unsignedFields: [],
+            checks: [{ id: "runtime.approval", status: "fail", message: runtimeApproval.message }]
+        },
+        corpus: {
+            schemaVersion: "1.0.0",
+            kind: "doctor.validation.corpus",
+            generatedAt,
+            version: packageVersion,
+            summary: { status: "fail", caseCount: 0, passedExpectations: 0, failedExpectations: 0, runtimeCases: 0 },
+            cases: []
+        },
+        performance: {
+            schemaVersion: "1.0.0",
+            kind: "doctor.perf",
+            generatedAt,
+            targetPath: rootPath,
+            status: "fail",
+            exitCode: 1,
+            summary: {
+                stageCount: 0,
+                slowestStage: "total",
+                totalDurationMs: 0,
+                validationStatus: "fail",
+                securityStatus: "fail",
+                trustScore: 0,
+                compatibilityFailures: 0,
+                thresholdFailures: 0
+            },
+            stages: [],
+            thresholds: []
+        },
+        security: { status: "fail", score: 0, findingCounts: { fail: 0, warn: 0, total: 0 } },
+        trust: { status: "fail", score: 0, findingCounts: { fail: 0, warn: 0, total: 0 } }
+    };
+    return {
+        ...report,
+        evidenceSignature: signReleaseEvidence(report, options.signingKey, `env:${options.signingKeyEnv}`)
+    };
+}
 export async function buildDoctorReleaseEvidenceReport(targetPath, options) {
     const rootPath = path.resolve(targetPath);
+    const runtimePlan = await buildDoctorRuntimePlan(rootPath, new Date().toISOString(), options.sandbox ? { sandbox: options.sandbox } : {});
+    const runtimeApproval = evaluateRuntimeApproval(runtimePlan, {
+        required: options.requireRuntimeApproval ?? false,
+        approvedDigest: options.runtimeApprovalDigest
+    });
+    if (!runtimeApprovalPassed(runtimeApproval)) {
+        return buildRuntimeApprovalFailureReport(rootPath, runtimePlan, runtimeApproval, options);
+    }
     const security = await buildSecurityAudit(rootPath);
     const runCheck = options.runCheck ?? validatePlugin;
     const checkOptions = options.runtime
         ? {
             runtime: true,
+            ...(options.allowNetwork ? { allowNetwork: true } : {}),
+            ...(options.allowLocalNetwork ? { allowLocalNetwork: true } : {}),
             ...(options.sandbox ? { runtimeSandbox: options.sandbox } : {})
         }
         : {};
-    const [attestation, corpus, performance, trust, packageMetadata, git, runtimePlan] = await Promise.all([
+    const [attestation, corpus, performance, trust, packageMetadata, git] = await Promise.all([
         buildDoctorAttestation(rootPath, {
             signingKey: options.signingKey,
             signingKeyHint: `env:${options.signingKeyEnv}`,
@@ -216,8 +325,7 @@ export async function buildDoctorReleaseEvidenceReport(targetPath, options) {
         }),
         buildTrustScore(rootPath, { securityAudit: security }),
         readPackageMetadata(rootPath),
-        readGitMetadata(rootPath),
-        buildDoctorRuntimePlan(rootPath, new Date().toISOString(), options.sandbox ? { sandbox: options.sandbox } : {})
+        readGitMetadata(rootPath)
     ]);
     const normalizedPackageMetadata = {
         name: packageMetadata.name ?? attestation.subject.name,
@@ -229,10 +337,6 @@ export async function buildDoctorReleaseEvidenceReport(targetPath, options) {
         artifactPath: "inline:doctor.release-evidence.attestation"
     });
     const releaseGates = buildReleaseGateReport(git, options);
-    const runtimeApproval = evaluateRuntimeApproval(runtimePlan, {
-        required: options.requireRuntimeApproval ?? false,
-        approvedDigest: options.runtimeApprovalDigest
-    });
     const partialReport = {
         schemaVersion: "1.0.0",
         kind: "doctor.release.evidence",

package/dist/core/remote-mcp-probe.d.ts

@@ -0,0 +1,16 @@
+import { type BoundedHttpRequestOptions, type BoundedHttpResponse } from "./bounded-http-client.js";
+import { type RemoteLookup } from "./remote-network-policy.js";
+import type { Finding, RemoteRuntimeScorecard } from "../domain/types.js";
+export type RemoteMcpRequest = (rawUrl: string, options?: BoundedHttpRequestOptions) => Promise<BoundedHttpResponse>;
+export interface RemoteMcpProbeOptions {
+    allowNetwork?: boolean;
+    allowLocalNetwork?: boolean;
+    requestTimeoutMs?: number;
+    lookup?: RemoteLookup;
+    request?: RemoteMcpRequest;
+}
+export interface RemoteMcpProbeResult {
+    findings: Finding[];
+    scorecard: RemoteRuntimeScorecard;
+}
+export declare function probeRemoteMcpServer(serverName: string, rawUrl: string, options?: RemoteMcpProbeOptions): Promise<RemoteMcpProbeResult>;

package/dist/core/remote-mcp-probe.js

@@ -0,0 +1,226 @@
+import { BoundedHttpError, requestBoundedHttp } from "./bounded-http-client.js";
+import { RemoteNetworkPolicyError } from "./remote-network-policy.js";
+import { checkRemoteOAuthReadiness } from "./remote-oauth-readiness.js";
+import { inspectRemoteMcpUrl } from "./remote-url-policy.js";
+import { packageVersion } from "../version.js";
+const MCP_PROTOCOL_VERSION = "2025-11-25";
+function createScorecard() {
+    return {
+        transport: "skipped",
+        networkSafety: "skipped",
+        initialize: "skipped",
+        contentType: "skipped",
+        session: "absent",
+        protocolHeaders: "skipped",
+        authorization: "skipped",
+        overall: "skipped"
+    };
+}
+function failure(id, message, impact, suggestedFix) {
+    return { id, severity: "fail", message, impact, suggestedFix };
+}
+function finalize(scorecard, findings) {
+    scorecard.overall = findings.some((finding) => finding.severity === "fail")
+        ? "fail"
+        : findings.some((finding) => finding.severity === "warn")
+            ? "warn"
+            : scorecard.initialize === "pass" || scorecard.authorization === "pass"
+                ? "pass"
+                : "skipped";
+    return { findings, scorecard };
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function responseHeader(headers, name) {
+    const value = headers[name];
+    return typeof value === "string" ? value : null;
+}
+function mediaType(value) {
+    return value?.split(";", 1)[0]?.trim().toLowerCase() ?? null;
+}
+function parseJsonObject(source) {
+    try {
+        const parsed = JSON.parse(source);
+        return isPlainObject(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isInitializeResponseCandidate(message) {
+    return message.id === 1;
+}
+function findSseInitializeResponse(body) {
+    const text = body.toString("utf8").replace(/\r\n/g, "\n");
+    let offset = 0;
+    while (offset < text.length) {
+        const boundary = text.indexOf("\n\n", offset);
+        if (boundary === -1) {
+            return null;
+        }
+        const data = text.slice(offset, boundary).split("\n")
+            .filter((line) => line.startsWith("data:"))
+            .map((line) => line.slice(5).replace(/^ /, ""));
+        const message = data.length > 0 ? parseJsonObject(data.join("\n")) : null;
+        if (message && isInitializeResponseCandidate(message)) {
+            return message;
+        }
+        offset = boundary + 2;
+    }
+    return null;
+}
+function parseInitializeResponse(body, contentType) {
+    return contentType === "text/event-stream"
+        ? findSseInitializeResponse(body)
+        : parseJsonObject(body.toString("utf8"));
+}
+function isValidInitializeResponse(message) {
+    return (message.jsonrpc === "2.0" &&
+        message.id === 1 &&
+        isPlainObject(message.result) &&
+        message.result.protocolVersion === MCP_PROTOCOL_VERSION &&
+        isPlainObject(message.result.capabilities) &&
+        isPlainObject(message.result.serverInfo) &&
+        typeof message.result.serverInfo.name === "string" &&
+        typeof message.result.serverInfo.version === "string");
+}
+function validSessionId(value) {
+    return value !== null && /^[\x21-\x7e]+$/.test(value);
+}
+function transportFailureId(error) {
+    if (error instanceof BoundedHttpError) {
+        if (error.code === "REMOTE_HTTP_TIMEOUT")
+            return "plugin.runtime.remote.transport.timeout";
+        if (error.code === "REMOTE_HTTP_RESPONSE_TOO_LARGE")
+            return "plugin.runtime.remote.transport.response_too_large";
+    }
+    return "plugin.runtime.remote.transport.failed";
+}
+function transportStatus(error) {
+    return error instanceof RemoteNetworkPolicyError
+        ? "skipped"
+        : "fail";
+}
+export async function probeRemoteMcpServer(serverName, rawUrl, options = {}) {
+    const scorecard = createScorecard();
+    const findings = [];
+    const request = options.request ?? requestBoundedHttp;
+    if (!options.allowNetwork) {
+        scorecard.networkSafety = "fail";
+        findings.push(failure("plugin.runtime.remote.network_not_approved", `The remote MCP server \`${serverName}\` was not contacted because network probing is not approved.`, "Remote MCP initialization can create outbound network traffic and must be explicitly approved.", "Enable remote network probing only after reviewing the server endpoint."));
+        return finalize(scorecard, findings);
+    }
+    const inspection = inspectRemoteMcpUrl(rawUrl);
+    if (inspection.issues.length > 0) {
+        scorecard.networkSafety = "fail";
+        findings.push(failure("plugin.runtime.remote.url.invalid", `The remote MCP server \`${serverName}\` has an unsafe or unsupported endpoint URL.`, "Unsafe remote endpoint URLs can bypass network controls or expose credentials.", "Use an absolute HTTP or HTTPS endpoint without credentials, query parameters, fragments, or IP literals."));
+        return finalize(scorecard, findings);
+    }
+    scorecard.networkSafety = "pass";
+    const initializeBody = JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: "Codex Plugin Doctor", version: packageVersion }
+        }
+    });
+    let initializeResponse;
+    try {
+        initializeResponse = await request(rawUrl, {
+            allowLocalNetwork: options.allowLocalNetwork,
+            lookup: options.lookup,
+            timeoutMs: options.requestTimeoutMs,
+            method: "POST",
+            body: initializeBody,
+            headers: {
+                Accept: "application/json, text/event-stream",
+                "Content-Type": "application/json"
+            },
+            stopAfter: (body) => findSseInitializeResponse(body) !== null
+        });
+    }
+    catch (error) {
+        scorecard.transport = transportStatus(error);
+        if (error instanceof RemoteNetworkPolicyError) {
+            scorecard.networkSafety = "fail";
+        }
+        findings.push(failure(transportFailureId(error), `The remote MCP server \`${serverName}\` could not complete a bounded initialize request.`, "A failed transport prevents safe MCP protocol negotiation.", "Verify the endpoint is reachable and complies with the configured remote network policy."));
+        return finalize(scorecard, findings);
+    }
+    scorecard.transport = "pass";
+    if (initializeResponse.statusCode === 401) {
+        const challenge = initializeResponse.headers["www-authenticate"];
+        const readiness = await checkRemoteOAuthReadiness(inspection.sanitizedUrl ?? rawUrl, challenge === undefined ? [] : [challenge], {
+            request,
+            requestOptions: {
+                allowLocalNetwork: options.allowLocalNetwork,
+                lookup: options.lookup,
+                timeoutMs: options.requestTimeoutMs
+            }
+        });
+        scorecard.authorization = readiness.status;
+        findings.push(...readiness.findings);
+        return finalize(scorecard, findings);
+    }
+    if (initializeResponse.statusCode !== 200) {
+        scorecard.initialize = "fail";
+        findings.push(failure("plugin.runtime.remote.http_status.invalid", `The remote MCP server \`${serverName}\` returned an unexpected initialize HTTP status.`, "Streamable HTTP MCP initialization requires a successful response before protocol negotiation can continue.", "Return HTTP 200 for initialize, or configure authorization before probing a protected endpoint."));
+        return finalize(scorecard, findings);
+    }
+    const contentType = mediaType(responseHeader(initializeResponse.headers, "content-type"));
+    if (contentType !== "application/json" && contentType !== "text/event-stream") {
+        scorecard.contentType = "fail";
+        scorecard.initialize = "fail";
+        findings.push(failure("plugin.runtime.remote.content_type.invalid", `The remote MCP server \`${serverName}\` returned an unsupported initialize content type.`, "MCP initialization responses must be JSON or Server-Sent Events so the JSON-RPC result can be validated.", "Return application/json or text/event-stream with a JSON-RPC initialize response."));
+        return finalize(scorecard, findings);
+    }
+    scorecard.contentType = "pass";
+    const sessionId = responseHeader(initializeResponse.headers, "mcp-session-id");
+    if (sessionId !== null && !validSessionId(sessionId)) {
+        scorecard.session = "present-invalid";
+        scorecard.initialize = "fail";
+        findings.push(failure("plugin.runtime.remote.session.invalid", `The remote MCP server \`${serverName}\` returned an invalid MCP session header.`, "Invalid session identifiers cannot be safely replayed on the initialized notification.", "Return MCP-Session-Id only as visible ASCII characters."));
+        return finalize(scorecard, findings);
+    }
+    if (sessionId !== null) {
+        scorecard.session = "present-valid";
+    }
+    const initializeMessage = parseInitializeResponse(initializeResponse.body, contentType);
+    if (!initializeMessage || !isValidInitializeResponse(initializeMessage)) {
+        scorecard.initialize = "fail";
+        findings.push(failure("plugin.runtime.remote.initialize.invalid", `The remote MCP server \`${serverName}\` returned an invalid initialize JSON-RPC result.`, "A malformed initialize result prevents protocol version negotiation.", "Return a JSON-RPC 2.0 result with id 1 and protocol version 2025-11-25."));
+        return finalize(scorecard, findings);
+    }
+    scorecard.initialize = "pass";
+    try {
+        const initializedResponse = await request(rawUrl, {
+            allowLocalNetwork: options.allowLocalNetwork,
+            lookup: options.lookup,
+            timeoutMs: options.requestTimeoutMs,
+            method: "POST",
+            body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }),
+            headers: {
+                Accept: "application/json, text/event-stream",
+                "Content-Type": "application/json",
+                "MCP-Protocol-Version": MCP_PROTOCOL_VERSION,
+                ...(sessionId === null ? {} : { "MCP-Session-Id": sessionId })
+            }
+        });
+        if (initializedResponse.statusCode < 200 || initializedResponse.statusCode >= 300) {
+            scorecard.protocolHeaders = "fail";
+            findings.push(failure("plugin.runtime.remote.initialized.failed", `The remote MCP server \`${serverName}\` did not acknowledge the initialized notification.`, "The MCP session may not be ready for subsequent protocol traffic.", "Accept a successful HTTP response to notifications/initialized at the same MCP endpoint."));
+            return finalize(scorecard, findings);
+        }
+    }
+    catch {
+        scorecard.protocolHeaders = "fail";
+        findings.push(failure("plugin.runtime.remote.initialized.failed", `The remote MCP server \`${serverName}\` could not receive the initialized notification.`, "The MCP session may not be ready for subsequent protocol traffic.", "Accept a successful HTTP response to notifications/initialized at the same MCP endpoint."));
+        return finalize(scorecard, findings);
+    }
+    scorecard.protocolHeaders = "pass";
+    return finalize(scorecard, findings);
+}

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

@@ -0,0 +1,24 @@
+export interface ResolvedRemoteTarget {
+    hostname: string;
+    address: string;
+    family: 4 | 6;
+    local: boolean;
+}
+export interface RemoteLookup {
+    (hostname: string, options: {
+        all: true;
+        verbatim: true;
+    }): Promise<Array<{
+        address: string;
+        family: 4 | 6;
+    }>>;
+}
+export interface ResolveRemoteTargetOptions {
+    allowLocalNetwork?: boolean;
+    lookup?: RemoteLookup;
+}
+export declare class RemoteNetworkPolicyError extends Error {
+    readonly code: "REMOTE_TARGET_EMPTY" | "REMOTE_TARGET_FORBIDDEN" | "REMOTE_TARGET_INVALID_ADDRESS" | "REMOTE_TARGET_LOOKUP_FAILED" | "REMOTE_TARGET_URL_INVALID";
+    constructor(code: "REMOTE_TARGET_EMPTY" | "REMOTE_TARGET_FORBIDDEN" | "REMOTE_TARGET_INVALID_ADDRESS" | "REMOTE_TARGET_LOOKUP_FAILED" | "REMOTE_TARGET_URL_INVALID", message: string);
+}
+export declare function resolveRemoteTarget(url: URL, options?: ResolveRemoteTargetOptions): Promise<ResolvedRemoteTarget>;