@sxl-studio/bridge 1.7.2 → 1.8.0

package/dist/mcp-runtime-probe.js

@@ -0,0 +1,777 @@
+import { getBridgePackageVersion } from "./bridge-version.js";
+import { validateFigmaMcpSkillsParityPayload } from "./figma-mcp-skills-parity.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function fetchText(endpoint, options) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs);
+    try {
+        const headers = {
+            Accept: "application/json, text/event-stream",
+        };
+        if (options.authToken) {
+            headers.Authorization = `Bearer ${options.authToken}`;
+        }
+        if (options.sessionId) {
+            headers["Mcp-Session-Id"] = options.sessionId;
+        }
+        if (options.protocolVersion) {
+            headers["mcp-protocol-version"] = options.protocolVersion;
+        }
+        let body;
+        if (options.body !== undefined) {
+            headers["Content-Type"] = "application/json";
+            body = JSON.stringify(options.body);
+        }
+        const response = await options.fetchImpl(`${options.baseUrl}${endpoint}`, {
+            method: options.method,
+            headers,
+            body,
+            signal: controller.signal,
+        });
+        return {
+            status: response.status,
+            body: await response.text(),
+            headers: response.headers,
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function parseJsonRpcResponse(response) {
+    const contentType = response.headers.get("Content-Type") ?? response.headers.get("content-type") ?? "";
+    const text = response.body.trim();
+    if (!text)
+        return null;
+    if (contentType.includes("text/event-stream")) {
+        const blocks = text.split(/\r?\n\r?\n/);
+        for (const block of blocks) {
+            const data = block
+                .split(/\r?\n/)
+                .filter((line) => line.startsWith("data:"))
+                .map((line) => line.slice("data:".length).trimStart())
+                .join("\n")
+                .trim();
+            if (!data)
+                continue;
+            try {
+                const parsed = JSON.parse(data);
+                if (isRecord(parsed))
+                    return parsed;
+            }
+            catch {
+                continue;
+            }
+        }
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(text);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseToolTextJsonPayload(response) {
+    const message = parseJsonRpcResponse(response);
+    const result = isRecord(message?.result) ? message.result : null;
+    const content = Array.isArray(result?.["content"]) ? result["content"] : [];
+    const firstText = content.find((item) => isRecord(item) && item["type"] === "text" && typeof item["text"] === "string");
+    if (!isRecord(firstText) || typeof firstText["text"] !== "string")
+        return null;
+    try {
+        return JSON.parse(firstText["text"]);
+    }
+    catch {
+        return null;
+    }
+}
+function parseResourceTextJsonPayload(response, uri) {
+    const message = parseJsonRpcResponse(response);
+    const result = isRecord(message?.result) ? message.result : null;
+    const contents = Array.isArray(result?.["contents"]) ? result["contents"] : [];
+    const resourceContent = contents.find((item) => isRecord(item) && item["uri"] === uri && typeof item["text"] === "string");
+    if (!isRecord(resourceContent) || typeof resourceContent["text"] !== "string")
+        return null;
+    try {
+        return JSON.parse(resourceContent["text"]);
+    }
+    catch {
+        return null;
+    }
+}
+function parsePromptText(response) {
+    const message = parseJsonRpcResponse(response);
+    const result = isRecord(message?.result) ? message.result : null;
+    const messages = Array.isArray(result?.["messages"]) ? result["messages"] : [];
+    return messages
+        .map((item) => isRecord(item) && isRecord(item["content"]) ? item["content"]["text"] : "")
+        .filter((text) => typeof text === "string")
+        .join("\n");
+}
+function fail(code, message, httpStatus) {
+    return {
+        ok: false,
+        status: "fail",
+        error: { code, message, httpStatus },
+        warnings: [],
+    };
+}
+export async function runMcpRuntimeProbe(options) {
+    const endpoint = "/mcp";
+    const protocolVersion = "2025-11-25";
+    const warnings = [];
+    let sessionId = null;
+    let negotiatedProtocolVersion = protocolVersion;
+    const finalResult = { current: null };
+    const done = (result) => {
+        finalResult.current = result;
+        return result;
+    };
+    try {
+        const init = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            body: {
+                jsonrpc: "2.0",
+                id: 1,
+                method: "initialize",
+                params: {
+                    protocolVersion,
+                    capabilities: {},
+                    clientInfo: {
+                        name: "sxl-bridge-runtime-probe",
+                        version: getBridgePackageVersion(),
+                    },
+                },
+            },
+        });
+        if (init.status === 401) {
+            return done(fail("MCP_STREAMABLE_HTTP_UNAUTHORIZED", "POST /mcp initialize requires Authorization. Pass --auth-token or set BRIDGE_AUTH_TOKEN.", init.status));
+        }
+        if (init.status < 200 || init.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_ERROR", `POST /mcp initialize returned HTTP ${init.status}.`, init.status));
+        }
+        sessionId = init.headers.get("mcp-session-id") ?? init.headers.get("Mcp-Session-Id");
+        const initMessage = parseJsonRpcResponse(init);
+        const initResult = isRecord(initMessage?.result) ? initMessage.result : null;
+        const serverInfo = isRecord(initResult?.["serverInfo"]) ? initResult["serverInfo"] : null;
+        const serverName = typeof serverInfo?.["name"] === "string" ? serverInfo["name"] : null;
+        const negotiated = typeof initResult?.["protocolVersion"] === "string" ? initResult["protocolVersion"] : null;
+        if (negotiated)
+            negotiatedProtocolVersion = negotiated;
+        if (!sessionId || !initMessage || !initResult || serverName !== "@sxl-studio/bridge") {
+            return done(fail("MCP_STREAMABLE_HTTP_INIT_INVALID", "POST /mcp initialize did not return the expected Bridge MCP session envelope.", init.status));
+        }
+        const initialized = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                method: "notifications/initialized",
+                params: {},
+            },
+        });
+        if (initialized.status < 200 || initialized.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_INITIALIZED_FAILED", `POST /mcp notifications/initialized returned HTTP ${initialized.status}.`, initialized.status));
+        }
+        const toolsList = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                id: 2,
+                method: "tools/list",
+                params: {},
+            },
+        });
+        if (toolsList.status < 200 || toolsList.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_TOOLS_LIST_FAILED", `POST /mcp tools/list returned HTTP ${toolsList.status}.`, toolsList.status));
+        }
+        const toolsMessage = parseJsonRpcResponse(toolsList);
+        const toolsResult = isRecord(toolsMessage?.result) ? toolsMessage.result : null;
+        const tools = Array.isArray(toolsResult?.["tools"]) ? toolsResult["tools"] : [];
+        const toolNames = new Set(tools
+            .filter(isRecord)
+            .map((tool) => typeof tool["name"] === "string" ? tool["name"] : "")
+            .filter(Boolean));
+        const missingRequiredMcpTools = ["list_tools", "get_operator_runbook", "get_libraries", "search_design_system"]
+            .filter((name) => !toolNames.has(name));
+        if (missingRequiredMcpTools.length > 0) {
+            return done(fail("MCP_STREAMABLE_HTTP_FIGMA_MCP_COMPAT_TOOLS_MISSING", `POST /mcp tools/list did not return required Bridge/Figma MCP-compatible tools: ${missingRequiredMcpTools.join(", ")}.`, toolsList.status));
+        }
+        const getLibrariesCall = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                id: 31,
+                method: "tools/call",
+                params: {
+                    name: "get_libraries",
+                    arguments: {
+                        source: "rest-known",
+                        bridgeResponseMode: "full",
+                    },
+                },
+            },
+        });
+        if (getLibrariesCall.status < 200 || getLibrariesCall.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_GET_LIBRARIES_FAILED", `POST /mcp tools/call get_libraries returned HTTP ${getLibrariesCall.status}.`, getLibrariesCall.status));
+        }
+        const getLibrariesPayload = parseToolTextJsonPayload(getLibrariesCall);
+        const getLibrariesOk = isRecord(getLibrariesPayload) &&
+            getLibrariesPayload["ok"] === true &&
+            getLibrariesPayload["tool"] === "get_libraries" &&
+            getLibrariesPayload["compatibility"] === "figma-mcp-design" &&
+            Array.isArray(getLibrariesPayload["warnings"]);
+        if (!getLibrariesOk) {
+            return done(fail("MCP_STREAMABLE_HTTP_GET_LIBRARIES_INVALID", "POST /mcp tools/call get_libraries did not return the expected Figma MCP-compatible zero-config envelope.", getLibrariesCall.status));
+        }
+        const searchDesignSystemCall = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                id: 32,
+                method: "tools/call",
+                params: {
+                    name: "search_design_system",
+                    arguments: {
+                        source: "rest-known",
+                        query: "button",
+                        bridgeResponseMode: "full",
+                    },
+                },
+            },
+        });
+        if (searchDesignSystemCall.status < 200 || searchDesignSystemCall.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_SEARCH_DESIGN_SYSTEM_FAILED", `POST /mcp tools/call search_design_system returned HTTP ${searchDesignSystemCall.status}.`, searchDesignSystemCall.status));
+        }
+        const searchDesignSystemPayload = parseToolTextJsonPayload(searchDesignSystemCall);
+        const searchDesignSystemOk = isRecord(searchDesignSystemPayload) &&
+            searchDesignSystemPayload["ok"] === true &&
+            searchDesignSystemPayload["tool"] === "search_design_system" &&
+            searchDesignSystemPayload["compatibility"] === "figma-mcp-design" &&
+            typeof searchDesignSystemPayload["count"] === "number" &&
+            Array.isArray(searchDesignSystemPayload["warnings"]);
+        if (!searchDesignSystemOk) {
+            return done(fail("MCP_STREAMABLE_HTTP_SEARCH_DESIGN_SYSTEM_INVALID", "POST /mcp tools/call search_design_system did not return the expected Figma MCP-compatible zero-config envelope.", searchDesignSystemCall.status));
+        }
+        const listToolsCall = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                id: 3,
+                method: "tools/call",
+                params: {
+                    name: "list_tools",
+                    arguments: { category: "diagnostics" },
+                },
+            },
+        });
+        if (listToolsCall.status < 200 || listToolsCall.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_TOOL_CALL_FAILED", `POST /mcp tools/call list_tools returned HTTP ${listToolsCall.status}.`, listToolsCall.status));
+        }
+        const callMessage = parseJsonRpcResponse(listToolsCall);
+        const callResult = isRecord(callMessage?.result) ? callMessage.result : null;
+        const content = Array.isArray(callResult?.["content"]) ? callResult["content"] : [];
+        const firstText = content.find((item) => isRecord(item) && item["type"] === "text" && typeof item["text"] === "string");
+        let cataloguePayload = null;
+        if (isRecord(firstText) && typeof firstText["text"] === "string") {
+            try {
+                cataloguePayload = JSON.parse(firstText["text"]);
+            }
+            catch {
+                cataloguePayload = null;
+            }
+        }
+        const catalogueTools = isRecord(cataloguePayload) && Array.isArray(cataloguePayload["tools"])
+            ? cataloguePayload["tools"]
+            : [];
+        const hasPluginStatus = catalogueTools.some((tool) => isRecord(tool) && tool["name"] === "get_plugin_status");
+        if (!hasPluginStatus) {
+            return done(fail("MCP_STREAMABLE_HTTP_TOOL_CALL_INVALID", "POST /mcp tools/call list_tools did not return the expected normalized Bridge tool response.", listToolsCall.status));
+        }
+        const validateScreenSpecCall = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                id: 4,
+                method: "tools/call",
+                params: {
+                    name: "validate_screen_spec",
+                    arguments: {
+                        spec: {
+                            name: "SXL Bridge MCP Probe",
+                            dryRun: true,
+                            items: [{ kind: "text", value: "MCP probe" }],
+                        },
+                    },
+                },
+            },
+        });
+        if (validateScreenSpecCall.status < 200 || validateScreenSpecCall.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_VALIDATE_SCREEN_SPEC_FAILED", `POST /mcp tools/call validate_screen_spec returned HTTP ${validateScreenSpecCall.status}.`, validateScreenSpecCall.status));
+        }
+        const validateSpecMessage = parseJsonRpcResponse(validateScreenSpecCall);
+        const validateSpecResult = isRecord(validateSpecMessage?.result) ? validateSpecMessage.result : null;
+        const validateSpecContent = Array.isArray(validateSpecResult?.["content"]) ? validateSpecResult["content"] : [];
+        const validateSpecFirstText = validateSpecContent.find((item) => isRecord(item) && item["type"] === "text" && typeof item["text"] === "string");
+        let validateSpecPayload = null;
+        if (isRecord(validateSpecFirstText) && typeof validateSpecFirstText["text"] === "string") {
+            try {
+                validateSpecPayload = JSON.parse(validateSpecFirstText["text"]);
+            }
+            catch {
+                validateSpecPayload = null;
+            }
+        }
+        if (!isRecord(validateSpecPayload) || validateSpecPayload["ok"] !== true || validateSpecPayload["dryRun"] !== true) {
+            return done(fail("MCP_STREAMABLE_HTTP_VALIDATE_SCREEN_SPEC_INVALID", "POST /mcp tools/call validate_screen_spec did not return the expected dry-run validation payload.", validateScreenSpecCall.status));
+        }
+        const previewExportCall = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                id: 5,
+                method: "tools/call",
+                params: {
+                    name: "preview_export_variables",
+                    arguments: {
+                        collection: "SXL Bridge MCP Probe",
+                        deleteOrphans: false,
+                    },
+                },
+            },
+        });
+        if (previewExportCall.status < 200 || previewExportCall.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_PREVIEW_EXPORT_VARIABLES_FAILED", `POST /mcp tools/call preview_export_variables returned HTTP ${previewExportCall.status}.`, previewExportCall.status));
+        }
+        const previewExportMessage = parseJsonRpcResponse(previewExportCall);
+        const previewExportResult = isRecord(previewExportMessage?.result) ? previewExportMessage.result : null;
+        const previewExportContent = Array.isArray(previewExportResult?.["content"]) ? previewExportResult["content"] : [];
+        const previewExportFirstText = previewExportContent.find((item) => isRecord(item) && item["type"] === "text" && typeof item["text"] === "string");
+        let previewExportPayload = null;
+        if (isRecord(previewExportFirstText) && typeof previewExportFirstText["text"] === "string") {
+            try {
+                previewExportPayload = JSON.parse(previewExportFirstText["text"]);
+            }
+            catch {
+                previewExportPayload = null;
+            }
+        }
+        const previewExportOk = isRecord(previewExportPayload) &&
+            previewExportPayload["ok"] === true &&
+            previewExportPayload["dryRun"] === true &&
+            previewExportPayload["commandType"] === "export_variables" &&
+            isRecord(previewExportPayload["commandPayload"]);
+        if (!previewExportOk) {
+            return done(fail("MCP_STREAMABLE_HTTP_PREVIEW_EXPORT_VARIABLES_INVALID", "POST /mcp tools/call preview_export_variables did not return the expected export preflight payload.", previewExportCall.status));
+        }
+        const skillsParityCall = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                id: 6,
+                method: "tools/call",
+                params: {
+                    name: "get_figma_mcp_skills_parity",
+                    arguments: {},
+                },
+            },
+        });
+        if (skillsParityCall.status < 200 || skillsParityCall.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_SKILLS_PARITY_FAILED", `POST /mcp tools/call get_figma_mcp_skills_parity returned HTTP ${skillsParityCall.status}.`, skillsParityCall.status));
+        }
+        const skillsParityMessage = parseJsonRpcResponse(skillsParityCall);
+        const skillsParityResult = isRecord(skillsParityMessage?.result) ? skillsParityMessage.result : null;
+        const skillsParityContent = Array.isArray(skillsParityResult?.["content"]) ? skillsParityResult["content"] : [];
+        const skillsParityFirstText = skillsParityContent.find((item) => isRecord(item) && item["type"] === "text" && typeof item["text"] === "string");
+        let skillsParityPayload = null;
+        if (isRecord(skillsParityFirstText) && typeof skillsParityFirstText["text"] === "string") {
+            try {
+                skillsParityPayload = JSON.parse(skillsParityFirstText["text"]);
+            }
+            catch {
+                skillsParityPayload = null;
+            }
+        }
+        const skillsParityValidation = validateFigmaMcpSkillsParityPayload(skillsParityPayload);
+        if (!skillsParityValidation.ok) {
+            return done(fail("MCP_STREAMABLE_HTTP_SKILLS_PARITY_INVALID", `POST /mcp tools/call get_figma_mcp_skills_parity did not return the expected current skills parity matrix: ${skillsParityValidation.errors.join(" ")}`, skillsParityCall.status));
+        }
+        const operatorRunbookToolCall = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                id: 61,
+                method: "tools/call",
+                params: {
+                    name: "get_operator_runbook",
+                    arguments: {},
+                },
+            },
+        });
+        if (operatorRunbookToolCall.status < 200 || operatorRunbookToolCall.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_OPERATOR_RUNBOOK_TOOL_FAILED", `POST /mcp tools/call get_operator_runbook returned HTTP ${operatorRunbookToolCall.status}.`, operatorRunbookToolCall.status));
+        }
+        const operatorRunbookToolPayload = parseToolTextJsonPayload(operatorRunbookToolCall);
+        const operatorRunbookToolWorkflows = isRecord(operatorRunbookToolPayload) && Array.isArray(operatorRunbookToolPayload["workflows"])
+            ? operatorRunbookToolPayload["workflows"]
+            : [];
+        const operatorRunbookToolWorkflowIds = new Set(operatorRunbookToolWorkflows
+            .filter(isRecord)
+            .map((workflow) => typeof workflow["id"] === "string" ? workflow["id"] : "")
+            .filter(Boolean));
+        const operatorRunbookToolOk = isRecord(operatorRunbookToolPayload) &&
+            operatorRunbookToolPayload["id"] === "sxl-operator-runbook" &&
+            operatorRunbookToolWorkflowIds.has("draw-or-update-screen") &&
+            operatorRunbookToolWorkflowIds.has("official-figma-mcp-companion");
+        if (!operatorRunbookToolOk) {
+            return done(fail("MCP_STREAMABLE_HTTP_OPERATOR_RUNBOOK_TOOL_INVALID", "POST /mcp tools/call get_operator_runbook did not return the expected SXL operator workflow map.", operatorRunbookToolCall.status));
+        }
+        const libraryWorkflowCall = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                id: 7,
+                method: "tools/call",
+                params: {
+                    name: "plan_workflow",
+                    arguments: {
+                        request: "get_libraries and search_design_system for a button component",
+                    },
+                },
+            },
+        });
+        if (libraryWorkflowCall.status < 200 || libraryWorkflowCall.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_LIBRARY_WORKFLOW_FAILED", `POST /mcp tools/call plan_workflow returned HTTP ${libraryWorkflowCall.status}.`, libraryWorkflowCall.status));
+        }
+        const libraryWorkflowPayload = parseToolTextJsonPayload(libraryWorkflowCall);
+        const libraryWorkflowRoute = isRecord(libraryWorkflowPayload) && isRecord(libraryWorkflowPayload["route"])
+            ? libraryWorkflowPayload["route"]
+            : null;
+        const libraryWorkflowSteps = isRecord(libraryWorkflowPayload) && Array.isArray(libraryWorkflowPayload["steps"])
+            ? libraryWorkflowPayload["steps"]
+            : [];
+        const libraryWorkflowToolNames = new Set(libraryWorkflowSteps
+            .filter(isRecord)
+            .map((step) => typeof step["toolName"] === "string" ? step["toolName"] : "")
+            .filter(Boolean));
+        const usesCompanionGate = libraryWorkflowSteps.some((step) => isRecord(step) && step["title"] === "Use official Figma MCP companion");
+        const libraryWorkflowOk = isRecord(libraryWorkflowRoute) &&
+            libraryWorkflowRoute["recipeId"] === "sxl-use" &&
+            libraryWorkflowToolNames.has("get_libraries") &&
+            libraryWorkflowToolNames.has("search_design_system") &&
+            !usesCompanionGate;
+        if (!libraryWorkflowOk) {
+            return done(fail("MCP_STREAMABLE_HTTP_LIBRARY_WORKFLOW_INVALID", "POST /mcp tools/call plan_workflow did not route Figma Design library discovery through Bridge get_libraries/search_design_system.", libraryWorkflowCall.status));
+        }
+        const resourcesList = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                id: 8,
+                method: "resources/list",
+                params: {},
+            },
+        });
+        if (resourcesList.status < 200 || resourcesList.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_RESOURCES_LIST_FAILED", `POST /mcp resources/list returned HTTP ${resourcesList.status}.`, resourcesList.status));
+        }
+        const resourcesMessage = parseJsonRpcResponse(resourcesList);
+        const resourcesResult = isRecord(resourcesMessage?.result) ? resourcesMessage.result : null;
+        const resources = Array.isArray(resourcesResult?.["resources"]) ? resourcesResult["resources"] : [];
+        const hasRuntimeSummary = resources.some((resource) => isRecord(resource) && resource["uri"] === "sxl://agent/runtime-summary");
+        const hasOperatorRunbookResource = resources.some((resource) => isRecord(resource) && resource["uri"] === "sxl://agent/operator-runbook");
+        const hasSkillsParityResource = resources.some((resource) => isRecord(resource) && resource["uri"] === "sxl://agent/figma-mcp-skills-parity");
+        if (!hasRuntimeSummary || !hasOperatorRunbookResource || !hasSkillsParityResource) {
+            return done(fail("MCP_STREAMABLE_HTTP_RESOURCES_INVALID", "POST /mcp resources/list did not return required SXL agent resources.", resourcesList.status));
+        }
+        const runtimeSummaryRead = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                id: 9,
+                method: "resources/read",
+                params: {
+                    uri: "sxl://agent/runtime-summary",
+                },
+            },
+        });
+        if (runtimeSummaryRead.status < 200 || runtimeSummaryRead.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_RESOURCE_READ_FAILED", `POST /mcp resources/read runtime-summary returned HTTP ${runtimeSummaryRead.status}.`, runtimeSummaryRead.status));
+        }
+        const runtimeSummaryMessage = parseJsonRpcResponse(runtimeSummaryRead);
+        const runtimeSummaryResult = isRecord(runtimeSummaryMessage?.result) ? runtimeSummaryMessage.result : null;
+        const resourceContents = Array.isArray(runtimeSummaryResult?.["contents"]) ? runtimeSummaryResult["contents"] : [];
+        const runtimeSummaryContent = resourceContents.find((item) => isRecord(item) && item["uri"] === "sxl://agent/runtime-summary" && typeof item["text"] === "string");
+        let runtimeSummaryPayload = null;
+        if (isRecord(runtimeSummaryContent) && typeof runtimeSummaryContent["text"] === "string") {
+            try {
+                runtimeSummaryPayload = JSON.parse(runtimeSummaryContent["text"]);
+            }
+            catch {
+                runtimeSummaryPayload = null;
+            }
+        }
+        const runtimeSummaryOk = isRecord(runtimeSummaryPayload) &&
+            isRecord(runtimeSummaryPayload["transport"]) &&
+            typeof runtimeSummaryPayload["transport"]["mcpStreamableHttp"] === "string" &&
+            isRecord(runtimeSummaryPayload["plugin"]) &&
+            isRecord(runtimeSummaryPayload["queue"]);
+        if (!runtimeSummaryOk) {
+            return done(fail("MCP_STREAMABLE_HTTP_RESOURCE_READ_INVALID", "POST /mcp resources/read runtime-summary did not return the expected Bridge runtime resource payload.", runtimeSummaryRead.status));
+        }
+        const operatorRunbookResourceRead = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                id: 10,
+                method: "resources/read",
+                params: {
+                    uri: "sxl://agent/operator-runbook",
+                },
+            },
+        });
+        if (operatorRunbookResourceRead.status < 200 || operatorRunbookResourceRead.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_OPERATOR_RUNBOOK_RESOURCE_READ_FAILED", `POST /mcp resources/read operator-runbook returned HTTP ${operatorRunbookResourceRead.status}.`, operatorRunbookResourceRead.status));
+        }
+        const operatorRunbookPayload = parseResourceTextJsonPayload(operatorRunbookResourceRead, "sxl://agent/operator-runbook");
+        const operatorRunbookWorkflows = isRecord(operatorRunbookPayload) && Array.isArray(operatorRunbookPayload["workflows"])
+            ? operatorRunbookPayload["workflows"]
+            : [];
+        const operatorWorkflowIds = new Set(operatorRunbookWorkflows
+            .filter(isRecord)
+            .map((workflow) => typeof workflow["id"] === "string" ? workflow["id"] : "")
+            .filter(Boolean));
+        const operatorRunbookOk = isRecord(operatorRunbookPayload) &&
+            operatorRunbookPayload["id"] === "sxl-operator-runbook" &&
+            operatorWorkflowIds.has("draw-or-update-screen") &&
+            operatorWorkflowIds.has("official-figma-mcp-companion");
+        if (!operatorRunbookOk) {
+            return done(fail("MCP_STREAMABLE_HTTP_OPERATOR_RUNBOOK_RESOURCE_READ_INVALID", "POST /mcp resources/read operator-runbook did not return the expected SXL operator workflow map.", operatorRunbookResourceRead.status));
+        }
+        const skillsParityResourceRead = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                id: 11,
+                method: "resources/read",
+                params: {
+                    uri: "sxl://agent/figma-mcp-skills-parity",
+                },
+            },
+        });
+        if (skillsParityResourceRead.status < 200 || skillsParityResourceRead.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_SKILLS_PARITY_RESOURCE_READ_FAILED", `POST /mcp resources/read figma-mcp-skills-parity returned HTTP ${skillsParityResourceRead.status}.`, skillsParityResourceRead.status));
+        }
+        const skillsParityResourceMessage = parseJsonRpcResponse(skillsParityResourceRead);
+        const skillsParityResourceResult = isRecord(skillsParityResourceMessage?.result) ? skillsParityResourceMessage.result : null;
+        const skillsParityResourceContents = Array.isArray(skillsParityResourceResult?.["contents"]) ? skillsParityResourceResult["contents"] : [];
+        const skillsParityResourceContent = skillsParityResourceContents.find((item) => isRecord(item) && item["uri"] === "sxl://agent/figma-mcp-skills-parity" && typeof item["text"] === "string");
+        let skillsParityResourcePayload = null;
+        if (isRecord(skillsParityResourceContent) && typeof skillsParityResourceContent["text"] === "string") {
+            try {
+                skillsParityResourcePayload = JSON.parse(skillsParityResourceContent["text"]);
+            }
+            catch {
+                skillsParityResourcePayload = null;
+            }
+        }
+        const skillsParityResourceValidation = validateFigmaMcpSkillsParityPayload(skillsParityResourcePayload);
+        if (!skillsParityResourceValidation.ok) {
+            return done(fail("MCP_STREAMABLE_HTTP_SKILLS_PARITY_RESOURCE_READ_INVALID", `POST /mcp resources/read figma-mcp-skills-parity did not return the expected current skills parity resource payload: ${skillsParityResourceValidation.errors.join(" ")}`, skillsParityResourceRead.status));
+        }
+        const promptsList = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                id: 12,
+                method: "prompts/list",
+                params: {},
+            },
+        });
+        if (promptsList.status < 200 || promptsList.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_PROMPTS_LIST_FAILED", `POST /mcp prompts/list returned HTTP ${promptsList.status}.`, promptsList.status));
+        }
+        const promptsMessage = parseJsonRpcResponse(promptsList);
+        const promptsResult = isRecord(promptsMessage?.result) ? promptsMessage.result : null;
+        const prompts = Array.isArray(promptsResult?.["prompts"]) ? promptsResult["prompts"] : [];
+        const promptNames = new Set(prompts
+            .filter(isRecord)
+            .map((prompt) => typeof prompt["name"] === "string" ? prompt["name"] : "")
+            .filter(Boolean));
+        const missingPrompts = ["sxl-operator", "sxl-generate-design", "figma-mcp-companion"]
+            .filter((name) => !promptNames.has(name));
+        if (missingPrompts.length > 0) {
+            return done(fail("MCP_STREAMABLE_HTTP_PROMPTS_INVALID", `POST /mcp prompts/list did not return required SXL skill prompts: ${missingPrompts.join(", ")}.`, promptsList.status));
+        }
+        const generateDesignPrompt = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                id: 13,
+                method: "prompts/get",
+                params: {
+                    name: "sxl-generate-design",
+                    arguments: {
+                        request: "Build a settings screen in Figma",
+                        focus: "runtime probe",
+                    },
+                },
+            },
+        });
+        if (generateDesignPrompt.status < 200 || generateDesignPrompt.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_PROMPT_GET_FAILED", `POST /mcp prompts/get sxl-generate-design returned HTTP ${generateDesignPrompt.status}.`, generateDesignPrompt.status));
+        }
+        const promptText = parsePromptText(generateDesignPrompt);
+        if (!promptText.includes("sxl://agent/recipes/sxl-generate-design") || !promptText.includes("validate_screen_spec")) {
+            return done(fail("MCP_STREAMABLE_HTTP_PROMPT_GET_INVALID", "POST /mcp prompts/get sxl-generate-design did not return the expected SXL skill prompt content.", generateDesignPrompt.status));
+        }
+        const operatorPrompt = await fetchText(endpoint, {
+            ...options,
+            method: "POST",
+            sessionId,
+            protocolVersion: negotiatedProtocolVersion,
+            body: {
+                jsonrpc: "2.0",
+                id: 14,
+                method: "prompts/get",
+                params: {
+                    name: "sxl-operator",
+                    arguments: {
+                        request: "Audit variables and draw documentation in Figma",
+                        focus: "runtime probe",
+                    },
+                },
+            },
+        });
+        if (operatorPrompt.status < 200 || operatorPrompt.status >= 300) {
+            return done(fail("MCP_STREAMABLE_HTTP_OPERATOR_PROMPT_GET_FAILED", `POST /mcp prompts/get sxl-operator returned HTTP ${operatorPrompt.status}.`, operatorPrompt.status));
+        }
+        const operatorPromptText = parsePromptText(operatorPrompt);
+        const operatorPromptOk = operatorPromptText.includes("sxl://agent/operator-runbook") &&
+            operatorPromptText.includes("draw-or-update-screen") &&
+            operatorPromptText.includes("npm run bridge:readiness:live");
+        if (!operatorPromptOk) {
+            return done(fail("MCP_STREAMABLE_HTTP_OPERATOR_PROMPT_GET_INVALID", "POST /mcp prompts/get sxl-operator did not return the expected SXL operator runbook prompt content.", operatorPrompt.status));
+        }
+        return done({
+            ok: true,
+            status: warnings.length > 0 ? "warn" : "pass",
+            details: {
+                session: "stateful",
+                toolCount: tools.length,
+                diagnosticsToolCount: catalogueTools.length,
+                toolCalls: [
+                    "list_tools",
+                    "get_operator_runbook",
+                    "validate_screen_spec",
+                    "preview_export_variables",
+                    "get_figma_mcp_skills_parity",
+                    "plan_workflow",
+                    "get_libraries",
+                    "search_design_system",
+                ],
+                localValidationTool: "validate_screen_spec",
+                resourceCount: resources.length,
+                resourceRead: [
+                    "sxl://agent/runtime-summary",
+                    "sxl://agent/operator-runbook",
+                    "sxl://agent/figma-mcp-skills-parity",
+                ],
+                promptCount: prompts.length,
+                promptRead: ["sxl-operator", "sxl-generate-design"],
+                figmaMcpSkillsParity: {
+                    officialSkillCount: skillsParityValidation.officialSkillCount,
+                    compatibilityAliases: skillsParityValidation.compatibilityAliases,
+                },
+                protocolVersion: negotiatedProtocolVersion,
+            },
+            warnings,
+        });
+    }
+    catch (error) {
+        return done(fail("MCP_STREAMABLE_HTTP_UNREACHABLE", `MCP /mcp probe failed: ${error instanceof Error ? error.message : String(error)}`));
+    }
+    finally {
+        if (sessionId) {
+            try {
+                const closed = await fetchText(endpoint, {
+                    ...options,
+                    method: "DELETE",
+                    sessionId,
+                    protocolVersion: negotiatedProtocolVersion,
+                });
+                if (closed.status < 200 || closed.status >= 300) {
+                    warnings.push({
+                        code: "MCP_STREAMABLE_HTTP_TERMINATE_WARN",
+                        message: `DELETE /mcp returned HTTP ${closed.status}; runtime probe succeeded but session cleanup may have failed.`,
+                    });
+                }
+            }
+            catch (error) {
+                warnings.push({
+                    code: "MCP_STREAMABLE_HTTP_TERMINATE_WARN",
+                    message: `DELETE /mcp failed after runtime probe: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        }
+        if (finalResult.current) {
+            finalResult.current.warnings = warnings;
+            if (finalResult.current.ok && warnings.length > 0) {
+                finalResult.current.status = "warn";
+            }
+        }
+    }
+}
+//# sourceMappingURL=mcp-runtime-probe.js.map