aui-mcp-server 0.0.1

package/src/server.ts

@@ -0,0 +1,391 @@
+import http from 'node:http';
+import { promises as fs } from 'node:fs';
+
+import chokidar from 'chokidar';
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  type Tool,
+} from '@modelcontextprotocol/sdk/types.js';
+
+import { init, loadRemote } from '@module-federation/runtime';
+
+// In Node.js there is no `self` global by default, but many MF remoteEntry
+// bundles still reference it (especially browser-first builds). Polyfill it so
+// MF runtime can eval remoteEntry safely.
+const __mfGlobal = globalThis as any;
+if (typeof __mfGlobal.self === 'undefined') __mfGlobal.self = __mfGlobal;
+if (typeof __mfGlobal.window === 'undefined') __mfGlobal.window = __mfGlobal;
+
+import type { AuiMcpManifest, AuiXCatalog, AuiXToolDefinition } from './types';
+import { readJsonFile, toToolName } from './utils';
+
+export type TransportType = 'stdio' | 'sse';
+
+export interface ServeAuiMcpServerOptions {
+  /** If provided, server will load tools from manifest.json (recommended for prod) */
+  manifestPath?: string;
+  /** If provided, server will derive tools from aui-x-catalog.json (recommended for dev) */
+  catalogPath?: string;
+  /** Enable hot reload for manifest/catalog */
+  watch?: boolean;
+  /** Transport type */
+  transport?: TransportType;
+  /** SSE port (only for transport=sse) */
+  port?: number;
+}
+
+const EMPTY_INPUT_SCHEMA: Tool['inputSchema'] = {
+  type: 'object',
+  properties: {},
+  required: [],
+};
+
+async function loadManifestFromFile(manifestPath: string): Promise<AuiMcpManifest> {
+  const manifest = await readJsonFile<AuiMcpManifest>(manifestPath);
+  if (!manifest || typeof manifest !== 'object' || (manifest as any).schemaVersion !== 1) {
+    throw new Error(`Invalid manifest: ${manifestPath}`);
+  }
+  return manifest;
+}
+
+async function loadManifestFromCatalog(catalogPath: string): Promise<AuiMcpManifest> {
+  const catalog = await readJsonFile<AuiXCatalog>(catalogPath);
+  if (!catalog || typeof catalog !== 'object' || Array.isArray(catalog)) {
+    throw new Error(`Invalid aui-x-catalog.json: ${catalogPath}`);
+  }
+
+  return {
+    schemaVersion: 1,
+    tools: Object.entries(catalog).map(([componentName, entry]) => ({
+      name: toToolName(componentName),
+      componentName,
+      description: entry.description,
+      inputSchema: EMPTY_INPUT_SCHEMA,
+      entry,
+    })),
+  };
+}
+
+function buildToolMap(manifest: AuiMcpManifest): Map<string, (typeof manifest.tools)[number]> {
+  const map = new Map<string, (typeof manifest.tools)[number]>();
+  for (const tool of manifest.tools ?? []) {
+    map.set(tool.name, tool);
+  }
+  return map;
+}
+
+async function executeCatalogTool(
+  manifest: AuiMcpManifest,
+  toolName: string,
+  args: unknown
+): Promise<{ ok: true; value: unknown } | { ok: false; message: string }> {
+  const tools = buildToolMap(manifest);
+  const tool = tools.get(toolName);
+
+  if (!tool) {
+    return { ok: false, message: `Tool not found: ${toolName}` };
+  }
+
+  const entry = tool.entry;
+  const xLoader = entry['x-loader'];
+  const xTools = (entry['x-tools'] ?? []) as AuiXToolDefinition[];
+
+  if (!xLoader) {
+    return { ok: false, message: `No x-loader config for tool: ${toolName}` };
+  }
+
+  if (!xTools.length) {
+    return { ok: false, message: `No x-tools defined for component: ${tool.componentName}` };
+  }
+
+  const selectedTool = xTools.find((t) => t.name === toolName) ?? xTools[0];
+
+  if (!selectedTool) {
+    return { ok: false, message: `No matching x-tools entry for tool: ${toolName}` };
+  }
+
+  // Prefer MF remote loader when loader path is present; otherwise fall back to local logic file.
+  const loaderPath = selectedTool.loader.slice(2); // Remove "./" prefix 
+  const logicFilePath = selectedTool.logicFilePath;
+
+  try {
+    const inputArgs = (args && typeof args === 'object') ? (args as Record<string, unknown>) : {};
+
+    // MF 2.0 remote loader path (e.g. "./ArtistEvents.data")
+    if (loaderPath) {
+      const scope = xLoader.scope;
+      const remoteEntryUrl = xLoader.url;
+
+      // Initialize MF runtime for this remote; repeated init calls are tolerated.
+      try {
+        init({
+          name: 'aui-mcp-mf-host',
+          remotes: [
+            {
+              name: scope,
+              entry: remoteEntryUrl,
+            },
+          ],
+        });
+      } catch {
+        // Ignore init errors (e.g. duplicate init); runtime will reuse existing instance.
+      }
+
+      const remoteKey = `${scope}/${loaderPath}`;
+      const mod: any = await loadRemote(remoteKey);
+      const loaderFn = mod?.loader ?? mod?.default;
+
+      if (typeof loaderFn !== 'function') {
+        return {
+          ok: false,
+          message: `Loaded MF module '${remoteKey}' does not export a callable loader`,
+        };
+      }
+
+      const result = await loaderFn(inputArgs);
+      return { ok: true, value: result };
+    }
+
+    // Fallback: execute local logic file directly (dev/non-MF mode)
+    if (logicFilePath) {
+      const moduleUrl = new URL(`file://${logicFilePath}`);
+      const mod: any = await import(moduleUrl.href);
+      const loaderFn = mod?.loader ?? mod?.default;
+
+      if (typeof loaderFn !== 'function') {
+        return {
+          ok: false,
+          message: `Local logic file '${logicFilePath}' does not export a callable loader`,
+        };
+      }
+
+      const result = await loaderFn(inputArgs);
+      return { ok: true, value: result };
+    }
+
+    return { ok: false, message: `No executable loader found for tool: ${toolName}` };
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error('[aui-mcp] tool execution failed:', error);
+    return {
+      ok: false,
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+async function createServer(getManifest: () => AuiMcpManifest): Promise<Server> {
+  const server = new Server(
+    { name: 'aui-x-catalog', version: '0.1.0' },
+    { capabilities: { tools: {} } }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const manifest = getManifest();
+    return {
+      tools: (manifest.tools ?? []).map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema ?? EMPTY_INPUT_SCHEMA,
+      })),
+    };
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const manifest = getManifest();
+    const exec = await executeCatalogTool(manifest, request.params.name, request.params.arguments);
+
+    if (!exec.ok) {
+      return {
+        content: [{ type: 'text' as const, text: exec.message }],
+        isError: true,
+      };
+    }
+
+    return {
+      // Return raw loader result as JSON for the Agent to consume.
+      content: [{ type: 'text' as const, text: JSON.stringify(exec.value) }],
+    };
+  });
+
+  return server;
+}
+
+async function startWatch(
+  filePath: string,
+  onReload: () => Promise<void>,
+  onReloadError: (error: unknown) => void
+): Promise<chokidar.FSWatcher> {
+  await fs.access(filePath);
+
+  const watcher = chokidar.watch(filePath, { ignoreInitial: true });
+  watcher.on('change', async () => {
+    try {
+      await onReload();
+    } catch (err) {
+      onReloadError(err);
+    }
+  });
+
+  return watcher;
+}
+
+export async function serveAuiMcpServer(options: ServeAuiMcpServerOptions = {}): Promise<void> {
+  const transport: TransportType = options.transport ?? 'stdio';
+  const port = options.port ?? 8001;
+
+  const manifestPath = options.manifestPath;
+  const catalogPath = options.catalogPath;
+
+  if (!manifestPath && !catalogPath) {
+    throw new Error('Either manifestPath or catalogPath is required');
+  }
+
+  const resolvedCatalogPath = catalogPath ?? '';
+  let currentManifest: AuiMcpManifest = manifestPath
+    ? await loadManifestFromFile(manifestPath)
+    : await loadManifestFromCatalog(resolvedCatalogPath);
+
+  const getRawCatalog = (): AuiXCatalog => {
+    const catalog: AuiXCatalog = {};
+    for (const tool of currentManifest.tools ?? []) {
+      if (tool.entry) {
+        catalog[tool.componentName] = tool.entry;
+      }
+    }
+    return catalog;
+  };
+
+  const server = await createServer(() => currentManifest);
+
+  if (options.watch) {
+    const watchPath = manifestPath ?? resolvedCatalogPath;
+
+    await startWatch(
+      watchPath,
+      async () => {
+        currentManifest = manifestPath
+          ? await loadManifestFromFile(manifestPath)
+          : await loadManifestFromCatalog(resolvedCatalogPath);
+
+        await server.sendToolListChanged();
+        // eslint-disable-next-line no-console
+        console.error(
+          `[aui-mcp] reloaded: ${(currentManifest.tools ?? []).length} tools from ${watchPath}`
+        );
+      },
+      (error) => {
+        // eslint-disable-next-line no-console
+        console.error(`[aui-mcp] reload failed:`, error);
+      }
+    );
+  }
+
+  if (transport === 'stdio') {
+    await server.connect(new StdioServerTransport());
+    return;
+  }
+
+  const transports = new Map<string, SSEServerTransport>();
+
+  const httpServer = http.createServer(async (req, res) => {
+    try {
+      const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+
+      if (req.method === 'GET' && url.pathname === '/catalog') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(getRawCatalog(), null, 2));
+        return;
+      }
+
+      if (req.method === 'POST' && url.pathname === '/call-tool') {
+        const chunks: Buffer[] = [];
+        for await (const chunk of req) {
+          chunks.push(chunk as Buffer);
+        }
+
+        let payload: any = {};
+        try {
+          const raw = Buffer.concat(chunks).toString('utf-8');
+          payload = raw ? JSON.parse(raw) : {};
+        } catch (error) {
+          // eslint-disable-next-line no-console
+          console.error('[aui-mcp] invalid /call-tool payload:', error);
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Invalid JSON payload' }));
+          return;
+        }
+
+        const name = payload.name as string | undefined;
+        const args = payload.arguments ?? payload.args ?? {};
+
+        if (!name || typeof name !== 'string') {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Missing tool name' }));
+          return;
+        }
+
+        const exec = await executeCatalogTool(currentManifest, name, args);
+
+        if (!exec.ok) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: exec.message }));
+          return;
+        }
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(exec.value));
+        return;
+      }
+
+      if (req.method === 'GET' && url.pathname === '/sse') {
+        const transportInstance = new SSEServerTransport('/message', res);
+        transports.set(transportInstance.sessionId, transportInstance);
+        req.on('close', () => {
+          transports.delete(transportInstance.sessionId);
+        });
+        await server.connect(transportInstance);
+        return;
+      }
+
+      if (req.method === 'POST' && url.pathname === '/message') {
+        const sessionId = url.searchParams.get('sessionId');
+        if (!sessionId) {
+          res.writeHead(400).end('Missing sessionId');
+          return;
+        }
+
+        const transportInstance = transports.get(sessionId);
+        if (!transportInstance) {
+          res.writeHead(404).end('Unknown sessionId');
+          return;
+        }
+
+        await transportInstance.handlePostMessage(req, res);
+        return;
+      }
+
+      res.writeHead(404).end('Not found');
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error('[aui-mcp] request handler error:', error);
+      res.writeHead(500).end('Internal server error');
+    }
+  });
+
+  httpServer.on('error', (error) => {
+    // Keep dev workflow resilient: don't crash the whole build process.
+    // eslint-disable-next-line no-console
+    console.error('[aui-mcp] http server error:', error);
+  });
+
+  httpServer.listen(port, () => {
+    // eslint-disable-next-line no-console
+    console.error(`[aui-mcp] SSE listening on http://localhost:${port}/sse`);
+  });
+}

package/src/templates.ts

@@ -0,0 +1,51 @@
+export function buildServerSource(): string {
+  // NOTE: This file is meant to be bundled by esbuild in the generator.
+  // It reads manifest.json next to itself.
+  return `import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const manifestPath = process.env.AUI_MCP_MANIFEST ?? join(__dirname, 'manifest.json');
+const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+
+const server = new Server(
+  { name: 'aui-x-catalog', version: '0.1.0' },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: (manifest.tools ?? []).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema ?? { type: 'object', properties: {}, required: [] },
+    })),
+  };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const toolName = request.params?.name;
+  const tool = (manifest.tools ?? []).find((t) => t.name === toolName);
+  if (!tool) {
+    throw new Error('Tool not found: ' + toolName);
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(tool.entry, null, 2),
+      },
+    ],
+  };
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+`;
+}

package/src/types.ts

@@ -0,0 +1,195 @@
+/**
+ * Shared types for AUI-X catalog & MCP artifacts.
+ */
+
+// ─── MF Stats JSON (dist/mf-stats.json) ─────────────────────────────────────
+
+export interface MfStatsExposes {
+  path: string; // e.g. "./ArtistProfile"
+  id: string; // e.g. "artist_profile_remote:ArtistProfile"
+  name: string; // e.g. "ArtistProfile"
+  file: string; // e.g. "src/ArtistProfile"
+  loader?: string; // MF 2.0 data loader path
+}
+
+export interface MfStats {
+  id: string; // MF scope name, e.g. "artist_profile_remote"
+  name: string;
+  metaData: {
+    remoteEntry: { name: string; path: string; type: string };
+    globalName: string;
+    publicPath: string;
+  };
+  exposes: MfStatsExposes[];
+}
+
+// ─── JSDoc parsing result (from compiled d.ts) ──────────────────────────────
+
+export interface AuiActionDefinition {
+  /**
+   * Action event name sent to the server (e.g. "wish_more_shows").
+   */
+  name: string;
+  /**
+   * Human-readable description for the LLM to understand when to trigger this action.
+   */
+  description?: string;
+  /**
+   * Optional list of context key names sent in the action payload.
+   */
+  contextKeys?: string[];
+  /**
+   * If set, the Agent should reply with this component name when receiving this action.
+   */
+  replyWith?: string;
+}
+
+export interface AuiJsDocTags {
+  isAuiComponent: boolean;
+  description?: string;
+  authRequired?: boolean;
+  fallback?: string;
+  example?: unknown;
+  tools?: { name: string; logicFile: string }[];
+  /** Parsed @action tags – formally declares server-event actions this component can dispatch */
+  actions?: AuiActionDefinition[];
+}
+
+export interface PropDefinition {
+  name: string;
+  type: string;
+  optional: boolean;
+  description?: string;
+}
+
+export interface RemoteContext {
+  stats: MfStats;
+  expose: MfStatsExposes;
+  jsdoc: AuiJsDocTags;
+  props: PropDefinition[];
+  componentName: string;
+  remoteEntryUrl: string;
+  loaderExpose?: MfStatsExposes;
+}
+
+// ─── aui-x-catalog.json ─────────────────────────────────────────────────────
+
+export interface AuiXLoaderConfig {
+  type: 'module-federation';
+  /** remoteEntry.js full url */
+  url: string;
+  /** MF scope name */
+  scope: string;
+  /** MF exposed module path, e.g. "./ArtistProfile" */
+  module: string;
+}
+
+export interface AuiXToolDefinition {
+  /**
+   * Logical tool name exposed to MCP clients.
+   * Typically follows the `get_<component>_...` convention.
+   */
+  name: string;
+
+  /** Human-readable description for the LLM. */
+  description: string;
+
+  /**
+   * MF data loader exposed module path, e.g. "./ArtistEvents.data".
+   *
+   * This is consumed at runtime by the MCP server together with the
+   * component-level `x-loader` config to dynamically load and execute
+   * the corresponding MF 2.0 loader module.
+   */
+  loader: string;
+
+  /** JSON Schema-style parameter definition for MCP tool input. */
+  parameters: Record<string, unknown>;
+
+  /** Optional: local logic file path for dev-server or non-MF execution. */
+  logicFilePath?: string;
+}
+
+export interface AuiXCatalogEntry {
+  type: 'object';
+  description: string;
+
+  /** JSON Schema properties */
+  properties: Record<
+    string,
+    | {
+        type: 'object';
+        description?: string;
+        properties: {
+          literalString?: { type: 'string' };
+          path?: { type: 'string' };
+        };
+      }
+    | {
+        type: 'object';
+        description?: string;
+        properties: {
+          name: { type: 'string' };
+          context?: {
+            type: 'array';
+            items: {
+              type: 'object';
+              properties: {
+                key: { type: 'string' };
+                value: { type: 'object' };
+              };
+              required: ['key', 'value'];
+            };
+          };
+        };
+        required: ['name'];
+      }
+  >;
+
+  required?: string[];
+
+  'x-loader': AuiXLoaderConfig;
+  'x-example'?: unknown;
+  'x-auth-required'?: boolean;
+  'x-fallback'?: string;
+  'x-tools'?: AuiXToolDefinition[];
+}
+
+/** Full aui-x-catalog.json structure */
+export type AuiXCatalog = Record<string, AuiXCatalogEntry>;
+
+// ─── MCP manifest (dist/mcp/manifest.json) ──────────────────────────────────
+
+export interface AuiMcpTool {
+  /** MCP tool name */
+  name: string;
+  /** Component name (key in aui-x-catalog.json) */
+  componentName: string;
+  /** Display description for LLM */
+  description?: string;
+  /** MCP input schema (JSON Schema) */
+  inputSchema: Record<string, unknown>;
+  /** Full catalog entry (includes x-loader, x-example, ...) */
+  entry: AuiXCatalogEntry;
+}
+
+export interface AuiMcpManifest {
+  schemaVersion: 1;
+  tools: AuiMcpTool[];
+}
+
+export interface GenerateAuiMcpAssetsOptions {
+  /** Path to aui-x-catalog.json. Defaults to "aui-x-catalog.json" in cwd */
+  catalogPath?: string;
+  /** dist directory of remote build output, defaults to dist */
+  outDir?: string;
+  /** sub dir inside outDir, defaults to mcp */
+  mcpDirname?: string;
+  /** Whether to emit an executable MCP server bundle */
+  emitServer?: boolean;
+}
+
+export interface GenerateAuiMcpAssetsResult {
+  manifestPath: string;
+  serverPath?: string;
+}

package/src/utils.ts

@@ -0,0 +1,29 @@
+import { promises as fs } from 'node:fs';
+
+export async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function readJsonFile<T>(filePath: string): Promise<T> {
+  const raw = await fs.readFile(filePath, 'utf-8');
+  return JSON.parse(raw) as T;
+}
+
+export function toSnakeCase(input: string): string {
+  return input
+    .trim()
+    .replace(/[\s-]+/g, '_')
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+    .replace(/_+/g, '_')
+    .toLowerCase();
+}
+
+export function toToolName(componentName: string): string {
+  return `get_${toSnakeCase(componentName)}`;
+}

package/test.js

@@ -0,0 +1,16 @@
+import { createInstance,  } from '@module-federation/runtime';
+const host = createInstance({
+    name:'host',
+    remotes:[
+        {
+            name:'music_remotes',
+            entry:'http://localhost:5174/mf-manifest.json'
+        }
+    ]
+});
+
+host.loadRemote('music_remotes/ArtistEvents.data').then(({loader})=>{
+    loader({artist:'xxxx',region:'cn'}).then((data)=>{
+        console.log('loader data',data)
+    })
+});

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}