@frontmcp/ui 0.5.0 → 0.6.0

package/types/ui-config.d.ts

@@ -0,0 +1,639 @@
+/**
+ * Standalone UI Configuration Types
+ *
+ * SDK-independent types for configuring UI templates.
+ * These types can be used by external consumers (like AgentLink)
+ * without requiring @frontmcp/sdk as a dependency.
+ *
+ * @packageDocumentation
+ */
+import type { CDNDependency, FileBundleOptions } from '../dependency/types';
+/**
+ * Content Security Policy for UI templates rendered in sandboxed iframes.
+ * Based on OpenAI Apps SDK and MCP Apps (SEP-1865) specifications.
+ */
+export interface UIContentSecurityPolicy {
+    /**
+     * Origins allowed for fetch/XHR/WebSocket connections.
+     * Maps to CSP `connect-src` directive.
+     * @example ['https://api.example.com', 'https://*.myservice.com']
+     */
+    connectDomains?: string[];
+    /**
+     * Origins allowed for images, scripts, fonts, and styles.
+     * Maps to CSP `img-src`, `script-src`, `style-src`, `font-src` directives.
+     * @example ['https://cdn.example.com']
+     */
+    resourceDomains?: string[];
+}
+/**
+ * XSS protection and content security settings.
+ *
+ * Controls sanitization of HTML content rendered in widgets.
+ * By default, strict sanitization is applied to prevent XSS attacks.
+ *
+ * ## Platform Isolation Context
+ *
+ * Both OpenAI and Claude render widgets in **double-iframe isolation**:
+ *
+ * ```
+ * ┌─────────────────────────────────────────────────┐
+ * │  ChatGPT / Claude Desktop                       │
+ * │  ┌─────────────────────────────────────────────┐│
+ * │  │  Outer Sandbox Iframe                       ││
+ * │  │  - sandbox="allow-scripts allow-same-origin"││
+ * │  │  - No access to parent cookies              ││
+ * │  │  ┌─────────────────────────────────────────┐││
+ * │  │  │  Inner Widget Iframe                    │││
+ * │  │  │  - CSP: script-src 'self' 'unsafe-inline'│││
+ * │  │  │  - CSP: connect-src based on config     │││
+ * │  │  │  - Your widget HTML renders here        │││
+ * │  │  └─────────────────────────────────────────┘││
+ * │  └─────────────────────────────────────────────┘│
+ * └─────────────────────────────────────────────────┘
+ * ```
+ *
+ * This isolation means XSS attacks are **contained** but can still:
+ * - Access widget data (input/output)
+ * - Make API calls within CSP-allowed domains
+ * - Display fake/phishing UI to users
+ *
+ * **Recommendation:** Only disable protection for fully trusted content.
+ */
+export interface UIContentSecurity {
+    /**
+     * Allow `javascript:` and other potentially dangerous URL schemes in links.
+     *
+     * When `false` (default), URLs are validated to only allow:
+     * - `http://`, `https://` (web URLs)
+     * - `/`, `#` (relative paths, anchors)
+     * - `mailto:` (email links)
+     *
+     * When `true`, allows any URL scheme including:
+     * - `javascript:` (inline script execution)
+     * - `data:` (data URIs)
+     * - `vbscript:` (legacy script)
+     *
+     * @default false
+     */
+    allowUnsafeLinks?: boolean;
+    /**
+     * Allow inline `<script>` tags and event handlers (onclick, onerror, etc).
+     *
+     * When `false` (default), HTML content is sanitized to remove:
+     * - `<script>...</script>` tags
+     * - Event handler attributes (`onclick`, `onerror`, `onload`, etc.)
+     *
+     * When `true`, these elements are preserved in the output.
+     *
+     * **Note:** Even with this enabled, CSP may still block script execution
+     * depending on the platform's iframe sandbox settings.
+     *
+     * @default false
+     */
+    allowInlineScripts?: boolean;
+    /**
+     * Completely bypass all HTML sanitization.
+     *
+     * **⚠️ DANGEROUS:** Only use with fully trusted, server-generated content.
+     *
+     * When `true`, no sanitization is applied:
+     * - Script tags are preserved
+     * - Event handlers are preserved
+     * - All URL schemes are allowed
+     * - No HTML escaping is performed
+     *
+     * This is useful for:
+     * - Embedding trusted third-party widgets
+     * - Complex interactive dashboards from trusted sources
+     * - Content that was pre-sanitized server-side
+     *
+     * @default false
+     */
+    bypassSanitization?: boolean;
+}
+/**
+ * Helper functions available in template context.
+ */
+export interface TemplateHelpers {
+    /**
+     * Escape HTML special characters to prevent XSS.
+     */
+    escapeHtml: (str: string) => string;
+    /**
+     * Format a date for display.
+     * @param date - Date object or ISO string
+     * @param format - Optional format (default: localized date)
+     */
+    formatDate: (date: Date | string, format?: string) => string;
+    /**
+     * Format a number as currency.
+     * @param amount - The numeric amount
+     * @param currency - ISO 4217 currency code (default: 'USD')
+     */
+    formatCurrency: (amount: number, currency?: string) => string;
+    /**
+     * Generate a unique ID for DOM elements.
+     * @param prefix - Optional prefix for the ID
+     */
+    uniqueId: (prefix?: string) => string;
+    /**
+     * Safely embed JSON data in HTML (escapes script-breaking characters).
+     */
+    jsonEmbed: (data: unknown) => string;
+}
+/**
+ * Context passed to template builder functions.
+ * Contains all data needed to render a tool's UI template.
+ */
+export interface TemplateContext<In = unknown, Out = unknown> {
+    /**
+     * The input arguments passed to the tool.
+     */
+    input: In;
+    /**
+     * The raw output returned by the tool's execute method.
+     */
+    output: Out;
+    /**
+     * The structured content parsed from the output (if outputSchema was provided).
+     * This is the JSON-serializable form suitable for widget consumption.
+     */
+    structuredContent?: unknown;
+    /**
+     * Helper functions for template rendering.
+     */
+    helpers: TemplateHelpers;
+}
+/**
+ * Template builder function type.
+ * Receives context with input/output and returns HTML string.
+ */
+export type TemplateBuilderFn<In = unknown, Out = unknown> = (ctx: TemplateContext<In, Out>) => string;
+/**
+ * Widget serving mode determines how the widget HTML is delivered to the client.
+ *
+ * - `'auto'` (default): Automatically select mode based on client capabilities.
+ *   For OpenAI/ext-apps: uses 'inline'. For Claude: uses 'inline' with dual-payload.
+ *   For unsupported clients (e.g., Gemini): skips UI entirely (returns JSON only).
+ *
+ * - `'inline'`: HTML embedded directly in tool response `_meta['ui/html']`.
+ *   Works on all platforms including network-blocked ones.
+ *
+ * - `'static'`: Pre-compiled at startup, resolved via `tools/list` (ui:// resource URI).
+ *   Widget is fetched via MCP `resources/read`.
+ *
+ * - `'hybrid'`: Shell (React runtime + bridge) pre-compiled at startup.
+ *   Component code transpiled per-request and delivered in `_meta['ui/component']`.
+ *
+ * - `'direct-url'`: HTTP endpoint on MCP server.
+ *
+ * - `'custom-url'`: Custom URL (CDN or external hosting).
+ */
+export type WidgetServingMode = 'auto' | 'inline' | 'static' | 'hybrid' | 'direct-url' | 'custom-url';
+/**
+ * @deprecated Use 'static' instead of 'mcp-resource'. Will be removed in v2.0.
+ * Alias maintained for backwards compatibility.
+ */
+export type WidgetServingModeLegacy = 'mcp-resource';
+/**
+ * Widget display mode preference.
+ */
+export type WidgetDisplayMode = 'inline' | 'fullscreen' | 'pip';
+/**
+ * UI template configuration for tools.
+ * Enables rendering interactive widgets for tool responses in supported hosts
+ * (OpenAI Apps SDK, Claude/MCP-UI, etc.).
+ *
+ * This is a standalone type that doesn't depend on @frontmcp/sdk.
+ * Use this type in external systems (like AgentLink) that consume @frontmcp/ui.
+ *
+ * @example
+ * ```typescript
+ * const uiConfig: UITemplateConfig = {
+ *   template: (ctx) => `
+ *     <div class="p-4">
+ *       <h2>${ctx.helpers.escapeHtml(ctx.input.location)}</h2>
+ *       <p>${ctx.output.temperature}°F</p>
+ *     </div>
+ *   `,
+ *   csp: { connectDomains: ['https://api.weather.com'] },
+ *   widgetAccessible: true,
+ *   widgetDescription: 'Displays current weather conditions',
+ * };
+ * ```
+ */
+export interface UITemplateConfig<In = unknown, Out = unknown> {
+    /**
+     * Template for rendering tool UI.
+     *
+     * Supports multiple formats (auto-detected by renderer):
+     * - Template builder function: `(ctx) => string` - receives input/output/helpers, returns HTML
+     * - Static HTML/MDX string: `"<div>...</div>"` or `"# Title\n<Card />"`
+     * - React component: `MyWidget` - receives props with input/output/helpers
+     */
+    template: TemplateBuilderFn<In, Out> | string | ((props: any) => any);
+    /**
+     * Content Security Policy for the sandboxed widget.
+     * Controls which external resources the widget can access.
+     */
+    csp?: UIContentSecurityPolicy;
+    /**
+     * Content security and XSS protection settings.
+     *
+     * By default, FrontMCP sanitizes HTML content to prevent XSS attacks:
+     * - Removes `<script>` tags and event handlers (onclick, onerror, etc.)
+     * - Validates URL schemes in links (blocks `javascript:`, `data:`, `vbscript:`)
+     *
+     * These protections can be disabled for trusted content that requires
+     * inline scripts, custom event handlers, or special URL schemes.
+     *
+     * ## Security Context
+     *
+     * **OpenAI/Claude run widgets in double-iframe isolation:**
+     * - Outer sandbox iframe with restricted permissions
+     * - Inner content iframe with CSP headers
+     * - No access to parent window or cookies
+     * - Network requests restricted by CSP
+     *
+     * This isolation provides defense-in-depth, making XSS less impactful.
+     * However, XSS can still:
+     * - Steal widget state/data
+     * - Make unauthorized API calls (within CSP limits)
+     * - Phish users with fake UI
+     *
+     * **Best Practice:** Keep XSS protection enabled unless you have a specific
+     * need for inline scripts/handlers AND trust your content source completely.
+     *
+     * @example
+     * ```typescript
+     * // Default: Full XSS protection
+     * ui: { template: MyWidget }
+     *
+     * // Allow inline scripts for trusted dashboard
+     * ui: {
+     *   template: TrustedDashboard,
+     *   contentSecurity: { allowInlineScripts: true }
+     * }
+     *
+     * // Bypass all sanitization for fully trusted HTML
+     * ui: {
+     *   template: FullyTrustedContent,
+     *   contentSecurity: { bypassSanitization: true }
+     * }
+     * ```
+     */
+    contentSecurity?: UIContentSecurity;
+    /**
+     * Whether the widget can invoke tools via the MCP bridge.
+     * When true, the widget gains access to `window.mcpBridge.callTool()`.
+     * Maps to OpenAI's `openai/widgetAccessible` annotation.
+     *
+     * Default: false
+     */
+    widgetAccessible?: boolean;
+    /**
+     * Preferred display mode for the widget.
+     * - 'inline': Rendered inline in the conversation (default)
+     * - 'fullscreen': Request fullscreen display
+     * - 'pip': Picture-in-picture mode
+     *
+     * Note: Host may not support all modes; this is a preference hint.
+     */
+    displayMode?: WidgetDisplayMode;
+    /**
+     * Human-readable description shown to users about what the widget does.
+     * Maps to OpenAI's `openai/widgetDescription` annotation.
+     */
+    widgetDescription?: string;
+    /**
+     * Status messages shown during tool invocation (OpenAI ChatGPT specific).
+     * Maps to OpenAI's `openai/toolInvocation/invoking` and `openai/toolInvocation/invoked`.
+     *
+     * @example
+     * ```typescript
+     * invocationStatus: {
+     *   invoking: 'Fetching weather data...',
+     *   invoked: 'Weather data loaded'
+     * }
+     * ```
+     */
+    invocationStatus?: {
+        /** Status text shown while tool is executing */
+        invoking?: string;
+        /** Status text shown after tool execution completes */
+        invoked?: string;
+    };
+    /**
+     * How the widget HTML should be served to the client.
+     *
+     * - `'auto'` (default): Automatically select mode based on client capabilities.
+     *   For OpenAI/ext-apps clients: uses `'inline'` with `_meta`.
+     *   For Claude clients: uses `'inline'` with dual-payload format.
+     *   For unsupported clients (Gemini, unknown): skips UI (returns JSON only).
+     *
+     * - `'inline'`: HTML embedded directly in tool response `_meta['ui/html']`.
+     *   Best for small widgets, works on all platforms including network-blocked ones.
+     *
+     * - `'static'`: Widget pre-compiled at server startup, registered as MCP resource with `ui://` URI.
+     *   Client fetches via `resources/read`. Good for OpenAI's template system.
+     *   Widget is resolved during `tools/list`, not dependent on tool call.
+     *
+     * - `'hybrid'`: Shell (React runtime + bridge) pre-compiled at startup.
+     *   Component code transpiled per-request and delivered in `_meta['ui/component']`.
+     *
+     * - `'direct-url'`: Served from MCP server's HTTP endpoint.
+     *   Avoids third-party cookie issues since widget loads from same domain.
+     *
+     * - `'custom-url'`: Served from a custom URL (CDN, external hosting).
+     *   Requires `customWidgetUrl` to be set.
+     *
+     * @default 'auto'
+     */
+    servingMode?: WidgetServingMode;
+    /**
+     * Custom URL for widget serving when `servingMode: 'custom-url'`.
+     * The URL can include `{token}` placeholder which will be replaced with
+     * the widget access token.
+     *
+     * @example
+     * ```typescript
+     * customWidgetUrl: 'https://cdn.example.com/widgets/weather.html?token={token}'
+     * ```
+     */
+    customWidgetUrl?: string;
+    /**
+     * Path for direct URL serving when `servingMode: 'direct-url'`.
+     * This path is appended to the MCP server's base URL.
+     *
+     * @example
+     * ```typescript
+     * directPath: '/widgets/weather'
+     * // Results in: https://mcp-server.example.com/widgets/weather?token=...
+     * ```
+     */
+    directPath?: string;
+    /**
+     * Custom React components available in MDX templates.
+     * These components can be used directly in MDX content without importing.
+     *
+     * @example
+     * ```typescript
+     * ui: {
+     *   template: `# Weather\n<Alert type="info">Data loaded</Alert>`,
+     *   mdxComponents: {
+     *     Alert: ({ type, children }) => <div className={type}>{children}</div>,
+     *     Card: MyCardComponent,
+     *   }
+     * }
+     * ```
+     */
+    mdxComponents?: Record<string, any>;
+    /**
+     * Whether to show a border around the UI widget.
+     * MCP Apps spec: `_meta.ui.prefersBorder`
+     *
+     * When true, hosts should render a visible border around the sandbox iframe.
+     * Useful for visual clarity when the widget content doesn't have its own borders.
+     *
+     * Default: undefined (host decides)
+     */
+    prefersBorder?: boolean;
+    /**
+     * Dedicated sandbox domain for the widget.
+     * MCP Apps spec: `_meta.ui.domain`
+     *
+     * When specified, the host should load the widget in an iframe with this
+     * domain as the origin, providing additional isolation.
+     *
+     * @example 'sandbox.example.com'
+     */
+    sandboxDomain?: string;
+    /**
+     * Enable client-side React hydration after server-side rendering (SSR).
+     *
+     * **Default: `false`**
+     *
+     * When `false` (default):
+     * - SSR output is static HTML
+     * - No React runtime is loaded on the client
+     * - All interactivity is handled by the FrontMCP Bridge IIFE
+     * - This prevents React Hydration Error #418 in MCP clients
+     *
+     * When `true`:
+     * - React/ReactDOM CDN scripts are included
+     * - Client attempts to hydrate React components
+     * - May cause hydration mismatch errors in some MCP clients (Claude, ChatGPT)
+     *
+     * **Why disabled by default?**
+     * MCP clients like Claude and ChatGPT render HTML in sandboxed iframes.
+     * React hydration expects the client-rendered HTML to exactly match the
+     * server-rendered HTML. Due to timing differences, random data, and
+     * different execution contexts, mismatches frequently occur causing
+     * React Error #418 ("Hydration failed...").
+     *
+     * The FrontMCP Bridge IIFE already provides all necessary interactivity
+     * (tool calls via `data-tool-call`, state updates, loading states) without
+     * requiring React hydration.
+     *
+     * **Only enable if:**
+     * - You need React state management on the client
+     * - You're sure your template produces deterministic HTML
+     * - You've tested hydration works in your target MCP client
+     *
+     * @example
+     * ```typescript
+     * // Disable hydration (default behavior - recommended)
+     * ui: {
+     *   template: MyReactComponent,
+     *   hydrate: false
+     * }
+     *
+     * // Enable hydration (use with caution)
+     * ui: {
+     *   template: MyStatefulComponent,
+     *   hydrate: true
+     * }
+     * ```
+     */
+    hydrate?: boolean;
+    /**
+     * UI renderer type.
+     *
+     * - `'html'`: HTML with optional Handlebars
+     * - `'react'`: React component (SSR)
+     * - `'mdx'`: MDX template
+     * - `'markdown'`: Pure Markdown
+     * - `'auto'`: Auto-detect from template (default)
+     *
+     * @default 'auto'
+     */
+    uiType?: 'html' | 'react' | 'mdx' | 'markdown' | 'auto';
+    /**
+     * Bundling mode.
+     *
+     * - `'static'`: Pre-compile widget shell, inject data at runtime (default)
+     * - `'dynamic'`: Generate fresh HTML per tool invocation
+     *
+     * @default 'static'
+     */
+    bundlingMode?: 'static' | 'dynamic';
+    /**
+     * Resource loading mode.
+     *
+     * - `'cdn'`: Load React/MDX/Handlebars from CDN URLs (lightweight)
+     * - `'inline'`: Embed all scripts in HTML (self-contained)
+     *
+     * Use 'cdn' for most platforms (OpenAI, ChatGPT, Cursor).
+     * Use 'inline' for network-blocked environments (Claude Artifacts).
+     *
+     * @default 'cdn'
+     */
+    resourceMode?: 'cdn' | 'inline';
+    /**
+     * Runtime options for specific renderers.
+     */
+    runtimeOptions?: {
+        /** Enable React hydration after SSR */
+        hydrate?: boolean;
+        /** Markdown rendering options */
+        markdown?: {
+            /** Enable GitHub-flavored markdown */
+            gfm?: boolean;
+            /** Syntax highlighting theme */
+            highlightTheme?: string;
+        };
+    };
+    /**
+     * Prefix text shown before HTML in dual-payload responses (Claude).
+     *
+     * When the output mode is `'dual-payload'` (auto-detected for Claude clients),
+     * the tool response contains two TextContent blocks:
+     * 1. Pure JSON data: `{"temperature": 72, ...}`
+     * 2. Markdown-wrapped HTML: `{prefix}:\n\n```html\n<!DOCTYPE html>...\n```
+     *
+     * This field controls the prefix text in block 2.
+     *
+     * @default 'Here is the visual result'
+     *
+     * @example
+     * ```typescript
+     * // Weather tool
+     * ui: {
+     *   template: WeatherWidget,
+     *   htmlResponsePrefix: 'Here is the weather dashboard',
+     * }
+     * // Output block 2: "Here is the weather dashboard:\n\n```html\n..."
+     *
+     * // Stock tool
+     * ui: {
+     *   template: StockWidget,
+     *   htmlResponsePrefix: 'Here is the stock information',
+     * }
+     * // Output block 2: "Here is the stock information:\n\n```html\n..."
+     * ```
+     */
+    htmlResponsePrefix?: string;
+    /**
+     * Packages to load from CDN instead of bundling.
+     *
+     * When `template` is a file path (e.g., `'./chart-widget.tsx'`), imports
+     * of these packages will be excluded from the bundle and loaded at runtime
+     * via CDN import maps.
+     *
+     * Package names should match npm package names. The CDN URL is resolved
+     * from the built-in CDN registry or from explicit `dependencies` overrides.
+     *
+     * **Platform considerations:**
+     * - Claude only allows `cdnjs.cloudflare.com` (blocked network)
+     * - OpenAI/Cursor/other platforms can use any CDN
+     *
+     * @example
+     * ```typescript
+     * // Auto-resolved from CDN registry
+     * ui: {
+     *   template: './chart-widget.tsx',
+     *   externals: ['chart.js', 'react-chartjs-2'],
+     * }
+     *
+     * // With explicit override
+     * ui: {
+     *   template: './chart-widget.tsx',
+     *   externals: ['chart.js'],
+     *   dependencies: {
+     *     'chart.js': {
+     *       url: 'https://cdnjs.cloudflare.com/ajax/libs/Chart.js/4.4.1/chart.umd.min.js',
+     *       integrity: 'sha512-...',
+     *       global: 'Chart',
+     *     },
+     *   },
+     * }
+     * ```
+     */
+    externals?: string[];
+    /**
+     * Explicit CDN dependency overrides for external packages.
+     *
+     * Use this to specify custom CDN URLs or override the default CDN registry
+     * entries for packages listed in `externals`.
+     *
+     * Keys are npm package names. Values specify the CDN URL, integrity hash,
+     * and other loading options.
+     *
+     * @example
+     * ```typescript
+     * ui: {
+     *   template: './dashboard.tsx',
+     *   externals: ['d3', 'lodash'],
+     *   dependencies: {
+     *     'd3': {
+     *       url: 'https://cdnjs.cloudflare.com/ajax/libs/d3/7.8.5/d3.min.js',
+     *       integrity: 'sha512-...',
+     *       global: 'd3',
+     *     },
+     *     'lodash': {
+     *       url: 'https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js',
+     *       global: '_',
+     *     },
+     *   },
+     * }
+     * ```
+     */
+    dependencies?: Record<string, CDNDependency>;
+    /**
+     * Bundle options for file-based templates.
+     *
+     * Controls how the file-based template is compiled and bundled.
+     * These options are only used when `template` is a file path.
+     *
+     * @example
+     * ```typescript
+     * // Development mode
+     * ui: {
+     *   template: './debug-widget.tsx',
+     *   bundleOptions: {
+     *     minify: false,
+     *     sourceMaps: true,
+     *     target: 'esnext',
+     *   },
+     * }
+     *
+     * // Production mode (defaults)
+     * ui: {
+     *   template: './widget.tsx',
+     *   bundleOptions: {
+     *     minify: true,
+     *     treeShake: true,
+     *     target: 'es2020',
+     *   },
+     * }
+     * ```
+     */
+    fileBundleOptions?: FileBundleOptions;
+}
+/**
+ * Type alias for backwards compatibility.
+ * Prefer using UITemplateConfig directly.
+ */
+export type UITemplate<In = unknown, Out = unknown> = UITemplateConfig<In, Out>;
+//# sourceMappingURL=ui-config.d.ts.map

package/types/ui-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-config.d.ts","sourceRoot":"","sources":["../../src/types/ui-config.ts"],"names":[],"mappings":"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"}