npm - aui-mcp-server - Versions diffs - 0.0.1 - Mend

aui-mcp-server 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (62) hide show

package/README.md +122 -0
package/dist/cli.cjs +1088 -0
package/dist/cli.cjs.map +1 -0
package/dist/cli.d.cts +1 -0
package/dist/cli.d.ts +1 -0
package/dist/cli.js +1076 -0
package/dist/cli.js.map +1 -0
package/dist/client/index.cjs +619 -0
package/dist/client/index.cjs.map +1 -0
package/dist/client/index.d.cts +194 -0
package/dist/client/index.d.ts +194 -0
package/dist/client/index.js +584 -0
package/dist/client/index.js.map +1 -0
package/dist/index.cjs +1053 -0
package/dist/index.cjs.map +1 -0
package/dist/index.d.cts +163 -0
package/dist/index.d.ts +163 -0
package/dist/index.js +1036 -0
package/dist/index.js.map +1 -0
package/dist/rsbuild.cjs +1049 -0
package/dist/rsbuild.cjs.map +1 -0
package/dist/rsbuild.d.cts +12 -0
package/dist/rsbuild.d.ts +12 -0
package/dist/rsbuild.js +1038 -0
package/dist/rsbuild.js.map +1 -0
package/dist/rspack.cjs +1016 -0
package/dist/rspack.cjs.map +1 -0
package/dist/rspack.d.cts +40 -0
package/dist/rspack.d.ts +40 -0
package/dist/rspack.js +1005 -0
package/dist/rspack.js.map +1 -0
package/dist/server.cjs +304 -0
package/dist/server.cjs.map +1 -0
package/dist/server.d.cts +16 -0
package/dist/server.d.ts +16 -0
package/dist/server.js +297 -0
package/dist/server.js.map +1 -0
package/package.json +72 -0
package/src/catalog/build.ts +89 -0
package/src/catalog/entry.ts +183 -0
package/src/catalog/parser.ts +173 -0
package/src/catalog/tool_parser.ts +145 -0
package/src/cli.ts +318 -0
package/src/client/handshake.ts +166 -0
package/src/client/index.ts +6 -0
package/src/client/registry.tsx +184 -0
package/src/client/types.ts +136 -0
package/src/client/useA2UIStream.ts +378 -0
package/src/client/useLogger.ts +147 -0
package/src/generator.ts +100 -0
package/src/index.ts +17 -0
package/src/mcp-app-poc.html +69 -0
package/src/poc.ts +88 -0
package/src/rsbuild.ts +46 -0
package/src/rspack.ts +282 -0
package/src/server.ts +391 -0
package/src/templates.ts +51 -0
package/src/types.ts +195 -0
package/src/utils.ts +29 -0
package/test.js +16 -0
package/tsconfig.json +19 -0
package/tsup.config.ts +27 -0

package/src/generator.ts ADDED Viewed

@@ -0,0 +1,100 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import esbuild from 'esbuild';
+import type {
+  AuiMcpManifest,
+  AuiXCatalog,
+  GenerateAuiMcpAssetsOptions,
+  GenerateAuiMcpAssetsResult,
+} from './types';
+import { fileExists, readJsonFile, toToolName } from './utils';
+import { buildServerSource } from './templates';
+function assertCatalogShape(catalog: unknown): asserts catalog is AuiXCatalog {
+  if (!catalog || typeof catalog !== 'object' || Array.isArray(catalog)) {
+    throw new Error('Invalid aui-x-catalog.json: expected an object');
+  }
+}
+async function loadCatalog(options: GenerateAuiMcpAssetsOptions): Promise<AuiXCatalog> {
+  const catalogPath = options.catalogPath ?? 'aui-x-catalog.json';
+  if (!(await fileExists(catalogPath))) {
+    throw new Error(`catalog not found: ${catalogPath}`);
+  }
+  const catalog = await readJsonFile<unknown>(catalogPath);
+  assertCatalogShape(catalog);
+  return catalog;
+}
+export function buildAuiMcpManifest(catalog: AuiXCatalog): AuiMcpManifest {
+  const tools = Object.entries(catalog).map(([componentName, entry]) => {
+    return {
+      name: toToolName(componentName),
+      componentName,
+      description: entry.description,
+      inputSchema: { type: 'object', properties: {}, required: [] },
+      entry,
+    };
+  });
+  return {
+    schemaVersion: 1,
+    tools,
+  };
+}
+export async function bundleAuiMcpServer(): Promise<string> {
+  const serverSource = buildServerSource();
+  const result = await esbuild.build({
+    stdin: {
+      contents: serverSource,
+      // Resolve from package root so pnpm symlinked deps can be bundled.
+      resolveDir: path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'),
+      sourcefile: 'aui-mcp-server.generated.ts',
+      loader: 'ts',
+    },
+    bundle: true,
+    platform: 'node',
+    format: 'esm',
+    target: 'node18',
+    write: false,
+    outfile: 'server.mjs',
+    sourcemap: false,
+    logLevel: 'silent',
+  });
+  const outputFile = result.outputFiles?.[0];
+  if (!outputFile) {
+    throw new Error('Failed to bundle MCP server');
+  }
+  return outputFile.text;
+}
+export async function generateAuiMcpAssets(
+  options: GenerateAuiMcpAssetsOptions = {}
+): Promise<GenerateAuiMcpAssetsResult> {
+  const outDir = options.outDir ?? 'dist';
+  const mcpDirname = options.mcpDirname ?? 'mcp';
+  const mcpDir = path.join(outDir, mcpDirname);
+  const catalog = await loadCatalog(options);
+  const manifest = buildAuiMcpManifest(catalog);
+  await fs.mkdir(mcpDir, { recursive: true });
+  const manifestPath = path.join(mcpDir, 'manifest.json');
+  await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+  let serverPath: string | undefined;
+  if (options.emitServer !== false) {
+    serverPath = path.join(mcpDir, 'server.mjs');
+    const serverCode = await bundleAuiMcpServer();
+    await fs.writeFile(serverPath, serverCode, 'utf-8');
+  }
+  return { manifestPath, serverPath };
+}

package/src/index.ts ADDED Viewed

@@ -0,0 +1,17 @@
+export type {
+  AuiMcpManifest,
+  AuiMcpTool,
+  AuiXCatalog,
+  AuiXCatalogEntry,
+  AuiXLoaderConfig,
+  GenerateAuiMcpAssetsOptions,
+  GenerateAuiMcpAssetsResult,
+  MfStats,
+} from './types';
+export { buildAuiMcpManifest, bundleAuiMcpServer, generateAuiMcpAssets } from './generator';
+export { serveAuiMcpServer } from './server';
+export type { ServeAuiMcpServerOptions, TransportType } from './server';
+export { buildCatalogFromStats } from './catalog/build';
+export { auiMcpRsbuildPlugin } from './rsbuild';
+export { AuiMcpRspackPlugin } from './rspack';

package/src/mcp-app-poc.html ADDED Viewed

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AUI-X MCP POC</title>
+    <style>
+        body { font-family: sans-serif; padding: 20px; background: #f0f0f0; }
+        .container { background: white; border-radius: 8px; padding: 20px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+        .status { color: #666; font-size: 0.9em; margin-bottom: 10px; }
+        .result { border-top: 1px solid #eee; margin-top: 10px; padding-top: 10px; }
+        .loader { color: #007bff; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>AUI-X MCP POC</h1>
+        <div id="status" class="status">Connecting to MCP host...</div>
+        <div id="content">
+            <p>This is a POC for the Iframe-based UI in AUI-X.</p>
+        </div>
+        <div id="result" class="result" style="display:none">
+            <h3>Tool Result:</h3>
+            <pre id="tool-output"></pre>
+        </div>
+    </div>
+    <script type="module">
+        // For POC, we'll use a simple postMessage bridge if @modelcontextprotocol/ext-apps is not available as a CDN resource easily
+        // But for verification, we'll try to listen to message events which is what the SDK uses under the hood
+        const statusEl = document.getElementById('status');
+        const resultEl = document.getElementById('result');
+        const outputEl = document.getElementById('tool-output');
+        window.addEventListener('message', (event) => {
+            console.log('Received message:', event.data);
+            // The MCP Apps SDK uses a specific message format for handshake and protocol messages
+            if (event.data && event.data.method === 'initialize') {
+                statusEl.innerText = 'Connected to MCP host';
+                // Send initialize response
+                event.source.postMessage({
+                    jsonrpc: '2.0',
+                    id: event.data.id,
+                    result: {
+                        protocolVersion: '2024-11-05',
+                        capabilities: {},
+                        serverInfo: { name: 'aui-x-poc', version: '0.1.0' }
+                    }
+                }, event.origin);
+            }
+            // Handle tool results
+            if (event.data && event.data.method === 'notifications/toolResult') {
+                const result = event.data.params;
+                statusEl.innerText = 'Tool result received';
+                resultEl.style.display = 'block';
+                outputEl.innerText = JSON.stringify(result, null, 2);
+            }
+        });
+        // Signal that we are ready
+        if (window.parent !== window) {
+            window.parent.postMessage({ type: 'mcp-app-ready' }, '*');
+        }
+    </script>
+</body>
+</html>

package/src/poc.ts ADDED Viewed

@@ -0,0 +1,88 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerAppResource, registerAppTool, RESOURCE_MIME_TYPE } from '@modelcontextprotocol/ext-apps/server';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { z } from 'zod';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+async function main() {
+  const server = new McpServer({
+    name: 'aui-x-poc-server',
+    version: '1.0.0',
+  });
+  const POC_RESOURCE_URI = 'ui://aui-x/poc';
+  // 1. Register the POC Tool
+  registerAppTool(
+    server,
+    'aui_x_poc_tool',
+    {
+      title: 'AUI-X POC Tool',
+      description: 'A simple tool to demonstrate AUI-X Iframe integration',
+      inputSchema: z.object({
+        message: z.string().optional().describe('A message to display in the POC UI'),
+      }),
+      _meta: {
+        ui: {
+          resourceUri: POC_RESOURCE_URI,
+        },
+      },
+    },
+    async (args) => {
+      console.error('[POC] Tool called with:', args);
+      const payload = {
+        tool: 'aui_x_poc_tool',
+        args,
+        resource: {
+            uri: POC_RESOURCE_URI,
+            mimeType: 'text/html;profile=mcp-app'
+        }
+      };
+      return {
+        content: [{ type: 'text', text: JSON.stringify(payload) }],
+        structuredContent: payload,
+      };
+    }
+  );
+  // 2. Register the POC Resource
+  registerAppResource(
+    server,
+    'aui-x-poc-resource',
+    POC_RESOURCE_URI,
+    { mimeType: RESOURCE_MIME_TYPE },
+    async () => {
+      console.error('[POC] Resource requested:', POC_RESOURCE_URI);
+      const htmlPath = path.join(__dirname, 'mcp-app-poc.html');
+      const html = await fs.readFile(htmlPath, 'utf-8');
+      return {
+        contents: [
+          {
+            uri: POC_RESOURCE_URI,
+            mimeType: RESOURCE_MIME_TYPE,
+            text: html,
+            _meta: {
+              ui: {
+                prefersBorder: true,
+              },
+            },
+          },
+        ],
+      };
+    }
+  );
+  console.error('[POC] Server starting...');
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('[POC] Server connected via stdio');
+}
+main().catch((err) => {
+  console.error('[POC] Fatal error:', err);
+  process.exit(1);
+});

package/src/rsbuild.ts ADDED Viewed

@@ -0,0 +1,46 @@
+import type { AuiMcpRspackPluginOptions } from './rspack';
+import { AuiMcpRspackPlugin } from './rspack';
+import { createRequire } from 'node:module';
+/**
+ * Rsbuild plugin wrapper.
+ *
+ * It injects `AuiMcpRspackPlugin` into the underlying Rspack config.
+ */
+export function auiMcpRsbuildPlugin(options: AuiMcpRspackPluginOptions = {}): any {
+  return {
+    // Rslib `format: 'mf'` expects this plugin to exist in config.plugins.
+    name: 'rsbuild:module-federation-enhanced',
+    setup(api: any) {
+      const mfOptions = options.mfOptions;
+      if (!mfOptions || typeof mfOptions !== 'object') {
+        throw new Error('[aui-mcp-server] Missing required option: mfOptions');
+      }
+      // Ensure rslib/rsbuild mf pipeline is enabled without requiring users to add MF plugin themselves.
+      // We load it lazily so non-rsbuild consumers don't need this dependency.
+      try {
+        const require = createRequire(import.meta.url);
+        const { pluginModuleFederation } = require('@module-federation/rsbuild-plugin') as any;
+        pluginModuleFederation(mfOptions,{target:'dual'}).setup?.(api);
+      } catch (err) {
+        throw new Error(
+          `[aui-mcp-server] Failed to load @module-federation/rsbuild-plugin. Please install it. ` +
+            `${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      api.modifyRspackConfig?.((config: any, utils: any) => {
+        utils.appendPlugins(
+          new AuiMcpRspackPlugin({
+            ...options,
+            mfOptions,
+            // MF plugin is handled by @module-federation/rsbuild-plugin above.
+            applyModuleFederationPlugin: false,
+          })
+        );
+        return config;
+      });
+    },
+  };
+}

package/src/rspack.ts ADDED Viewed

@@ -0,0 +1,282 @@
+import fs from 'node:fs';
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+import type { Compiler, RspackPluginInstance } from '@rspack/core';
+import { ModuleFederationPlugin } from '@module-federation/enhanced/rspack';
+import type { MfStats } from './types';
+import { buildCatalogFromStats } from './catalog/build';
+import { generateAuiMcpAssets } from './generator';
+import type { TransportType } from './server';
+import { serveAuiMcpServer } from './server';
+export interface AuiMcpRspackPluginOptions {
+  /** Module Federation options (will be passed to MF plugin). */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  mfOptions?: any;
+  /** If false, will NOT apply ModuleFederationPlugin (useful when MF is managed by a rsbuild plugin). */
+  applyModuleFederationPlugin?: boolean;
+  /** dist output directory (absolute or relative to compiler.context). Defaults to compiler output.path */
+  outDir?: string;
+  /** Sub dir under dist for MCP assets. Defaults to "mcp" */
+  mcpDirname?: string;
+  /** Name of stats asset emitted by MF plugin. Defaults to "mf-stats.json" */
+  statsAssetName?: string;
+  /** Name of generated catalog json in dist root. Defaults to "aui-x-catalog.json" */
+  catalogAssetName?: string;
+  /** Whether to emit an executable MCP server bundle. Defaults to true */
+  emitServer?: boolean;
+  /** Auto start MCP server in watch/dev mode */
+  dev?: boolean;
+  /** Transport type used by auto-started server */
+  transport?: TransportType;
+  /** SSE port used by auto-started server */
+  port?: number;
+}
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+export class AuiMcpRspackPlugin implements RspackPluginInstance {
+  private options: AuiMcpRspackPluginOptions;
+  private devServerStarted = false;
+  constructor(options: AuiMcpRspackPluginOptions = {}) {
+    this.options = options;
+  }
+  apply(compiler: Compiler): void {
+    const pluginName = 'aui-mcp-server';
+    const mfOptions = this.options.mfOptions;
+    if (!mfOptions || typeof mfOptions !== 'object') {
+      throw new Error(`[${pluginName}] Missing required option: mfOptions`);
+    }
+    this.injectAfterGenerateTypesHook(compiler, mfOptions);
+    if (this.options.applyModuleFederationPlugin !== false) {
+      new ModuleFederationPlugin(mfOptions).apply(compiler);
+    }
+  }
+  private getOutDir(compiler: any, compilation: any | undefined): string {
+    const rawOutDir =
+      this.options.outDir ??
+      compilation?.outputOptions?.path ??
+      compiler?.options?.output?.path ??
+      compiler?.outputPath ??
+      'dist';
+    // Prefer process.cwd() because some wrappers (rsbuild/rslib) may set compiler.context
+    // to the workspace root while the actual project output (dist) is relative to cwd.
+    const context = process.cwd();
+    return path.isAbsolute(rawOutDir) ? rawOutDir : path.resolve(context, rawOutDir);
+  }
+  private isDev(compiler: any): boolean {
+    if (this.options.dev !== undefined) return this.options.dev;
+    const mode = compiler?.options?.mode;
+    if (mode === 'development') return true;
+    if (compiler?.watchMode) return true;
+    return false;
+  }
+  private readCompiledTypes(compiler: any, outDir: string, componentName: string): string | undefined {
+    // 1) @mf-types/xxx.d.ts (MF 2.0 standard entry)
+    const entryPath = path.join(outDir, '@mf-types', `${componentName}.d.ts`);
+    let content = this.readFileFromCompilerOrNodeFs(compiler, entryPath);
+    // 2) Fallback: @mf-types/compiled-types/xxx.d.ts
+    if (!content) {
+      const compiledPath = path.join(outDir, '@mf-types', 'compiled-types', `${componentName}.d.ts`);
+      content = this.readFileFromCompilerOrNodeFs(compiler, compiledPath);
+    }
+    if (!content) return undefined;
+    // 3) Proxy file: export * from './compiled-types/xxx'
+    const match = content.match(/export \* from '\.\/(compiled-types\/[^']+)'/);
+    if (!match) return content;
+    const realPath = path.join(outDir, '@mf-types', `${match[1]}.d.ts`);
+    return this.readFileFromCompilerOrNodeFs(compiler, realPath);
+  }
+  private readFileFromCompilerOrNodeFs(compiler: any, absPath: string): string | undefined {
+    // Prefer rspack/webpack outputFileSystem (memfs in dev) if available.
+    const ofs = compiler?.outputFileSystem;
+    const readFileSync = ofs?.readFileSync;
+    if (typeof readFileSync === 'function') {
+      try {
+        const resolved = readFileSync.call(ofs, absPath);
+        return Buffer.isBuffer(resolved) ? resolved.toString('utf-8') : String(resolved);
+      } catch {
+        // ignore and fallback to node fs
+      }
+    }
+    try {
+      if (fs.existsSync(absPath)) return fs.readFileSync(absPath, 'utf-8');
+    } catch {
+      // ignore
+    }
+    return undefined;
+  }
+  private async readJsonFromCompilerOrNodeFs<T>(compiler: any, absPath: string): Promise<T> {
+    const ofs = compiler?.outputFileSystem;
+    const readFile = ofs?.readFile;
+    if (typeof readFile === 'function') {
+      const data = await new Promise<string>((resolve, reject) => {
+        readFile.call(ofs, absPath, (err: any, buf: any) => {
+          if (err) return reject(err);
+          const text = Buffer.isBuffer(buf) ? buf.toString('utf-8') : String(buf);
+          resolve(text);
+        });
+      });
+      return JSON.parse(data) as T;
+    }
+    const text = await fsp.readFile(absPath, 'utf-8');
+    return JSON.parse(text) as T;
+  }
+  private async generateCatalogAndMcpAssetsAfterTypes(compiler: Compiler): Promise<string | undefined> {
+    const outDir = this.getOutDir(compiler, undefined);
+    const statsAssetName = this.options.statsAssetName ?? 'mf-stats.json';
+    const statsPath = path.join(outDir, statsAssetName);
+    let stats: MfStats;
+    try {
+      stats = await this.readJsonFromCompilerOrNodeFs<MfStats>(compiler, statsPath);
+    } catch (err) {
+      // eslint-disable-next-line no-console
+      console.error(
+        `[aui-mcp-server] Failed to read ${statsAssetName} from ${statsPath}:`,
+        err instanceof Error ? err.message : err
+      );
+      return undefined;
+    }
+    // MF dts generation may still be flushing files in dev; wait briefly for compiled-types.
+    const componentNames = (stats.exposes ?? [])
+      .filter((e: any) => e && typeof e === 'object' && typeof e.path === 'string' && !e.path.endsWith('.data'))
+      .map((e: any) => String(e.name))
+      .filter(Boolean);
+    const maxAttempts = 20;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const missing = componentNames.filter((name) => !this.readCompiledTypes(compiler, outDir, name));
+      if (missing.length === 0) break;
+      if (attempt === maxAttempts) break;
+      await new Promise((r) => setTimeout(r, Math.min(200 * attempt, 1000)));
+    }
+    const { catalog, issues, missingJsdocComponents } = buildCatalogFromStats({
+      stats,
+      readCompiledTypes: (componentName) => this.readCompiledTypes(compiler, outDir, componentName),
+    });
+    if (issues.length > 0) {
+      const head = issues
+        .slice(0, 10)
+        .map((i) => `${i.componentName ?? 'unknown'}: ${i.message}`)
+        .join('; ');
+      const tail = issues.length > 10 ? ` ... (+${issues.length - 10})` : '';
+      // eslint-disable-next-line no-console
+      console.warn(`[aui-mcp-server] catalog issues: ${head}${tail}`);
+    }
+    if (missingJsdocComponents.length > 0) {
+      const names = missingJsdocComponents.slice(0, 10).join(', ');
+      const tail = missingJsdocComponents.length > 10 ? ` ... (+${missingJsdocComponents.length - 10})` : '';
+      // eslint-disable-next-line no-console
+      console.warn(
+        `[aui-mcp-server] missing @aui-component JSDoc: ${names}${tail}. Please run skills/aui-jsdoc-gen to write back to source files and retry.`
+      );
+    }
+    if (!isRecord(catalog) || Object.keys(catalog).length === 0) return undefined;
+    const catalogAssetName = this.options.catalogAssetName ?? 'aui-x-catalog.json';
+    const catalogPath = path.resolve(outDir, catalogAssetName);
+    await fsp.mkdir(path.dirname(catalogPath), { recursive: true });
+    await fsp.writeFile(catalogPath, JSON.stringify(catalog, null, 2) + '\n', 'utf-8');
+    await generateAuiMcpAssets({
+      catalogPath,
+      outDir,
+      mcpDirname: this.options.mcpDirname ?? 'mcp',
+      emitServer: this.options.emitServer !== false,
+    });
+    return catalogPath;
+  }
+  private injectAfterGenerateTypesHook(compiler: Compiler, mfOptions: any): void {
+    const pluginName = 'aui-mcp-server';
+    const rawDts = mfOptions.dts ?? {};
+    mfOptions.dts = isRecord(rawDts) ? rawDts : {};
+    const dts = mfOptions.dts as Record<string, unknown>;
+    // MF Plugin expects the hook at: dts.generateTypes.afterGenerate
+    const rawGenerateTypes = (dts as any).generateTypes ?? {};
+    (dts as any).generateTypes = isRecord(rawGenerateTypes) ? rawGenerateTypes : {};
+    const generateTypes = (dts as any).generateTypes as Record<string, unknown>;
+    // Avoid double injection if plugin applied twice.
+    if ((generateTypes as any).__auiMcpInjectedAfterGenerate) return;
+    (generateTypes as any).__auiMcpInjectedAfterGenerate = true;
+    const userAfter = (generateTypes as any).afterGenerate as undefined | ((...args: any[]) => any);
+    (generateTypes as any).afterGenerate = async (...args: any[]) => {
+      try {
+        await Promise.resolve(userAfter?.(...args));
+      } catch (err) {
+        // eslint-disable-next-line no-console
+        console.error(`[${pluginName}] user afterGenerate failed:`, err);
+      }
+      let catalogPath: string | undefined;
+      try {
+        catalogPath = await this.generateCatalogAndMcpAssetsAfterTypes(compiler);
+      } catch (err) {
+        // eslint-disable-next-line no-console
+        console.error(`[${pluginName}] afterGenerate (aui) failed:`, err);
+        return;
+      }
+      if (!catalogPath) return;
+      if (!this.isDev(compiler)) return;
+      if (this.devServerStarted) return;
+      this.devServerStarted = true;
+      try {
+        await serveAuiMcpServer({
+          catalogPath,
+          watch: true,
+          // Dev defaults to SSE so the sample can proxy to /api/tools.
+          transport: (this.options.transport ?? 'sse') as TransportType,
+          port: this.options.port ?? 8001,
+        });
+      } catch (err) {
+        // eslint-disable-next-line no-console
+        console.error(`[${pluginName}] start dev server failed:`, err);
+      }
+    };
+  }
+}