@frontmcp/ui 0.6.0 → 0.6.2

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

@@ -1,639 +0,0 @@
-/**
- * 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/esm/types/ui-config.d.ts.map

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