@fitchmultz/pi-mcp-adapter 5.0.0

package/dist/ui-resource-handler.d.ts

@@ -0,0 +1,17 @@
+import { type SessionRecoveryDeps } from "./session-recovery.ts";
+import type { McpServerManager } from "./server-manager.ts";
+import { type McpConfig, type UiResourceContent } from "./types.ts";
+interface ReadUiResourceOptions {
+    config?: McpConfig;
+    signal?: AbortSignal;
+    onNeedsAuth?: SessionRecoveryDeps["onNeedsAuth"];
+}
+export declare class UiResourceHandler {
+    private manager;
+    private config;
+    private log;
+    constructor(manager: McpServerManager, config?: McpConfig | undefined);
+    readUiResource(serverName: string, uri: string, options?: ReadUiResourceOptions): Promise<UiResourceContent>;
+    private getListResourceMeta;
+}
+export {};

package/dist/ui-resource-handler.js

@@ -0,0 +1,209 @@
+import { RESOURCE_MIME_TYPE } from "@modelcontextprotocol/ext-apps/app-bridge";
+import { UrlElicitationRequiredError } from "@modelcontextprotocol/client";
+import { logger } from "./logger.js";
+import { SessionRecoveryAuthRequiredError, withSessionRecovery } from "./session-recovery.js";
+import { isServerDisabled } from "./types.js";
+export class UiResourceHandler {
+    manager;
+    config;
+    log = logger.child({ component: "UiResourceHandler" });
+    constructor(manager, config = undefined) {
+        this.manager = manager;
+        this.config = config;
+    }
+    async readUiResource(serverName, uri, options = {}) {
+        const log = this.log.child({ server: serverName, uri });
+        if (!uri.startsWith("ui://")) {
+            throw new Error(`Invalid UI resource "${uri}": URI must start with ui://`);
+        }
+        log.debug("Fetching UI resource");
+        let result;
+        try {
+            const config = options.config ?? this.config;
+            if (config && isServerDisabled(config.mcpServers[serverName])) {
+                throw new Error(`MCP server "${serverName}" is disabled`);
+            }
+            if (config) {
+                this.manager.touch(serverName);
+                this.manager.incrementInFlight(serverName);
+                try {
+                    result = await withSessionRecovery({
+                        manager: this.manager,
+                        config,
+                        ...(options.signal ? { signal: options.signal } : {}),
+                        ...(options.onNeedsAuth ? { onNeedsAuth: options.onNeedsAuth } : {}),
+                    }, serverName, (connection) => connection.client.readResource({ uri }, this.manager.getRequestOptions(serverName, options.signal)));
+                }
+                finally {
+                    this.manager.decrementInFlight(serverName);
+                    this.manager.touch(serverName);
+                }
+            }
+            else {
+                result = await this.manager.readResource(serverName, uri, options.signal);
+            }
+        }
+        catch (error) {
+            if (error instanceof UrlElicitationRequiredError || error instanceof SessionRecoveryAuthRequiredError)
+                throw error;
+            const message = error instanceof Error ? error.message : String(error);
+            log.error("Failed to read resource", error instanceof Error ? error : undefined);
+            throw new Error(`Failed to fetch UI resource "${uri}": ${message}`, error instanceof Error ? { cause: error } : undefined);
+        }
+        const content = selectContent(result, uri);
+        const mimeType = content.mimeType;
+        if (mimeType && !isHtmlMimeType(mimeType)) {
+            log.warn("Unsupported MIME type", { mimeType });
+            throw new Error(`Invalid UI resource "${uri}": unsupported MIME type "${mimeType}" (expected text/html or ${RESOURCE_MIME_TYPE})`);
+        }
+        const html = toHtml(content);
+        if (!html.trim()) {
+            log.warn("Resource content is empty");
+            throw new Error(`Invalid UI resource "${uri}": content is empty`);
+        }
+        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: {
+                ...((contentMeta.csp ?? listMeta.csp) !== undefined ? { csp: contentMeta.csp ?? listMeta.csp } : {}),
+                ...((contentMeta.permissions ?? listMeta.permissions) !== undefined
+                    ? { permissions: contentMeta.permissions ?? listMeta.permissions }
+                    : {}),
+                ...((contentMeta.domain ?? listMeta.domain) !== undefined ? { domain: contentMeta.domain ?? listMeta.domain } : {}),
+                ...((contentMeta.prefersBorder ?? listMeta.prefersBorder) !== undefined
+                    ? { 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;
+    const firstContent = contents[0];
+    if (!firstContent) {
+        throw new Error(`No contents returned for UI resource: ${preferredUri}`);
+    }
+    return firstContent;
+}
+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`);
+}
+const OPENAI_CSP_FIELD_MAPPINGS = [
+    ["resource_domains", "resourceDomains"],
+    ["connect_domains", "connectDomains"],
+    ["frame_domains", "frameDomains"],
+];
+const UI_CSP_DOMAIN_FIELDS = [
+    "resourceDomains",
+    "connectDomains",
+    "frameDomains",
+    "baseUriDomains",
+];
+function extractUiMeta(meta) {
+    if (!meta || typeof meta !== "object")
+        return {};
+    const ui = isRecord(meta.ui) ? meta.ui : undefined;
+    const out = {};
+    const openAiCsp = hasOwnProperty(meta, "openai/widgetCSP")
+        ? normalizeOpenAiWidgetCsp(meta["openai/widgetCSP"])
+        : undefined;
+    const hasStandardCsp = !!ui && hasOwnProperty(ui, "csp");
+    const standardCspValue = hasStandardCsp ? ui.csp : undefined;
+    if (hasStandardCsp && !isRecord(standardCspValue)) {
+        // A declared canonical container takes precedence even when malformed.
+        out.csp = {};
+    }
+    else {
+        const standardCsp = hasStandardCsp
+            ? normalizeUiResourceCsp(standardCspValue)
+            : undefined;
+        if (openAiCsp || standardCsp) {
+            out.csp = { ...openAiCsp, ...standardCsp };
+            if (isRecord(standardCspValue)) {
+                for (const [, standardField] of OPENAI_CSP_FIELD_MAPPINGS) {
+                    if (hasOwnProperty(standardCspValue, standardField) && !copyStringArray(standardCspValue[standardField])) {
+                        delete out.csp[standardField];
+                    }
+                }
+            }
+        }
+    }
+    if (ui && isRecord(ui.permissions)) {
+        out.permissions = ui.permissions;
+    }
+    if (ui && typeof ui.domain === "string") {
+        out.domain = ui.domain;
+    }
+    if (ui && typeof ui.prefersBorder === "boolean") {
+        out.prefersBorder = ui.prefersBorder;
+    }
+    return out;
+}
+function normalizeUiResourceCsp(value) {
+    if (!isRecord(value))
+        return {};
+    const csp = {};
+    for (const field of UI_CSP_DOMAIN_FIELDS) {
+        const domains = copyStringArray(value[field]);
+        if (domains)
+            csp[field] = domains;
+    }
+    return csp;
+}
+function normalizeOpenAiWidgetCsp(value) {
+    if (!isRecord(value))
+        return {};
+    const csp = {};
+    for (const [sourceField, targetField] of OPENAI_CSP_FIELD_MAPPINGS) {
+        const domains = copyStringArray(value[sourceField]);
+        if (domains)
+            csp[targetField] = domains;
+    }
+    return csp;
+}
+function copyStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string")
+        ? [...value]
+        : undefined;
+}
+function hasOwnProperty(record, property) {
+    return Object.prototype.hasOwnProperty.call(record, property);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/ui-server.d.ts

@@ -0,0 +1,51 @@
+import type { CallToolResult } from "@modelcontextprotocol/client";
+import type { ConsentManager } from "./consent-manager.ts";
+import type { McpServerManager } from "./server-manager.ts";
+import type { McpExtensionState } from "./state.ts";
+import { type SessionRecoveryDeps } from "./session-recovery.ts";
+import { type McpConfig, type UiHostContext, type UiMessageParams, type UiModelContextParams, type UiResourceContent, type UiSessionMessages, type UiStreamSummary } from "./types.ts";
+export interface UiServerOptions {
+    serverName: string;
+    toolName: string;
+    toolArgs: Record<string, unknown>;
+    resource: UiResourceContent;
+    manager: McpServerManager;
+    /**
+     * Live extension config, used to re-read the server definition when
+     * recovering a terminated Streamable HTTP session (see
+     * session-recovery.ts). Optional so existing embedders/tests that don't
+     * need session recovery aren't forced to supply it; without it, proxied
+     * tool calls run without recovery (unchanged pre-existing behavior).
+     */
+    config?: McpConfig;
+    /** Live state enables TUI approval prompts for iframe-originated tool calls. */
+    state?: McpExtensionState;
+    onNeedsAuth?: SessionRecoveryDeps["onNeedsAuth"];
+    consentManager: ConsentManager;
+    hostContext?: UiHostContext;
+    initialResultPromise?: Promise<CallToolResult>;
+    sessionToken?: string;
+    port?: number;
+    onMessage?: (params: UiMessageParams) => Promise<void> | void;
+    onContextUpdate?: (params: UiModelContextParams) => Promise<void> | void;
+    onComplete?: (reason: string) => void;
+}
+export interface UiServerHandle {
+    url: string;
+    port: number;
+    sessionToken: string;
+    serverName: string;
+    toolName: string;
+    viewer?: "browser" | "glimpse" | "suppressed";
+    windowOpen?: boolean;
+    close: (reason?: string) => void;
+    sendToolInput: (args: Record<string, unknown>) => void;
+    sendToolResult: (result: CallToolResult) => void;
+    sendResultPatch: (result: CallToolResult) => void;
+    sendToolCancelled: (reason: string) => void;
+    sendHostContext: (context: UiHostContext) => void;
+    /** Get accumulated messages from this session */
+    getSessionMessages: () => UiSessionMessages;
+    getStreamSummary: () => UiStreamSummary | undefined;
+}
+export declare function startUiServer(options: UiServerOptions): Promise<UiServerHandle>;