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

package/dist/esm-node/cli.mjs

@@ -0,0 +1,360 @@
+import promises from "node:fs/promises";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRsbuild } from "@rsbuild/core";
+import { createHash } from "node:crypto";
+import { validateUiMetadata, validateViewsConfig } from "./3~0.mjs";
+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 = createHash('sha256').update(name).digest('hex').slice(0, 12);
+    return `mcp-ui-${label}-${hash}`;
+}
+function findMfManifest(assets, manifestFile) {
+    const matches = assets.filter((asset)=>node_path.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-${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.mkdir(node_path.dirname(filename), {
+        recursive: true
+    });
+    await promises.writeFile(`${filename}.tmp`, contents);
+    await promises.rename(`${filename}.tmp`, filename);
+}
+const packageFile = (filename)=>node_path.resolve(node_path.dirname(fileURLToPath(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: node_path.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 = ()=>node_path.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.readFile(configPath(), 'utf8'));
+                validateViewsConfig(source);
+                definition = source;
+                const appRequire = createRequire(node_path.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 = node_path.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 = node_path.join(entryDir, `${entryName}.jsx`);
+                    const mountEntry = enableAsyncEntry ? node_path.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(node_path.resolve(node_path.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 = node_path.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 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.readdir(shellOutput, {
+                            recursive: true
+                        }))){
+                            const absolute = node_path.join(shellOutput, filename);
+                            if (!filename.endsWith('.html') && (await promises.stat(absolute)).isFile()) shellAssets.set(filename.replaceAll(node_path.sep, '/'), await promises.readFile(absolute));
+                        }
+                        for (const name of Object.keys(shellEntries))shellHtml.set(name, await promises.readFile(node_path.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 = [
+                    node_path.join(internal, 'mcp-apps/entries') + node_path.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 = node_path.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(node_path.join(output, 'ui', `${name}.html`), html.source.source());
+                            }
+                            for (const [name, html] of shellHtml)await writeArtifact(node_path.join(output, 'ui', `${name}.html`), html);
+                            await writeArtifact(node_path.join(output, 'ui-manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`);
+                        });
+                    }
+                }
+            });
+        }
+    });
+const cli = mcpAppsPlugin;
+export default cli;
+export { mcpAppsPlugin };

package/dist/esm-node/server-plugin.mjs

@@ -0,0 +1,31 @@
+import node_path from "node:path";
+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: node_path.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();
+                    }
+                });
+            });
+        }
+    });
+export default server_plugin;

package/dist/esm-node/server.mjs

@@ -0,0 +1,216 @@
+import { createMcpHandler } from "@modelcontextprotocol/server";
+import { readFile, stat } from "node:fs/promises";
+import node_path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { RESOURCE_MIME_TYPE, registerAppResource } from "@modelcontextprotocol/ext-apps/server";
+import { validateUiManifest, assertHttpUrl } from "./3~0.mjs";
+const requestUiOptions = new WeakMap();
+const manifestCache = new Map();
+const remoteManifestTtl = 60000;
+async function loadUiManifest(source, mode) {
+    const url = source instanceof URL ? new URL(source.href) : /^https?:\/\//.test(source) ? new URL(source) : pathToFileURL(node_path.resolve(source));
+    const production = 'production' === mode;
+    const key = `${production ? 'production' : 'development'}:${url.href}`;
+    let version = 'process';
+    if (!production && 'file:' === url.protocol) {
+        const info = await stat(fileURLToPath(url), {
+            bigint: true
+        });
+        version = `${info.ino}:${info.size}:${info.mtimeNs}:${info.ctimeNs}`;
+    }
+    const cached = manifestCache.get(key);
+    if (cached?.version === version && cached.expiresAt > Date.now()) return cached.value;
+    const entry = {
+        version,
+        expiresAt: 1 / 0,
+        value: readSource(url).then((text)=>{
+            const manifest = JSON.parse(text);
+            validateUiManifest(manifest);
+            if (!production && 'file:' !== url.protocol) entry.expiresAt = Date.now() + remoteManifestTtl;
+            return {
+                manifest,
+                location: url
+            };
+        }).catch((error)=>{
+            if (manifestCache.get(key) === entry) manifestCache.delete(key);
+            throw error;
+        })
+    };
+    manifestCache.set(key, entry);
+    return entry.value;
+}
+async function readSource(url, signal) {
+    if ('file:' === url.protocol) return readFile(fileURLToPath(url), {
+        encoding: 'utf8',
+        signal
+    });
+    assertHttpUrl(url.href);
+    const response = await fetch(url, {
+        signal: signal ? AbortSignal.any([
+            signal,
+            AbortSignal.timeout(30000)
+        ]) : AbortSignal.timeout(30000)
+    });
+    if (!response.ok) throw new Error(`Failed to read UI resource: HTTP ${response.status}`);
+    return response.text();
+}
+function publicBase(manifest, options) {
+    const configured = options.assetBase ?? manifest.assetBase;
+    if ('request' !== configured) {
+        const base = assertHttpUrl(configured);
+        if (!base.pathname.endsWith('/')) base.pathname += '/';
+        return base;
+    }
+    if (!options.request) throw new Error('Request-relative UI assets require a request or an explicit assetBase');
+    return new URL('/', requestOrigin(options.request));
+}
+function requestOrigin(request) {
+    const url = new URL(request.url);
+    const proto = request.headers.get('x-forwarded-proto')?.split(',')[0].trim();
+    if ('https' === proto || 'http' === proto) url.protocol = `${proto}:`;
+    return url.origin;
+}
+function escapeAttribute(value) {
+    return value.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;');
+}
+async function registerUiResources(server, options = {}) {
+    const injected = options.request && requestUiOptions.get(options.request);
+    options = {
+        ...options,
+        manifest: options.manifest ?? injected?.manifest,
+        mode: options.mode ?? injected?.mode
+    };
+    if (!options.manifest) throw new Error('MCP UI manifest is required. Use the Modern.js MCP Apps server plugin with a request or pass an explicit manifest path or URL');
+    const { manifest, location } = await loadUiManifest(options.manifest, options.mode ?? 'production');
+    const base = publicBase(manifest, options);
+    const devSocket = 'development' === options.mode && options.request ? new URL(requestOrigin(options.request)) : void 0;
+    if (devSocket) devSocket.protocol = 'https:' === devSocket.protocol ? 'wss:' : 'ws:';
+    const uris = Object.create(null);
+    for (const [name, view] of Object.entries(manifest.views)){
+        const uri = `ui://app/${encodeURIComponent(name)}`;
+        uris[name] = uri;
+        const remote = 'remote' in view ? manifest.remotes[view.remote] : void 0;
+        const entry = remote ? new URL(remote.entry, base).href : void 0;
+        const ui = {
+            ...view.ui,
+            csp: {
+                ...view.ui.csp,
+                resourceDomains: [
+                    ...new Set([
+                        ...view.ui.csp?.resourceDomains ?? [],
+                        base.origin,
+                        ...entry ? [
+                            new URL(entry).origin
+                        ] : []
+                    ])
+                ],
+                baseUriDomains: [
+                    ...new Set([
+                        ...view.ui.csp?.baseUriDomains ?? [],
+                        base.origin
+                    ])
+                ],
+                connectDomains: [
+                    ...new Set([
+                        ...view.ui.csp?.connectDomains ?? [],
+                        base.origin,
+                        ...entry ? [
+                            new URL(entry).origin
+                        ] : [],
+                        ...devSocket ? [
+                            devSocket.origin
+                        ] : []
+                    ])
+                ]
+            }
+        };
+        registerAppResource(server, name, uri, {
+            _meta: {
+                ui
+            }
+        }, async (_uri, extra)=>{
+            const source = 'html' in view ? view.html : remote.shell;
+            const sourceUrl = /^https?:\/\//.test(source) ? new URL(source) : new URL(source, location);
+            let html = await readSource(sourceUrl, options.request ? AbortSignal.any([
+                options.request.signal,
+                extra.mcpReq.signal
+            ]) : extra.mcpReq.signal);
+            if (!/<head\b[^>]*>/i.test(html)) throw new Error('UI HTML requires a head element');
+            if (/<base\b/i.test(html)) throw new Error('UI HTML must not contain a base element');
+            const config = remote && 'expose' in view ? `<script type="application/json" id="modern-mcp-config">${JSON.stringify({
+                name: view.remote,
+                entry,
+                expose: view.expose,
+                view: name
+            }).replace(/</g, '\\u003c')}</script>` : '';
+            html = html.replace(/<head\b[^>]*>/i, (head)=>`${head}<base href="${escapeAttribute(base.href)}">${config}`);
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: RESOURCE_MIME_TYPE,
+                        text: html,
+                        _meta: {
+                            ui
+                        }
+                    }
+                ]
+            };
+        });
+    }
+    return uris;
+}
+async function currentContext(useContext) {
+    if (useContext) return useContext();
+    const { useHonoContext } = await import("@modern-js/server-runtime");
+    return useHonoContext();
+}
+function createFetchHandler(createServer, options = {}) {
+    const handler = createMcpHandler(({ requestInfo })=>{
+        if (!requestInfo) throw new Error('MCP HTTP request is required');
+        return createServer(requestInfo);
+    }, {
+        legacy: 'stateless',
+        onerror: options.onError
+    });
+    return async (request)=>{
+        const origin = request.headers.get('origin');
+        if (origin && ![
+            new URL(request.url).origin,
+            requestOrigin(request),
+            ...options.allowedOrigins ?? []
+        ].includes(origin)) return new Response('Forbidden origin', {
+            status: 403
+        });
+        return handler.fetch(request);
+    };
+}
+function createBffHandlers(createServer, options = {}) {
+    const { useContext, ...fetchOptions } = options;
+    const handle = createFetchHandler(async (request)=>{
+        const uiOptions = (await currentContext(useContext)).get('locals')?.modernMcpApps;
+        if (uiOptions) requestUiOptions.set(request, uiOptions);
+        return createServer(request);
+    }, fetchOptions);
+    const route = async (input)=>{
+        const context = await currentContext(useContext);
+        const raw = context.req.raw;
+        const headers = new Headers(raw.headers);
+        headers.delete('content-length');
+        const request = new Request(raw.url, {
+            method: raw.method,
+            headers,
+            ...'GET' === raw.method || 'HEAD' === raw.method ? {} : {
+                body: void 0 === input.data ? '' : JSON.stringify(input.data)
+            },
+            signal: raw.signal
+        });
+        return handle(request);
+    };
+    return {
+        POST: route,
+        GET: route,
+        DELETE: route
+    };
+}
+export { createBffHandlers, createFetchHandler, registerUiResources };

package/dist/types/cli/build.d.ts

@@ -0,0 +1,23 @@
+import { type McpViewsConfig, type UiManifest, type UiMetadata } from '../manifest.js';
+export type UiCsp = NonNullable<UiMetadata['csp']>;
+export declare function viewEntryName(name: string): string;
+export interface MfManifest {
+    name: string;
+    exposes: Array<{
+        name: string;
+    }>;
+}
+/** Identify the MF manifest by filename. Stats files share its shape. */
+export declare function findMfManifest(assets: ReadonlyArray<{
+    name: string;
+    source: {
+        source(): string | Buffer;
+    };
+}>, manifestFile: string): {
+    filename: string;
+    manifest: MfManifest;
+};
+export declare function createUiManifest(config: McpViewsConfig, prefix: unknown, mf?: {
+    manifest: MfManifest;
+    filename: string;
+}, csp?: UiCsp): UiManifest;

package/dist/types/cli/index.d.ts

@@ -0,0 +1,16 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+import { type UiCsp } from './build.js';
+export interface McpAppsPluginOptions {
+    /** JSON UI configuration, relative to the application root. */
+    views?: string;
+    /** CSP domains added to every view, merged with the csp in the views file. */
+    csp?: UiCsp;
+    mf?: {
+        /** MF manifest filename in the build output. Defaults to 'mf-manifest.json'. */
+        manifestFile?: string;
+        /** Module providing the shell's MF `createInstance`. Defaults to '@module-federation/enhanced/runtime'. */
+        runtime?: string;
+    };
+}
+export declare const mcpAppsPlugin: (options?: McpAppsPluginOptions) => CliPlugin<AppTools>;
+export default mcpAppsPlugin;

package/dist/types/cli/server-plugin.d.ts

@@ -0,0 +1,6 @@
+import type { ServerPlugin } from '@modern-js/server-runtime';
+export interface McpAppsServerOptions {
+    developmentManifest?: string;
+}
+export default _default;
+declare function _default(options?: McpAppsServerOptions): ServerPlugin;