sunpeak 0.14.3 → 0.15.4

package/dist/simulator/host-styles.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Re-export default style variables from the shared module.
+ * Host shells import from here; the canonical definition lives in lib/.
+ */
+export { DEFAULT_STYLE_VARIABLES } from '../lib/default-style-variables';

package/dist/simulator/hosts.d.ts

@@ -0,0 +1,73 @@
+import { McpUiDisplayMode, McpUiHostContext, McpUiHostCapabilities, McpUiStyles } from '@modelcontextprotocol/ext-apps';
+import { ScreenWidth } from './simulator-types';
+type Platform = NonNullable<McpUiHostContext['platform']>;
+/**
+ * Props passed to a host shell (conversation chrome) component.
+ * Each host implements a React component matching this interface.
+ */
+export interface HostConversationProps {
+    /** The resource content (iframe or children) to render inside the conversation */
+    children: React.ReactNode;
+    /** Current simulated screen width */
+    screenWidth: ScreenWidth;
+    /** Current MCP display mode */
+    displayMode: McpUiDisplayMode;
+    /** Current platform (desktop/mobile/web) */
+    platform: Platform;
+    /** Callback when the shell requests a display mode change (e.g., close button) */
+    onRequestDisplayMode?: (mode: McpUiDisplayMode) => void;
+    /** App name for display in conversation chrome */
+    appName?: string;
+    /** App icon (emoji or URL) for display in conversation chrome */
+    appIcon?: string;
+    /** User message to show in the conversation (decorative) */
+    userMessage?: string;
+    /** Whether content is transitioning between display modes */
+    isTransitioning?: boolean;
+}
+/** Unique identifier for a host */
+export type HostId = 'chatgpt' | 'claude' | (string & {});
+/**
+ * A registered host shell provides the conversation chrome and
+ * functional configuration for a specific MCP App host.
+ */
+export interface HostShell {
+    /** Unique host identifier */
+    id: HostId;
+    /** Human-readable name for the sidebar dropdown */
+    label: string;
+    /** The conversation shell React component */
+    Conversation: React.ComponentType<HostConversationProps>;
+    /** Apply the host's theme to the document (CSS variables, data attributes, etc.) */
+    applyTheme: (theme: 'light' | 'dark') => void;
+    /** Host info reported to the app via MCP protocol */
+    hostInfo: {
+        name: string;
+        version: string;
+    };
+    /** Host capabilities reported to the app via MCP protocol */
+    hostCapabilities: McpUiHostCapabilities;
+    /**
+     * MCP App style variables sent to the app via hostContext.styles.variables.
+     * Uses CSS light-dark() values so a single set adapts to theme automatically.
+     * The SDK's applyDocumentTheme() sets color-scheme which light-dark() reads.
+     * @see McpUiStyleVariableKey from @modelcontextprotocol/ext-apps
+     */
+    styleVariables?: McpUiStyles;
+    /**
+     * CSS custom properties for the simulator page chrome (sidebar, conversation area).
+     * These are applied to the document root and can override the defaults:
+     *   --sim-bg-sidebar       (fallback: var(--color-background-secondary))
+     *   --sim-bg-conversation  (fallback: var(--color-background-primary))
+     *
+     * Values should use CSS light-dark() for automatic theme adaptation.
+     */
+    pageStyles?: Record<string, string>;
+}
+/** Register a host shell. Idempotent — re-registering with the same id replaces. */
+export declare function registerHostShell(shell: HostShell): void;
+/** Get a registered host shell by id. */
+export declare function getHostShell(id: HostId): HostShell | undefined;
+/** Get all registered host shells, in insertion order. */
+export declare function getRegisteredHosts(): HostShell[];
+export {};

package/dist/{chatgpt → simulator}/iframe-resource.d.ts

@@ -1,5 +1,5 @@
 import { McpAppHostOptions } from './mcp-app-host';
-import { McpUiHostContext } from '@modelcontextprotocol/ext-apps';
+import { McpUiHostContext, McpUiResourcePermissions } from '@modelcontextprotocol/ext-apps';
 import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import * as React from 'react';
 /**
@@ -13,12 +13,17 @@ declare function escapeHtml(str: string): string;
 declare function isAllowedUrl(src: string): boolean;
 /**
  * Content Security Policy configuration for iframe resources.
+ * Matches McpUiResourceCsp from the MCP Apps spec.
  */
 export interface ResourceCSP {
     /** Domains allowed for fetch/XHR/WebSocket connections */
     connectDomains?: string[];
     /** Domains allowed for scripts, images, styles, fonts */
     resourceDomains?: string[];
+    /** Domains allowed for nested iframes */
+    frameDomains?: string[];
+    /** Domains allowed for the base-uri directive */
+    baseUriDomains?: string[];
 }
 /**
  * Extract CSP configuration from a resource's _meta.ui.csp field.
@@ -39,7 +44,13 @@ declare function generateCSP(csp: ResourceCSP | undefined, scriptSrc: string): s
  * Generates HTML wrapper for a script URL.
  * The MCP Apps SDK in the loaded script handles communication via PostMessageTransport.
  */
-declare function generateScriptHtml(scriptSrc: string, theme: string, cspPolicy: string): string;
+declare function generateScriptHtml(scriptSrc: string, theme: string, cspPolicy: string, platformScript?: string): string;
+/**
+ * Build the iframe `allow` attribute from resource-declared permissions.
+ * Maps McpUiResourcePermissions to Permission Policy directives and
+ * combines them with simulator baseline permissions.
+ */
+declare function buildIframeAllow(permissions: McpUiResourcePermissions | undefined): string;
 interface IframeResourceProps {
     /**
      * URL to an HTML page to load directly in the iframe.
@@ -57,12 +68,18 @@ interface IframeResourceProps {
     hostContext?: McpUiHostContext;
     /** Tool input arguments to send after connection */
     toolInput?: Record<string, unknown>;
+    /** Partial/streaming tool input to send as a tool-input-partial notification */
+    toolInputPartial?: Record<string, unknown>;
     /** Tool result to send after connection */
     toolResult?: CallToolResult;
     /** Optional callbacks for the MCP Apps host */
     hostOptions?: McpAppHostOptions;
     /** Optional CSP configuration (only used with scriptSrc) */
     csp?: ResourceCSP;
+    /** Resource-declared sandbox permissions (camera, microphone, etc.) */
+    permissions?: McpUiResourcePermissions;
+    /** Whether the host should render a border around the resource */
+    prefersBorder?: boolean;
     /** Optional className for the iframe container */
     className?: string;
     /** Optional style for the iframe */
@@ -79,6 +96,12 @@ interface IframeResourceProps {
      * This bypasses the normal MCP Apps protocol and is for simulator testing.
      */
     debugInjectState?: Record<string, unknown> | null;
+    /**
+     * Whether to inject a mock ChatGPT runtime (window.openai) into the iframe.
+     * When true, ChatGPT-specific hooks (useUploadFile, useRequestModal, etc.)
+     * and isChatGPT() will work inside the iframe.
+     */
+    injectOpenAIRuntime?: boolean;
 }
 /**
  * IframeResource renders MCP Apps in an iframe, communicating via the
@@ -92,13 +115,14 @@ interface IframeResourceProps {
  * connects via PostMessageTransport to window.parent. The parent side uses
  * McpAppHost (wrapping AppBridge) to communicate.
  */
-export declare function IframeResource({ src, scriptSrc, hostContext, toolInput, toolResult, hostOptions, csp, className, style, onDisplayModeReady, debugInjectState, }: IframeResourceProps): import("react/jsx-runtime").JSX.Element;
+export declare function IframeResource({ src, scriptSrc, hostContext, toolInput, toolInputPartial, toolResult, hostOptions, csp, permissions, prefersBorder, className, style, onDisplayModeReady, debugInjectState, injectOpenAIRuntime, }: IframeResourceProps): import("react/jsx-runtime").JSX.Element;
 export declare const _testExports: {
     escapeHtml: typeof escapeHtml;
     isAllowedUrl: typeof isAllowedUrl;
     isValidCspSource: typeof isValidCspSource;
     generateCSP: typeof generateCSP;
     generateScriptHtml: typeof generateScriptHtml;
+    buildIframeAllow: typeof buildIframeAllow;
     ALLOWED_SCRIPT_ORIGINS: string[];
 };
 export {};

package/dist/simulator/index.cjs

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const simulator = require("../simulator-DcfQBRXE.cjs");
+const simulatorUrl = require("../simulator-url-rgg_KYOg.cjs");
+const discovery = require("../discovery-CRR3SlyI.cjs");
+exports.IframeResource = simulator.IframeResource;
+exports.McpAppHost = simulator.McpAppHost;
+exports.SCREEN_WIDTHS = simulator.SCREEN_WIDTHS;
+exports.SidebarCheckbox = simulator.SidebarCheckbox;
+exports.SidebarCollapsibleControl = simulator.SidebarCollapsibleControl;
+exports.SidebarControl = simulator.SidebarControl;
+exports.SidebarInput = simulator.SidebarInput;
+exports.SidebarSelect = simulator.SidebarSelect;
+exports.SidebarTextarea = simulator.SidebarTextarea;
+exports.SidebarToggle = simulator.SidebarToggle;
+exports.SimpleSidebar = simulator.SimpleSidebar;
+exports.Simulator = simulator.Simulator;
+exports.ThemeProvider = simulator.ThemeProvider;
+exports.extractResourceCSP = simulator.extractResourceCSP;
+exports.getHostShell = simulator.getHostShell;
+exports.getRegisteredHosts = simulator.getRegisteredHosts;
+exports.registerHostShell = simulator.registerHostShell;
+exports.useSimulatorState = simulator.useSimulatorState;
+exports.useThemeContext = simulator.useThemeContext;
+exports.createSimulatorUrl = simulatorUrl.createSimulatorUrl;
+exports.buildDevSimulations = discovery.buildDevSimulations;
+exports.buildResourceMap = discovery.buildResourceMap;
+exports.buildSimulations = discovery.buildSimulations;
+exports.createResourceExports = discovery.createResourceExports;
+exports.extractResourceKey = discovery.extractResourceKey;
+exports.extractSimulationKey = discovery.extractSimulationKey;
+exports.extractSimulationName = discovery.extractSimulationName;
+exports.findResourceDirs = discovery.findResourceDirs;
+exports.findResourceKey = discovery.findResourceKey;
+exports.findSimulationFiles = discovery.findSimulationFiles;
+exports.getComponentName = discovery.getComponentName;
+exports.isSimulationFile = discovery.isSimulationFile;
+exports.toPascalCase = discovery.toPascalCase;
+//# sourceMappingURL=index.cjs.map

package/dist/simulator/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/simulator/index.d.ts

@@ -0,0 +1,18 @@
+export { Simulator } from './simulator';
+export type { SimulatorProps } from './simulator';
+export { useSimulatorState } from './use-simulator-state';
+export type { UseSimulatorStateOptions, SimulatorState } from './use-simulator-state';
+export { registerHostShell, getHostShell, getRegisteredHosts } from './hosts';
+export type { HostConversationProps, HostShell, HostId } from './hosts';
+export { McpAppHost } from './mcp-app-host';
+export type { McpAppHostOptions } from './mcp-app-host';
+export { IframeResource, extractResourceCSP } from './iframe-resource';
+export type { ResourceCSP } from './iframe-resource';
+export { ThemeProvider, useThemeContext } from './theme-provider';
+export type { ScreenWidth, SimulatorConfig } from './simulator-types';
+export { SCREEN_WIDTHS } from './simulator-types';
+export { createSimulatorUrl } from './simulator-url';
+export type { SimulatorUrlParams } from './simulator-url';
+export { SimpleSidebar, SidebarControl, SidebarCollapsibleControl, SidebarSelect, SidebarInput, SidebarCheckbox, SidebarTextarea, SidebarToggle, } from './simple-sidebar';
+export { buildDevSimulations, buildSimulations, buildResourceMap, createResourceExports, toPascalCase, extractResourceKey, extractSimulationKey, findResourceKey, getComponentName, findResourceDirs, isSimulationFile, extractSimulationName, findSimulationFiles, } from '../lib/discovery';
+export type { BuildSimulationsOptions, BuildDevSimulationsOptions, ResourceMetadata, ResourceDirInfo, FsOps, } from '../lib/discovery';

package/dist/simulator/index.js

@@ -0,0 +1,39 @@
+import { I, M, a, b, c, d, e, f, g, h, i, S, T, j, k, l, r, u, m } from "../simulator-CxrtnguM.js";
+import { c as c2 } from "../simulator-url-CuLqtnSS.js";
+import { b as b2, a as a2, c as c3, d as d2, e as e2, f as f2, g as g2, h as h2, i as i2, j as j2, k as k2, l as l2, t } from "../discovery-DzV3HLXs.js";
+export {
+  I as IframeResource,
+  M as McpAppHost,
+  a as SCREEN_WIDTHS,
+  b as SidebarCheckbox,
+  c as SidebarCollapsibleControl,
+  d as SidebarControl,
+  e as SidebarInput,
+  f as SidebarSelect,
+  g as SidebarTextarea,
+  h as SidebarToggle,
+  i as SimpleSidebar,
+  S as Simulator,
+  T as ThemeProvider,
+  b2 as buildDevSimulations,
+  a2 as buildResourceMap,
+  c3 as buildSimulations,
+  d2 as createResourceExports,
+  c2 as createSimulatorUrl,
+  j as extractResourceCSP,
+  e2 as extractResourceKey,
+  f2 as extractSimulationKey,
+  g2 as extractSimulationName,
+  h2 as findResourceDirs,
+  i2 as findResourceKey,
+  j2 as findSimulationFiles,
+  k2 as getComponentName,
+  k as getHostShell,
+  l as getRegisteredHosts,
+  l2 as isSimulationFile,
+  r as registerHostShell,
+  t as toPascalCase,
+  u as useSimulatorState,
+  m as useThemeContext
+};
+//# sourceMappingURL=index.js.map

package/dist/simulator/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/{chatgpt → simulator}/mcp-app-host.d.ts

@@ -1,7 +1,14 @@
-import { McpUiHostContext, McpUiDisplayMode } from '@modelcontextprotocol/ext-apps/app-bridge';
+import { McpUiHostContext, McpUiDisplayMode, McpUiHostCapabilities } from '@modelcontextprotocol/ext-apps/app-bridge';
 import { CallToolRequest, CallToolResult, LoggingMessageNotification } from '@modelcontextprotocol/sdk/types.js';
 export interface McpAppHostOptions {
     hostContext?: McpUiHostContext;
+    /** Host info reported to the app via MCP protocol. Defaults to SunpeakSimulator. */
+    hostInfo?: {
+        name: string;
+        version: string;
+    };
+    /** Host capabilities reported to the app. Defaults to baseline MCP capabilities. */
+    hostCapabilities?: McpUiHostCapabilities;
     onDisplayModeChange?: (mode: McpUiDisplayMode) => void;
     onMessage?: (role: string, content: unknown[]) => void;
     onOpenLink?: (url: string) => void;

package/dist/simulator/mock-openai-runtime.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Mock OpenAI runtime for the simulator.
+ *
+ * ChatGPT-specific hooks (useUploadFile, useRequestModal, etc.) call
+ * `window.openai` directly — they don't use the MCP protocol. When the
+ * ChatGPT host is selected in the simulator, we inject this mock into
+ * the iframe's window so those hooks work during local development.
+ */
+/**
+ * Inline script that sets up a mock `window.openai` for srcdoc iframes.
+ * Embedded in the generated HTML *before* the app's script so that
+ * `isChatGPT()` and hooks work from the very first render.
+ */
+export declare const MOCK_OPENAI_RUNTIME_SCRIPT: string;
+/**
+ * Create a mock OpenAI runtime object for direct injection into an
+ * iframe's `contentWindow`. Used for src-mode iframes (dev with Vite)
+ * where we can't embed inline scripts in the page.
+ */
+export declare function createMockOpenAIRuntime(): Record<string, (...args: never[]) => unknown>;

package/dist/{chatgpt → simulator}/simulator-url.d.ts

@@ -1,6 +1,6 @@
 import { Theme, DisplayMode, DeviceType } from '../types/runtime';
 /**
- * Strongly-typed URL parameters for the ChatGPT Simulator.
+ * Strongly-typed URL parameters for the Simulator.
  *
  * Use with `createSimulatorUrl()` to generate type-safe URL paths for e2e tests.
  *
@@ -13,6 +13,7 @@ import { Theme, DisplayMode, DeviceType } from '../types/runtime';
  *   simulation: 'albums-show',
  *   theme: 'dark',
  *   displayMode: 'fullscreen',
+ *   host: 'claude',
  * }));
  * ```
  */
@@ -22,6 +23,12 @@ export interface SimulatorUrlParams {
      * Corresponds to the simulation JSON filename without the '-simulation.json' suffix.
      */
     simulation?: string;
+    /**
+     * The host shell to use (e.g., 'chatgpt', 'claude').
+     * Switches conversation chrome, theming, and reported host info/capabilities.
+     * @default 'chatgpt'
+     */
+    host?: string;
     /**
      * The color theme for the simulator.
      * @default 'dark'

package/dist/simulator/simulator.d.ts

@@ -0,0 +1,12 @@
+import { HostId } from './hosts';
+import { Simulation } from '../types/simulation';
+import * as React from 'react';
+export interface SimulatorProps {
+    children?: React.ReactNode;
+    simulations?: Record<string, Simulation>;
+    appName?: string;
+    appIcon?: string;
+    /** Which host shell to use initially. Defaults to 'chatgpt'. */
+    defaultHost?: HostId;
+}
+export declare function Simulator({ children, simulations, appName, appIcon, defaultHost, }: SimulatorProps): import("react/jsx-runtime").JSX.Element;

package/dist/{chatgpt → simulator}/theme-provider.d.ts

@@ -4,10 +4,12 @@ type ThemeProviderProps = {
     children: React.ReactNode;
     defaultTheme?: Theme;
     theme?: Theme;
+    /** Custom theme applier. If not provided, falls back to setting data-theme attribute. */
+    applyTheme?: (theme: Theme) => void;
 };
 type ThemeProviderState = {
     theme: Theme;
 };
-export declare function ThemeProvider({ children, defaultTheme, theme: controlledTheme, ...props }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function ThemeProvider({ children, defaultTheme, theme: controlledTheme, applyTheme, ...props }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
 export declare const useThemeContext: () => ThemeProviderState;
 export {};

package/dist/simulator/use-simulator-state.d.ts

@@ -0,0 +1,91 @@
+import { McpUiHostContext, McpUiDisplayMode, McpUiTheme, McpUiResourcePermissions } from '@modelcontextprotocol/ext-apps';
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { Simulation } from '../types/simulation';
+import { ScreenWidth } from './simulator-types';
+import { HostId } from './hosts';
+import { ResourceCSP } from './iframe-resource';
+type Platform = NonNullable<McpUiHostContext['platform']>;
+export interface UseSimulatorStateOptions {
+    simulations: Record<string, Simulation>;
+    defaultHost?: HostId;
+}
+export interface SimulatorState {
+    simulationNames: string[];
+    selectedSimulationName: string;
+    setSelectedSimulationName: (name: string) => void;
+    selectedSim: Simulation | undefined;
+    activeHost: HostId;
+    setActiveHost: (host: HostId) => void;
+    screenWidth: ScreenWidth;
+    setScreenWidth: (width: ScreenWidth) => void;
+    theme: McpUiTheme;
+    setTheme: (theme: McpUiTheme) => void;
+    displayMode: McpUiDisplayMode;
+    setDisplayMode: (mode: McpUiDisplayMode) => void;
+    locale: string;
+    setLocale: (locale: string) => void;
+    containerMaxHeight: number;
+    setContainerMaxHeight: (height: number) => void;
+    platform: Platform;
+    setPlatform: (platform: Platform) => void;
+    hover: boolean;
+    setHover: (hover: boolean) => void;
+    touch: boolean;
+    setTouch: (touch: boolean) => void;
+    safeAreaInsets: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    setSafeAreaInsets: React.Dispatch<React.SetStateAction<{
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    }>>;
+    timeZone: string;
+    setTimeZone: (tz: string) => void;
+    userAgent: string;
+    setUserAgent: (ua: string) => void;
+    hostContext: McpUiHostContext;
+    readyDisplayMode: McpUiDisplayMode;
+    handleDisplayModeReady: (mode: string) => void;
+    isTransitioning: boolean;
+    toolInput: Record<string, unknown>;
+    setToolInput: (input: Record<string, unknown>) => void;
+    toolResult: CallToolResult | undefined;
+    setToolResult: (result: CallToolResult | undefined) => void;
+    effectiveToolResult: CallToolResult | undefined;
+    modelContext: Record<string, unknown> | null;
+    setModelContext: (ctx: Record<string, unknown> | null) => void;
+    toolInputJson: string;
+    setToolInputJson: (json: string) => void;
+    toolInputError: string;
+    setToolInputError: (error: string) => void;
+    toolResultJson: string;
+    setToolResultJson: (json: string) => void;
+    toolResultError: string;
+    setToolResultError: (error: string) => void;
+    modelContextJson: string;
+    setModelContextJson: (json: string) => void;
+    modelContextError: string;
+    setModelContextError: (error: string) => void;
+    editingField: string | null;
+    setEditingField: (field: string | null) => void;
+    validateJSON: (json: string, setJson: (value: string) => void, setError: (error: string) => void) => void;
+    commitJSON: (json: string, setError: (error: string) => void, updateFn: (value: Record<string, unknown> | null) => void) => void;
+    handleDisplayModeChange: (mode: McpUiDisplayMode) => void;
+    handleUpdateModelContext: (content: unknown[], structuredContent?: unknown) => void;
+    toolInputPartial: Record<string, unknown> | undefined;
+    sendToolInputPartial: () => void;
+    resourceUrl: string | undefined;
+    resourceScript: string | undefined;
+    csp: ResourceCSP | undefined;
+    permissions: McpUiResourcePermissions | undefined;
+    prefersBorder: boolean;
+    domain: string | undefined;
+    hasIframeContent: boolean;
+}
+export declare function useSimulatorState({ simulations, defaultHost, }: UseSimulatorStateOptions): SimulatorState;
+export {};