pi-soly 1.9.3 → 1.11.0

package/mcp/__tests__/ui-resource-handler.upstream-test.ts

@@ -0,0 +1,303 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { UiResourceHandler } from "../ui-resource-handler.ts";
+import { UrlElicitationRequiredError } from "@modelcontextprotocol/sdk/types.js";
+import type { McpServerManager } from "../server-manager.ts";
+
+// Mock the manager
+function createMockManager(overrides: Partial<McpServerManager> = {}): McpServerManager {
+  return {
+    readResource: vi.fn(),
+    getConnection: vi.fn().mockReturnValue(null),
+    ...overrides,
+  } as unknown as McpServerManager;
+}
+
+describe("UiResourceHandler", () => {
+  describe("readUiResource", () => {
+    it("throws for non-ui:// URIs", async () => {
+      const manager = createMockManager();
+      const handler = new UiResourceHandler(manager);
+
+      await expect(handler.readUiResource("server", "https://example.com")).rejects.toThrow(
+        /URI must start with ui:\/\//
+      );
+    });
+
+    it("preserves URL-required errors for the outer tool adapter", async () => {
+      const error = new UrlElicitationRequiredError([{
+        mode: "url",
+        message: "Connect",
+        elicitationId: "connect-1",
+        url: "https://example.com/connect",
+      }]);
+      const manager = createMockManager({ readResource: vi.fn().mockRejectedValue(error) });
+      const handler = new UiResourceHandler(manager);
+
+      await expect(handler.readUiResource("server", "ui://test/widget")).rejects.toBe(error);
+    });
+
+    it("reads and returns HTML from text content", async () => {
+      const manager = createMockManager({
+        readResource: vi.fn().mockResolvedValue({
+          contents: [
+            {
+              uri: "ui://test/widget",
+              mimeType: "text/html",
+              text: "<h1>Hello</h1>",
+            },
+          ],
+        }),
+      });
+      const handler = new UiResourceHandler(manager);
+
+      const result = await handler.readUiResource("server", "ui://test/widget");
+
+      expect(result.uri).toBe("ui://test/widget");
+      expect(result.html).toBe("<h1>Hello</h1>");
+      expect(result.mimeType).toBe("text/html");
+    });
+
+    it("reads and decodes blob content", async () => {
+      const htmlContent = "<div>Blob content</div>";
+      const base64Content = Buffer.from(htmlContent).toString("base64");
+
+      const manager = createMockManager({
+        readResource: vi.fn().mockResolvedValue({
+          contents: [
+            {
+              uri: "ui://test/widget",
+              mimeType: "text/html",
+              blob: base64Content,
+            },
+          ],
+        }),
+      });
+      const handler = new UiResourceHandler(manager);
+
+      const result = await handler.readUiResource("server", "ui://test/widget");
+
+      expect(result.html).toBe(htmlContent);
+    });
+
+    it("throws for empty content", async () => {
+      const manager = createMockManager({
+        readResource: vi.fn().mockResolvedValue({
+          contents: [
+            {
+              uri: "ui://test/widget",
+              mimeType: "text/html",
+              text: "   ",
+            },
+          ],
+        }),
+      });
+      const handler = new UiResourceHandler(manager);
+
+      await expect(handler.readUiResource("server", "ui://test/widget")).rejects.toThrow(
+        /content is empty/
+      );
+    });
+
+    it("throws for unsupported MIME type", async () => {
+      const manager = createMockManager({
+        readResource: vi.fn().mockResolvedValue({
+          contents: [
+            {
+              uri: "ui://test/widget",
+              mimeType: "application/json",
+              text: '{"key": "value"}',
+            },
+          ],
+        }),
+      });
+      const handler = new UiResourceHandler(manager);
+
+      await expect(handler.readUiResource("server", "ui://test/widget")).rejects.toThrow(
+        /unsupported MIME type/
+      );
+    });
+
+    it("accepts text/html;profile=mcp-app MIME type", async () => {
+      const manager = createMockManager({
+        readResource: vi.fn().mockResolvedValue({
+          contents: [
+            {
+              uri: "ui://test/widget",
+              mimeType: "text/html;profile=mcp-app",
+              text: "<app>content</app>",
+            },
+          ],
+        }),
+      });
+      const handler = new UiResourceHandler(manager);
+
+      const result = await handler.readUiResource("server", "ui://test/widget");
+
+      expect(result.html).toBe("<app>content</app>");
+    });
+
+    it("throws when no contents returned", async () => {
+      const manager = createMockManager({
+        readResource: vi.fn().mockResolvedValue({
+          contents: [],
+        }),
+      });
+      const handler = new UiResourceHandler(manager);
+
+      await expect(handler.readUiResource("server", "ui://test/widget")).rejects.toThrow(
+        "No contents returned for UI resource: ui://test/widget"
+      );
+    });
+
+    it("prefers content with matching URI", async () => {
+      const manager = createMockManager({
+        readResource: vi.fn().mockResolvedValue({
+          contents: [
+            {
+              uri: "ui://other/widget",
+              mimeType: "text/html",
+              text: "<h1>Wrong</h1>",
+            },
+            {
+              uri: "ui://test/widget",
+              mimeType: "text/html",
+              text: "<h1>Correct</h1>",
+            },
+          ],
+        }),
+      });
+      const handler = new UiResourceHandler(manager);
+
+      const result = await handler.readUiResource("server", "ui://test/widget");
+
+      expect(result.html).toBe("<h1>Correct</h1>");
+    });
+
+    it("falls back to first HTML content if no URI match", async () => {
+      const manager = createMockManager({
+        readResource: vi.fn().mockResolvedValue({
+          contents: [
+            {
+              mimeType: "application/json",
+              text: "{}",
+            },
+            {
+              mimeType: "text/html",
+              text: "<h1>HTML</h1>",
+            },
+          ],
+        }),
+      });
+      const handler = new UiResourceHandler(manager);
+
+      const result = await handler.readUiResource("server", "ui://test/widget");
+
+      expect(result.html).toBe("<h1>HTML</h1>");
+    });
+
+    it("extracts CSP meta from content _meta", async () => {
+      const manager = createMockManager({
+        readResource: vi.fn().mockResolvedValue({
+          contents: [
+            {
+              uri: "ui://test/widget",
+              mimeType: "text/html",
+              text: "<h1>Content</h1>",
+              _meta: {
+                ui: {
+                  csp: {
+                    scriptDomains: ["'self'", "cdn.example.com"],
+                    styleDomains: ["'self'"],
+                  },
+                },
+              },
+            },
+          ],
+        }),
+      });
+      const handler = new UiResourceHandler(manager);
+
+      const result = await handler.readUiResource("server", "ui://test/widget");
+
+      expect(result.meta.csp).toEqual({
+        scriptDomains: ["'self'", "cdn.example.com"],
+        styleDomains: ["'self'"],
+      });
+    });
+
+    it("extracts permissions meta", async () => {
+      const manager = createMockManager({
+        readResource: vi.fn().mockResolvedValue({
+          contents: [
+            {
+              uri: "ui://test/widget",
+              mimeType: "text/html",
+              text: "<h1>Content</h1>",
+              _meta: {
+                ui: {
+                  permissions: {
+                    camera: {},
+                    microphone: {},
+                  },
+                },
+              },
+            },
+          ],
+        }),
+      });
+      const handler = new UiResourceHandler(manager);
+
+      const result = await handler.readUiResource("server", "ui://test/widget");
+
+      expect(result.meta.permissions).toEqual({
+        camera: {},
+        microphone: {},
+      });
+    });
+
+    it("extracts domain and prefersBorder meta", async () => {
+      const manager = createMockManager({
+        readResource: vi.fn().mockResolvedValue({
+          contents: [
+            {
+              uri: "ui://test/widget",
+              mimeType: "text/html",
+              text: "<h1>Content</h1>",
+              _meta: {
+                ui: {
+                  domain: "example.com",
+                  prefersBorder: true,
+                },
+              },
+            },
+          ],
+        }),
+      });
+      const handler = new UiResourceHandler(manager);
+
+      const result = await handler.readUiResource("server", "ui://test/widget");
+
+      expect(result.meta.domain).toBe("example.com");
+      expect(result.meta.prefersBorder).toBe(true);
+    });
+
+    it("throws when content has no text or blob", async () => {
+      const manager = createMockManager({
+        readResource: vi.fn().mockResolvedValue({
+          contents: [
+            {
+              uri: "ui://test/widget",
+              mimeType: "text/html",
+              // No text or blob
+            },
+          ],
+        }),
+      });
+      const handler = new UiResourceHandler(manager);
+
+      await expect(handler.readUiResource("server", "ui://test/widget")).rejects.toThrow(
+        "did not include text or blob content"
+      );
+    });
+  });
+});