@bleedingdev/modern-js-mcp-apps 0.0.0-bootstrap → 3.11.3-ultramodern.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,69 @@
-# Namespace bootstrap only
+# @modern-js/mcp-apps
 
-This deprecated placeholder reserves the UltraModern MCP Apps package identity for GitHub trusted publishing. It contains no implementation and must not be installed as a framework release.
+Build React MCP cards with Modern.js and write servers with the official MCP SDK.
+The UI build and the server exchange only `ui-manifest.json`.
+
+Install `react`, `react-dom`, `@modelcontextprotocol/server` and `@modelcontextprotocol/ext-apps` in the application. They are required peers so cards use the application's React and resource registration and HTTP handling use the application's SDK versions. `@modern-js/server-runtime` is an optional peer that provides the default `useContext` for `createBffHandlers`, loaded when a BFF handler is invoked. Standalone Fetch servers do not need it. `@module-federation/enhanced` is an optional peer that provides the default MF shell runtime.
+
+- `@modern-js/mcp-apps/cli` exports the `mcpAppsPlugin` build plugin
+- `@modern-js/mcp-apps/server-plugin` is the server plugin, loaded by name by the framework
+- `@modern-js/mcp-apps/server` exports `registerUiResources`, `createFetchHandler` and `createBffHandlers`
+- `@modern-js/mcp-apps/react` exports `McpViewProps`, `createMcpView`, `useMcpApp` and official host styling hooks
+
+## Build plugin
+
+Declare React cards in `mcp-views.json` and enable `mcpAppsPlugin({ views: './mcp-views.json' })`.
+
+```json
+{
+  "views": {
+    "todos": "./src/components/Todos.tsx",
+    "stats": { "expose": "./Stats" }
+  },
+  "csp": { "resourceDomains": [], "connectDomains": [] },
+  "prefersBorder": true
+}
+```
+
+Component paths resolve relative to the JSON file. Components must have a default export. MF exposes refer to this application's MF manifest output and must also have a default component export. `{ "remote": "https://host/mf-manifest.json", "expose": "./Name" }` refers to a deployed remote instead. Set `remote` at the top level alongside `csp` to share it across all expose views, for example `{ "remote": "https://host/mf-manifest.json", "views": { "todos": { "expose": "./Todos" }, "stats": { "expose": "./Stats" } } }`. A view-level `remote` overrides this default. Component paths remain local. Without either remote setting, exposes refer to this application. With a top-level `remote`, expose views in the same config cannot refer to this application's exposes, so set `remote` per view to mix both. The URL must point to the remote's manifest, with a path ending in `.json`, and the runtime reads the remote's name from it. The shell loads the remote manifest when the card opens, so republishing the remote needs no MCP server rebuild. Its exposes are not checked at build time, and the application needs no MF plugin. The manifest origin is added to CSP. Declare other origins serving the remote's chunks in `csp`. Local cards are added as application entries and reuse the framework's multi-entry compilation, including its loaders, styles and build plugins. Only the MF shell uses a separate Rsbuild compilation with the application's React dependencies, with its startup scripts and styles inlined. The plugin emits `dist/mcp-apps/ui-manifest.json` and never registers HTTP routes.
+
+- `mf.manifestFile` is the MF manifest filename in the web build output. It defaults to `mf-manifest.json` and must match exactly one emitted file.
+- `mf.runtime` is the module, resolved from the application, that the MF shell imports `createInstance` from. It defaults to `@module-federation/enhanced/runtime`.
+- `csp` adds CSP domains to every view, merged with the `csp` in `mcp-views.json`. Use it for domains computed in the framework or application config.
+
+The build also adds the origin of an absolute or protocol-relative asset prefix (`//cdn.example/app/` becomes `https://cdn.example`) to every view's `resourceDomains` and `connectDomains`, because card scripts and chunks load from it. A protocol-relative prefix keeps `assetBase` request-relative, so the UI manifest and MF manifest still load from the server.
+
+Local card entries mount React directly through `createMcpView` without the framework page runtime, because an opaque MCP Apps sandbox cannot read page cookies. With `source.enableAsyncEntry`, which the MF plugin enables, each entry adds a dynamic import boundary for MF shared initialization.
+
+`createBffHandlers(createServer, { useContext })` accepts the function returning the current Hono context. It defaults to `useHonoContext` from `@modern-js/server-runtime`. Frameworks wrapping Modern.js pass their own implementation.
+
+`registerUiResources()` loads the manifest asynchronously. The Modern.js server plugin provides the manifest path and runtime mode through the request created by `createBffHandlers`. Call `registerUiResources(server, { request })` to resolve them automatically. Explicit options override injected configuration. Standalone services must set `manifest` to a path or HTTP(S) URL and may set `mode` to `development` for live updates. The default mode is `production`. Relative HTML and shell files resolve against that location. Parsed manifests are cached per source URL and environment. Production keeps successful loads for the process lifetime, so updating a manifest at the same location requires a process restart. Development checks local file metadata on each registration and caches remote manifests for 60 seconds. Concurrent loads share one request and failures are retried. HTML is still read when a resource is requested, and request-specific origins are never cached.
+
+`await registerUiResources(server, { request })` returns view names mapped to `ui://app/<encoded-name>`. Register tools with the official `registerAppTool` helper and put the chosen URI in `_meta.ui.resourceUri`. MF selection is injected into the resource HTML rather than tool results.
+
+`assetBase` is a public directory URL or `request`. Request mode uses the request origin, honoring a sanitized `x-forwarded-proto`. Override `assetBase` at registration for an external static origin or path prefix. Resources add their required asset, connection and base URI origins to CSP while preserving configured metadata. Other chunk/CDN origins must be declared in `csp` or `mcp-views.json`.
+
+`createFetchHandler(createServer)` returns a standard Request/Response handler. It uses the SDK's stateless HTTP serving and rejects foreign browser origins unless configured through `allowedOrigins`. Authentication and authorization belong to the surrounding middleware or server factory. `createServer` must return a fresh official `McpServer` per request. `createBffHandlers` adapts the same factory to Modern BFF's consumed request body and exports POST, GET and DELETE handlers. The stateless SDK rejects unsupported session operations.
+
+Card component props are the latest successful `structuredContent` plus the reserved `mcpApp` field. Input arguments are not merged into props. New input, cancellation and teardown clear previous output. The default wrapper shows loading, cancellation and error states.
+
+See the MCP Apps guide in the Modern.js documentation for configuration and deployment examples.
+
+Cards advertise `inline` and `fullscreen` display modes by default. A local component module or MF expose can export `mcpCapabilities` to override display modes or declare additional SDK capabilities:
+
+<!-- prettier-ignore -->
+```tsx
+import type { McpCapabilities } from '@modern-js/mcp-apps/react'
+
+export const mcpCapabilities = {
+  availableDisplayModes: ['inline'],
+} satisfies McpCapabilities
+
+export default function Card() {
+  return <div>My card</div>
+}
+```
+
+`createMcpView(View, appInfo, capabilities)` accepts the same options directly. Properties are merged with the defaults, and an explicit `availableDisplayModes` array replaces the default array. MF modules are loaded before the handshake so their capabilities are included in initialization. Declaring fullscreen support does not add a fullscreen control or change the display mode automatically.
+
+Development resource CSP includes the request origin's `ws:` or `wss:` equivalent for the application HMR connection. Custom HMR hosts still need explicit `connectDomains` configuration. Production resources do not add this permission automatically.

package/dist/cjs/cli.cjs

@@ -0,0 +1,471 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>cli,
+    mcpAppsPlugin: ()=>mcpAppsPlugin
+});
+const promises_namespaceObject = require("node:fs/promises");
+var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_url_namespaceObject = require("node:url");
+const core_namespaceObject = require("@rsbuild/core");
+function isRecord(value) {
+    return null !== value && 'object' == typeof value && !Array.isArray(value);
+}
+function validateUiMetadata(value) {
+    if (!isRecord(value)) throw new Error('UI metadata must be an object');
+    if (void 0 !== value.prefersBorder && 'boolean' != typeof value.prefersBorder) throw new Error('prefersBorder must be a boolean');
+    if (void 0 !== value.domain && 'string' != typeof value.domain) throw new Error('domain must be a string');
+    if (void 0 !== value.permissions && !isRecord(value.permissions)) throw new Error('permissions must be an object');
+    if (void 0 !== value.csp) {
+        if (!isRecord(value.csp)) throw new Error('csp must be an object');
+        for (const [key, domains] of Object.entries(value.csp))if (![
+            'resourceDomains',
+            'connectDomains',
+            'frameDomains',
+            'baseUriDomains'
+        ].includes(key) || !Array.isArray(domains) || domains.some((domain)=>'string' != typeof domain)) throw new Error(`Invalid CSP field: ${key}`);
+    }
+}
+function validateViewsConfig(value) {
+    if (!isRecord(value) || !isRecord(value.views)) throw new Error('mcp-views.json requires a views object');
+    validateUiMetadata(value);
+    if (void 0 !== value.remote) {
+        if ('string' != typeof value.remote) throw new Error('remote must be a string');
+        assertRemoteManifest(value.remote);
+    }
+    for (const key of Object.keys(value))if (![
+        'views',
+        'remote',
+        'csp',
+        'prefersBorder',
+        'permissions',
+        'domain'
+    ].includes(key)) throw new Error(`Unknown MCP views option: ${key}`);
+    for (const [name, view] of Object.entries(value.views)){
+        if (!name.trim()) throw new Error('View names must be non-empty');
+        if (!('string' == typeof view && view.trim())) {
+            if (isRecord(view) && 'string' == typeof view.expose && view.expose.startsWith('./') && Object.keys(view).every((key)=>'expose' === key || 'remote' === key)) {
+                if (!('remote' in view)) continue;
+                if ('string' == typeof view.remote) {
+                    assertRemoteManifest(view.remote);
+                    continue;
+                }
+            }
+            throw new Error(`Invalid view: ${name}. Use a component path, { expose: './Name' } or { remote: 'https://host/mf-manifest.json', expose: './Name' }`);
+        }
+    }
+}
+function assertRemoteManifest(remote) {
+    if (!/^https?:\/\//.test(remote) || !assertHttpUrl(remote).pathname.endsWith('.json')) throw new Error(`Invalid MF remote: ${remote}. Use https://host/mf-manifest.json`);
+}
+function assertHttpUrl(source) {
+    const url = new URL(source);
+    if (![
+        'http:',
+        'https:'
+    ].includes(url.protocol) || url.username || url.password) throw new Error(`Invalid UI URL: ${source}`);
+    return url;
+}
+const external_node_crypto_namespaceObject = require("node:crypto");
+function assetPrefixOrigin(prefix) {
+    if ('string' != typeof prefix) return;
+    if (prefix.startsWith('//')) return new URL(`https:${prefix}`).origin;
+    if (/^https?:\/\//.test(prefix)) return new URL(prefix).origin;
+}
+function mergeCsp(...sources) {
+    const merged = {};
+    for (const source of sources)for (const [key, domains] of Object.entries(source ?? {}))merged[key] = [
+        ...new Set([
+            ...merged[key] ?? [],
+            ...domains ?? []
+        ])
+    ];
+    return Object.keys(merged).length ? merged : void 0;
+}
+function viewEntryName(name) {
+    const label = name.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/-+/g, '-').slice(0, 48).replace(/^-+|-+$/g, '') || 'view';
+    const hash = (0, external_node_crypto_namespaceObject.createHash)('sha256').update(name).digest('hex').slice(0, 12);
+    return `mcp-ui-${label}-${hash}`;
+}
+function findMfManifest(assets, manifestFile) {
+    const matches = assets.filter((asset)=>external_node_path_default().posix.basename(asset.name) === manifestFile);
+    if (1 !== matches.length) throw new Error(`Expected one MF manifest named ${manifestFile} in the web compilation, found ${matches.length}${matches.length ? `: ${matches.map((asset)=>asset.name).join(', ')}` : ''}. Set mf.manifestFile to the manifest filename`);
+    const [asset] = matches;
+    const manifest = JSON.parse(String(asset.source.source()));
+    if (!manifest || 'string' != typeof manifest.name || !Array.isArray(manifest.exposes)) throw new Error(`Invalid MF manifest: ${asset.name}`);
+    return {
+        filename: asset.name,
+        manifest: manifest
+    };
+}
+function createUiManifest(config, prefix, mf, csp) {
+    validateViewsConfig(config);
+    if (void 0 !== csp) validateUiMetadata({
+        csp
+    });
+    const { views, remote: defaultRemote, ...metadata } = config;
+    const assetOrigin = assetPrefixOrigin(prefix);
+    const mergedCsp = mergeCsp(metadata.csp, csp, assetOrigin ? {
+        resourceDomains: [
+            assetOrigin
+        ],
+        connectDomains: [
+            assetOrigin
+        ]
+    } : void 0);
+    const ui = {
+        prefersBorder: true,
+        ...metadata,
+        ...mergedCsp ? {
+            csp: mergedCsp
+        } : {}
+    };
+    const manifest = {
+        version: 1,
+        assetBase: 'string' == typeof prefix && /^https?:\/\//.test(prefix) ? `${prefix.replace(/\/+$/, '')}/` : 'request',
+        remotes: Object.create(null),
+        views: Object.create(null)
+    };
+    for (const [name, source] of Object.entries(views)){
+        if ('string' == typeof source) {
+            manifest.views[name] = {
+                html: `./ui/${viewEntryName(name)}.html`,
+                ui
+            };
+            continue;
+        }
+        let remote;
+        let entry;
+        const deployedRemote = source.remote ?? defaultRemote;
+        if (void 0 !== deployedRemote) {
+            entry = deployedRemote;
+            remote = `mcp-remote-${(0, external_node_crypto_namespaceObject.createHash)('sha256').update(entry).digest('hex').slice(0, 12)}`;
+        } else {
+            if (!mf) throw new Error(`View ${name} requires a Module Federation manifest. Enable the MF plugin and manifest output`);
+            if (!mf.manifest.exposes.some((item)=>item.name.replace(/^\.\//, '') === source.expose.slice(2))) throw new Error(`View ${name} references missing MF expose: ${source.expose}`);
+            const assetPath = 'string' == typeof prefix && prefix.startsWith('/') && !prefix.startsWith('//') ? prefix.replace(/^\/+|\/+$/g, '') : '';
+            entry = [
+                assetPath,
+                mf.filename
+            ].filter(Boolean).join('/');
+            remote = mf.manifest.name;
+        }
+        manifest.remotes[remote] = {
+            entry,
+            shell: './ui/mcp-shell.html'
+        };
+        manifest.views[name] = {
+            remote,
+            expose: source.expose,
+            ui
+        };
+    }
+    return manifest;
+}
+async function writeArtifact(filename, contents) {
+    await promises_default().mkdir(external_node_path_default().dirname(filename), {
+        recursive: true
+    });
+    await promises_default().writeFile(`${filename}.tmp`, contents);
+    await promises_default().rename(`${filename}.tmp`, filename);
+}
+const packageFile = (filename)=>external_node_path_default().resolve(external_node_path_default().dirname((0, external_node_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__)), '../..', 'dist/esm', filename);
+const mcpAppsPlugin = (options = {})=>({
+        name: '@modern-js/mcp-apps',
+        post: [
+            '@modern-js/runtime'
+        ],
+        setup (api) {
+            api._internalServerPlugins(({ plugins })=>{
+                const ctx = api.getAppContext();
+                plugins.push({
+                    name: '@modern-js/mcp-apps/server-plugin',
+                    options: [
+                        'dev',
+                        'start'
+                    ].includes(ctx.command) ? {
+                        developmentManifest: external_node_path_default().join(ctx.internalDirectory, 'mcp-apps/ui-manifest.json')
+                    } : {}
+                });
+                return {
+                    plugins
+                };
+            });
+            let definition;
+            const attachedCompilers = new WeakSet();
+            const shellHtml = new Map();
+            const shellAssets = new Map();
+            let buildShell;
+            let shellDirty = true;
+            let shellBuild;
+            const localEntries = new Set();
+            const configPath = ()=>external_node_path_default().resolve(api.getAppContext().appDirectory, options.views ?? 'mcp-views.json');
+            api.addWatchFiles(()=>[
+                    configPath()
+                ]);
+            api.modifyEntrypoints(async ({ entrypoints: current })=>{
+                const ctx = api.getAppContext();
+                const source = JSON.parse(await promises_default().readFile(configPath(), 'utf8'));
+                validateViewsConfig(source);
+                definition = source;
+                const appRequire = (0, external_node_module_namespaceObject.createRequire)(external_node_path_default().join(ctx.appDirectory, 'package.json'));
+                const needsMf = Object.values(definition.views).some((view)=>'string' != typeof view);
+                localEntries.clear();
+                shellHtml.clear();
+                shellAssets.clear();
+                buildShell = void 0;
+                shellDirty = true;
+                const shellEntries = {};
+                const entryDir = external_node_path_default().join(ctx.internalDirectory, 'mcp-apps/entries');
+                const entrypoints = current.filter((entry)=>entry.absoluteEntryDir !== entryDir);
+                const { enableAsyncEntry } = api.getNormalizedConfig().source;
+                for (const [name, source] of Object.entries(definition.views)){
+                    if ('string' != typeof source) continue;
+                    const entryName = viewEntryName(name);
+                    if (entrypoints.some((entry)=>entry.entryName === entryName)) throw new Error(`MCP entry conflicts with application entry: ${entryName}`);
+                    const entry = external_node_path_default().join(entryDir, `${entryName}.jsx`);
+                    const mountEntry = enableAsyncEntry ? external_node_path_default().join(entryDir, `${entryName}-mount.jsx`) : entry;
+                    await writeArtifact(mountEntry, `import React from ${JSON.stringify(appRequire.resolve('react'))};\nimport { createRoot } from ${JSON.stringify(appRequire.resolve('react-dom/client'))};\nimport { createMcpView } from ${JSON.stringify(packageFile('react.mjs'))};\nimport View, * as viewModule from ${JSON.stringify(external_node_path_default().resolve(external_node_path_default().dirname(configPath()), source))};\ncreateRoot(document.getElementById('root')).render(React.createElement(createMcpView(View, ${JSON.stringify({
+                        name,
+                        version: '1.0.0'
+                    })}, Reflect.get(viewModule, 'mcpCapabilities'))));\n`);
+                    if (enableAsyncEntry) await writeArtifact(entry, `import(${JSON.stringify(mountEntry)});\n`);
+                    localEntries.add(entryName);
+                    entrypoints.push({
+                        entryName,
+                        entry,
+                        isMainEntry: false,
+                        isAutoMount: false,
+                        absoluteEntryDir: entryDir
+                    });
+                }
+                if (needsMf) shellEntries['mcp-shell'] = packageFile('mf-entry.mjs');
+                if (Object.keys(shellEntries).length) {
+                    const shellOutput = external_node_path_default().join(ctx.internalDirectory, 'mcp-apps/shell');
+                    const config = api.getNormalizedConfig();
+                    const development = [
+                        'dev',
+                        'start'
+                    ].includes(ctx.command);
+                    const assetPrefix = development ? config.dev.assetPrefix : config.output.assetPrefix;
+                    const shell = await (0, core_namespaceObject.createRsbuild)({
+                        cwd: ctx.appDirectory,
+                        rsbuildConfig: {
+                            mode: 'production',
+                            html: {
+                                inject: 'body',
+                                title: 'MCP App'
+                            },
+                            source: {
+                                entry: shellEntries,
+                                define: {
+                                    ...config.source.define,
+                                    'process.env.NODE_ENV': JSON.stringify(development ? 'development' : 'production')
+                                }
+                            },
+                            resolve: {
+                                alias: {
+                                    ...config.source.alias,
+                                    ...Object.fromEntries([
+                                        'react',
+                                        'react-dom',
+                                        'react-dom/client',
+                                        'react/jsx-runtime',
+                                        'react/jsx-dev-runtime'
+                                    ].map((name)=>[
+                                            name + '$',
+                                            appRequire.resolve(name)
+                                        ])),
+                                    ...needsMf ? {
+                                        '@module-federation/enhanced/runtime$': appRequire.resolve(options.mf?.runtime ?? '@module-federation/enhanced/runtime')
+                                    } : {}
+                                }
+                            },
+                            output: {
+                                distPath: {
+                                    root: shellOutput
+                                },
+                                assetPrefix: 'string' == typeof assetPrefix ? assetPrefix : void 0,
+                                inlineScripts: true,
+                                inlineStyles: true,
+                                legalComments: 'inline'
+                            },
+                            tools: {
+                                swc: {
+                                    jsc: {
+                                        transform: {
+                                            react: {
+                                                runtime: 'automatic'
+                                            }
+                                        }
+                                    }
+                                },
+                                rspack: {
+                                    optimization: {
+                                        splitChunks: false,
+                                        nodeEnv: false
+                                    },
+                                    module: {
+                                        parser: {
+                                            javascript: {
+                                                dynamicImportMode: 'eager'
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    });
+                    const compileShell = async ()=>{
+                        const result = await shell.build();
+                        await result.close();
+                        shellAssets.clear();
+                        for (const filename of (await promises_default().readdir(shellOutput, {
+                            recursive: true
+                        }))){
+                            const absolute = external_node_path_default().join(shellOutput, filename);
+                            if (!filename.endsWith('.html') && (await promises_default().stat(absolute)).isFile()) shellAssets.set(filename.replaceAll(external_node_path_default().sep, '/'), await promises_default().readFile(absolute));
+                        }
+                        for (const name of Object.keys(shellEntries))shellHtml.set(name, await promises_default().readFile(external_node_path_default().join(shellOutput, `${name}.html`), 'utf8'));
+                    };
+                    buildShell = ()=>{
+                        if (shellBuild) return shellBuild;
+                        if (!shellDirty) return Promise.resolve();
+                        shellDirty = false;
+                        shellBuild = compileShell().catch((error)=>{
+                            shellDirty = true;
+                            throw error;
+                        }).finally(()=>{
+                            shellBuild = void 0;
+                        });
+                        return shellBuild;
+                    };
+                }
+                return {
+                    entrypoints
+                };
+            });
+            api.modifyRsbuildConfig((config)=>{
+                const lazy = config.dev?.lazyCompilation;
+                if (!lazy) return config;
+                const current = 'object' == typeof lazy ? lazy : {};
+                const test = current.test;
+                const internal = api.getAppContext().internalDirectory;
+                const eager = [
+                    external_node_path_default().join(internal, 'mcp-apps/entries') + external_node_path_default().sep
+                ];
+                config.dev = {
+                    ...config.dev,
+                    lazyCompilation: {
+                        ...current,
+                        test (module) {
+                            const resource = module.resource;
+                            if (resource && eager.some((directory)=>resource.startsWith(directory))) return false;
+                            return 'function' == typeof test ? test(module) : test instanceof RegExp ? test.test(resource ?? '') : true;
+                        }
+                    }
+                };
+                return config;
+            });
+            api.onAfterCreateCompiler(({ compiler, environments })=>{
+                api.onBeforeRestart(()=>new Promise((resolve, reject)=>compiler.close((error)=>error ? reject(error) : resolve())));
+                const compilers = 'compilers' in compiler ? compiler.compilers : [
+                    compiler
+                ];
+                for (const child of compilers){
+                    if (attachedCompilers.has(child)) continue;
+                    const environment = environments[child.name ?? 'client'];
+                    if (environment && 'web' === environment.config.output.target) {
+                        attachedCompilers.add(child);
+                        child.hooks.invalid.tap('modern-mcp-card-invalidate', ()=>{
+                            shellDirty = true;
+                        });
+                        child.hooks.beforeCompile.tapPromise('modern-mcp-card-build', async ()=>{
+                            await buildShell?.();
+                        });
+                        child.hooks.thisCompilation.tap('modern-mcp-card-html', (compilation)=>{
+                            compilation.hooks.processAssets.tap({
+                                name: 'modern-mcp-card-html',
+                                stage: child.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT
+                            }, ()=>{
+                                for (const [filename, contents] of shellAssets)if (!compilation.getAsset(filename)) compilation.emitAsset(filename, new child.webpack.sources.RawSource(contents));
+                            });
+                        });
+                        child.hooks.afterEmit.tapPromise('modern-mcp-ui-manifest', async (compilation)=>{
+                            if (compilation.errors.length) return;
+                            const ctx = api.getAppContext();
+                            const development = [
+                                'dev',
+                                'start'
+                            ].includes(ctx.command);
+                            const output = external_node_path_default().join(development ? ctx.internalDirectory : ctx.distDirectory, 'mcp-apps');
+                            let mf;
+                            if (Object.values(definition.views).some((view)=>'string' != typeof view && void 0 === view.remote && void 0 === definition.remote)) mf = findMfManifest(compilation.getAssets(), options.mf?.manifestFile ?? 'mf-manifest.json');
+                            const config = api.getNormalizedConfig();
+                            const manifest = createUiManifest(definition, development ? config.dev.assetPrefix : config.output.assetPrefix, mf, options.csp);
+                            for (const name of localEntries){
+                                const htmlPath = environment.htmlPaths[name];
+                                const html = htmlPath && compilation.getAsset(htmlPath);
+                                if (!html) throw new Error(`Missing MCP HTML output: ${name}`);
+                                await writeArtifact(external_node_path_default().join(output, 'ui', `${name}.html`), html.source.source());
+                            }
+                            for (const [name, html] of shellHtml)await writeArtifact(external_node_path_default().join(output, 'ui', `${name}.html`), html);
+                            await writeArtifact(external_node_path_default().join(output, 'ui-manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`);
+                        });
+                    }
+                }
+            });
+        }
+    });
+const cli = mcpAppsPlugin;
+exports["default"] = __webpack_exports__["default"];
+exports.mcpAppsPlugin = __webpack_exports__.mcpAppsPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "mcpAppsPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/server-plugin.cjs

@@ -0,0 +1,79 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>server_plugin
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const server_plugin = (options = {})=>({
+        name: '@modern-js/mcp-apps/server-plugin',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares, distDirectory } = api.getServerContext();
+                const uiOptions = options.developmentManifest ? {
+                    manifest: options.developmentManifest,
+                    mode: 'development'
+                } : {
+                    manifest: external_node_path_default().join(distDirectory, 'mcp-apps/ui-manifest.json'),
+                    mode: 'production'
+                };
+                middlewares.push({
+                    name: 'mcp-apps-context',
+                    before: [
+                        'bind-bff',
+                        'hono-bff-api'
+                    ],
+                    handler: async (context, next)=>{
+                        context.set('locals', {
+                            ...context.get('locals'),
+                            modernMcpApps: uiOptions
+                        });
+                        await next();
+                    }
+                });
+            });
+        }
+    });
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});