@aexol/spectral 0.2.5 → 0.2.7

package/dist/mcp/types.js

@@ -0,0 +1,93 @@
+// Re-export stream types from the shared lightweight module.
+// This allows the example package to import stream schemas without pulling the full types.ts dependency graph.
+export { UI_STREAM_HOST_CONTEXT_KEY, UI_STREAM_REQUEST_META_KEY, UI_STREAM_RESULT_PATCH_METHOD, SERVER_STREAM_RESULT_PATCH_METHOD, UI_STREAM_STRUCTURED_CONTENT_KEY, uiStreamModeSchema, visualizationStreamPhaseSchema, visualizationStreamFrameTypeSchema, visualizationStreamStatusSchema, uiStreamHostContextSchema, visualizationStreamEnvelopeSchema, uiStreamCallToolResultSchema, uiStreamResultPatchNotificationSchema, serverStreamResultPatchNotificationSchema, getUiStreamHostContext, getVisualizationStreamEnvelope, } from "./ui-stream-types.js";
+/**
+ * Extract prompt text from either legacy MCP UI message shapes or native AppBridge user messages.
+ */
+export function extractUiPromptText(params) {
+    if (params.type === "prompt" || params.prompt) {
+        const prompt = params.prompt ?? String(params.message ?? "");
+        return prompt || undefined;
+    }
+    if (params.role === "user" && Array.isArray(params.content)) {
+        const text = params.content
+            .map((block) => (block && typeof block === "object" && "text" in block ? String(block.text ?? "") : ""))
+            .filter(Boolean)
+            .join("\n\n");
+        return text || undefined;
+    }
+    return undefined;
+}
+/**
+ * Parse a canonical named UI handoff encoded as `intent\n{json}`.
+ */
+export function parseUiPromptHandoff(prompt) {
+    const newlineIndex = prompt.indexOf("\n");
+    if (newlineIndex <= 0) {
+        return undefined;
+    }
+    const intent = prompt.slice(0, newlineIndex).trim();
+    const payloadText = prompt.slice(newlineIndex + 1).trim();
+    if (!intent || !payloadText) {
+        return undefined;
+    }
+    if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(intent)) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(payloadText);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return undefined;
+        }
+        return {
+            intent,
+            params: parsed,
+            raw: prompt,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Get server prefix based on tool prefix mode.
+ */
+export function getServerPrefix(serverName, mode) {
+    if (mode === "none")
+        return "";
+    if (mode === "short") {
+        let short = serverName.replace(/-?mcp$/i, "").replace(/-/g, "_");
+        if (!short)
+            short = "mcp";
+        return short;
+    }
+    return serverName.replace(/-/g, "_");
+}
+/**
+ * Format a tool name with server prefix.
+ */
+export function formatToolName(toolName, serverName, prefix) {
+    const p = getServerPrefix(serverName, prefix);
+    return p ? `${p}_${toolName}` : toolName;
+}
+function normalizeToolName(value) {
+    return value.replace(/-/g, "_");
+}
+export function isToolExcluded(toolName, serverName, prefix, excludeTools) {
+    if (!Array.isArray(excludeTools) || excludeTools.length === 0)
+        return false;
+    const candidates = new Set([
+        normalizeToolName(toolName),
+        normalizeToolName(formatToolName(toolName, serverName, prefix)),
+        normalizeToolName(formatToolName(toolName, serverName, "server")),
+        normalizeToolName(formatToolName(toolName, serverName, "short")),
+    ]);
+    for (const excluded of excludeTools) {
+        if (typeof excluded !== "string")
+            continue;
+        if (candidates.has(normalizeToolName(excluded))) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/mcp/ui-resource-handler.js

@@ -0,0 +1,113 @@
+import { RESOURCE_MIME_TYPE } from "@modelcontextprotocol/ext-apps/app-bridge";
+import { ResourceFetchError, ResourceParseError } from "./errors.js";
+import { logger } from "./logger.js";
+export class UiResourceHandler {
+    manager;
+    log = logger.child({ component: "UiResourceHandler" });
+    constructor(manager) {
+        this.manager = manager;
+    }
+    async readUiResource(serverName, uri) {
+        const log = this.log.child({ server: serverName, uri });
+        if (!uri.startsWith("ui://")) {
+            throw new ResourceParseError(uri, "URI must start with ui://", { server: serverName });
+        }
+        log.debug("Fetching UI resource");
+        let result;
+        try {
+            result = await this.manager.readResource(serverName, uri);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            log.error("Failed to read resource", error instanceof Error ? error : undefined);
+            throw new ResourceFetchError(uri, message, {
+                server: serverName,
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+        const content = selectContent(result, uri);
+        const mimeType = content.mimeType;
+        if (mimeType && !isHtmlMimeType(mimeType)) {
+            log.warn("Unsupported MIME type", { mimeType });
+            throw new ResourceParseError(uri, `unsupported MIME type "${mimeType}" (expected text/html or ${RESOURCE_MIME_TYPE})`, { server: serverName, mimeType });
+        }
+        const html = toHtml(content);
+        if (!html.trim()) {
+            log.warn("Resource content is empty");
+            throw new ResourceParseError(uri, "content is empty", { server: serverName });
+        }
+        const contentMeta = extractUiMeta(content._meta);
+        const listMeta = extractUiMeta(this.getListResourceMeta(serverName, uri));
+        log.debug("Resource loaded successfully", {
+            contentLength: html.length,
+            hasCsp: !!contentMeta.csp || !!listMeta.csp,
+        });
+        return {
+            uri: content.uri ?? uri,
+            html,
+            mimeType: mimeType ?? RESOURCE_MIME_TYPE,
+            meta: {
+                csp: contentMeta.csp ?? listMeta.csp,
+                permissions: contentMeta.permissions ?? listMeta.permissions,
+                domain: contentMeta.domain ?? listMeta.domain,
+                prefersBorder: contentMeta.prefersBorder ?? listMeta.prefersBorder,
+            },
+        };
+    }
+    getListResourceMeta(serverName, uri) {
+        const connection = this.manager.getConnection(serverName);
+        if (!connection?.resources?.length)
+            return undefined;
+        const resource = connection.resources.find((entry) => entry.uri === uri);
+        if (!resource || !resource._meta || typeof resource._meta !== "object")
+            return undefined;
+        return resource._meta;
+    }
+}
+function selectContent(result, preferredUri) {
+    const contents = (result.contents ?? []);
+    if (contents.length === 0) {
+        throw new Error(`No contents returned for UI resource: ${preferredUri}`);
+    }
+    const byUri = contents.find((content) => content.uri === preferredUri);
+    if (byUri)
+        return byUri;
+    const byHtmlMime = contents.find((content) => content.mimeType && isHtmlMimeType(content.mimeType));
+    if (byHtmlMime)
+        return byHtmlMime;
+    return contents[0];
+}
+function isHtmlMimeType(mimeType) {
+    const normalized = mimeType.toLowerCase();
+    return normalized.startsWith("text/html") || normalized === RESOURCE_MIME_TYPE.toLowerCase();
+}
+function toHtml(content) {
+    if (typeof content.text === "string") {
+        return content.text;
+    }
+    if (typeof content.blob === "string") {
+        return Buffer.from(content.blob, "base64").toString("utf-8");
+    }
+    throw new Error(`UI resource ${content.uri ?? "(unknown)"} did not include text or blob content`);
+}
+function extractUiMeta(meta) {
+    if (!meta || typeof meta !== "object")
+        return {};
+    const ui = meta.ui;
+    if (!ui || typeof ui !== "object")
+        return {};
+    const out = {};
+    if (ui.csp && typeof ui.csp === "object") {
+        out.csp = ui.csp;
+    }
+    if (ui.permissions && typeof ui.permissions === "object") {
+        out.permissions = ui.permissions;
+    }
+    if (typeof ui.domain === "string") {
+        out.domain = ui.domain;
+    }
+    if (typeof ui.prefersBorder === "boolean") {
+        out.prefersBorder = ui.prefersBorder;
+    }
+    return out;
+}