aui-mcp-server 0.0.1

package/dist/rsbuild.js

@@ -0,0 +1,1038 @@
+import fs4, { promises, existsSync, readFileSync } from 'fs';
+import path2, { join, dirname, isAbsolute } from 'path';
+import { ModuleFederationPlugin } from '@module-federation/enhanced/rspack';
+import { fileURLToPath } from 'url';
+import esbuild from 'esbuild';
+import http from 'http';
+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 { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { init, loadRemote } from '@module-federation/runtime';
+import { createRequire } from 'module';
+
+/* aui-mcp-server */
+
+function parseToolLogic(toolName, logicFilePath, baseDir) {
+  let targetPath = "";
+  const extensions = [".ts", ".tsx", ".js", ".jsx"];
+  const absPath = isAbsolute(logicFilePath) ? logicFilePath : join(baseDir, logicFilePath);
+  for (const ext of ["", ...extensions]) {
+    if (existsSync(absPath + ext)) {
+      targetPath = absPath + ext;
+      break;
+    }
+  }
+  if (!targetPath) {
+    console.error(`[AUI-X] Tool logic file not found: ${logicFilePath} (base: ${baseDir})`);
+    return null;
+  }
+  const content = readFileSync(targetPath, "utf-8");
+  let description = `Automatically generated tool for ${toolName}.`;
+  let jsdocContent = "";
+  let paramsContent = "";
+  let finalToolName = toolName;
+  const jsdocRegex = /\/\*\*([\s\S]*?)\*\/[\s\S]*?(?:export\s+)?(?:async\s+)?function\s+(\w+)/g;
+  let match;
+  while ((match = jsdocRegex.exec(content)) !== null) {
+    const block = match[1];
+    const funcName = match[2];
+    const toolMatch = block.match(/@tool\s+(\w+)/);
+    if (toolMatch) {
+      if (toolMatch[1] === toolName || toolName.includes("artistevents") || toolName.endsWith("_data")) {
+        jsdocContent = block;
+        finalToolName = toolMatch[1];
+        const pRegex = new RegExp(`(?:export\\s+)?(?:async\\s+)?function\\s+${funcName}\\s*\\(\\s*(?:args|\\{[\\s\\S]*?\\}|)\\s*:\\s*\\{([\\s\\S]*?)\\}\\s*\\)`, "m");
+        const pMatch = content.match(pRegex);
+        if (pMatch) {
+          paramsContent = pMatch[1] || "";
+        }
+        break;
+      }
+    }
+    if (funcName === "loader" && !jsdocContent) {
+      jsdocContent = block;
+      const pRegex = /(?:export\s+)?(?:async\s+)?function\s+loader\s*\(\s*(?:args|\{[\s\S]*?\}|)\s*:\s*\{([\s\S]*?)\}\s*\)/m;
+      const pMatch = content.match(pRegex);
+      if (pMatch) {
+        paramsContent = pMatch[1] || "";
+      }
+    }
+  }
+  const properties = {};
+  const required = [];
+  if (jsdocContent) {
+    const descriptionOverride = jsdocContent.match(/@description\s+([^\n@]+)/);
+    if (descriptionOverride?.[1]) {
+      description = descriptionOverride[1].trim();
+    } else {
+      description = jsdocContent.split("\n").map((l) => l.replace(/^\s*\*\s?/, "").trim()).filter((l) => l && !l.startsWith("@") && !l.startsWith("/") && !l.endsWith("/")).join("\n").trim();
+      description = description.split("\n").filter((l) => !l.trim().startsWith("@")).join(" ").trim();
+    }
+    if (paramsContent) {
+      const fields = paramsContent.split(",").map((f) => f.trim()).filter(Boolean);
+      for (const field of fields) {
+        const fieldMatch = field.match(/^(\w+)(\??):\s*(\w+)/);
+        if (fieldMatch) {
+          const name = fieldMatch[1];
+          const optional = fieldMatch[2] === "?";
+          const rawType = fieldMatch[3];
+          let type = "string";
+          if (rawType === "number") type = "number";
+          if (rawType === "boolean") type = "boolean";
+          properties[name] = { type };
+          if (!optional) required.push(name);
+        }
+      }
+    }
+  }
+  return {
+    name: finalToolName,
+    description,
+    logicFilePath: targetPath,
+    parameters: {
+      type: "object",
+      properties,
+      required: required.length > 0 ? required : void 0
+    }
+  };
+}
+
+// src/catalog/entry.ts
+function propsToSchemaProperties(props) {
+  const result = {};
+  for (const prop of props) {
+    result[prop.name] = {
+      type: "object",
+      ...prop.description ? { description: prop.description } : {},
+      properties: {
+        literalString: { type: "string" },
+        path: { type: "string" }
+      }
+    };
+  }
+  return result;
+}
+function getRequiredProps(props) {
+  return props.filter((p) => !p.optional).map((p) => p.name);
+}
+function buildXLoader(ctx) {
+  return {
+    type: "module-federation",
+    url: ctx.remoteEntryUrl,
+    scope: ctx.stats.id,
+    module: ctx.expose.path
+  };
+}
+function buildFallbackExample(ctx) {
+  const surfaceId = `${ctx.componentName.toLowerCase()}-surface-1`;
+  const componentId = `${ctx.componentName.toLowerCase()}-card`;
+  const required = getRequiredProps(ctx.props);
+  const propsPayload = {};
+  for (const name of required) {
+    propsPayload[name] = { literalString: `<!-- ${name} -->` };
+  }
+  return [
+    {
+      beginRendering: {
+        surfaceId,
+        root: "root-column"
+      }
+    },
+    {
+      surfaceUpdate: {
+        surfaceId,
+        components: [
+          {
+            id: "root-column",
+            component: {
+              Column: {
+                children: { explicitList: [componentId] }
+              }
+            }
+          },
+          {
+            id: componentId,
+            component: {
+              [ctx.componentName]: propsPayload
+            }
+          }
+        ]
+      }
+    }
+  ];
+}
+function generateCatalogEntry(ctx) {
+  const schemaProps = propsToSchemaProperties(ctx.props);
+  const required = getRequiredProps(ctx.props);
+  if (ctx.jsdoc.actions && ctx.jsdoc.actions.length > 0) {
+    for (const actionDef of ctx.jsdoc.actions) {
+      const propName = `${actionDef.name}Action`;
+      const desc = actionDef.description ? `${actionDef.description}${actionDef.replyWith ? ` (Expected reply: ${actionDef.replyWith})` : ""}` : `Trigger server event: ${actionDef.name}`;
+      schemaProps[propName] = {
+        type: "object",
+        description: desc,
+        properties: {
+          name: { type: "string" },
+          context: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                key: { type: "string" },
+                value: { type: "object" }
+              },
+              required: ["key", "value"]
+            }
+          }
+        },
+        required: ["name"]
+      };
+    }
+  }
+  const entry = {
+    type: "object",
+    description: ctx.jsdoc.description ?? `AUI-X MF Remote component: ${ctx.componentName}.`,
+    properties: schemaProps,
+    ...required.length > 0 ? { required } : {},
+    "x-loader": buildXLoader(ctx),
+    "x-example": ctx.jsdoc.example ?? buildFallbackExample(ctx),
+    ...ctx.jsdoc.authRequired !== void 0 ? { "x-auth-required": ctx.jsdoc.authRequired } : {},
+    ...ctx.jsdoc.fallback ? { "x-fallback": ctx.jsdoc.fallback } : {}
+  };
+  const xTools = [];
+  if (ctx.jsdoc.tools && ctx.jsdoc.tools.length > 0) {
+    for (const tool of ctx.jsdoc.tools) {
+      const sourceFile = ctx.expose.file;
+      const baseDir = join(process.cwd(), dirname(sourceFile));
+      const parsed = parseToolLogic(tool.name, tool.logicFile, baseDir);
+      if (parsed && ctx.loaderExpose?.path) {
+        xTools.push({
+          name: parsed.name,
+          description: parsed.description,
+          loader: ctx.loaderExpose.path,
+          parameters: parsed.parameters,
+          logicFilePath: parsed.logicFilePath
+        });
+      }
+    }
+  }
+  if (ctx.loaderExpose) {
+    const loaderFile = ctx.loaderExpose.file;
+    const baseDir = process.cwd();
+    const defaultToolName = `get_${ctx.componentName.toLowerCase()}_data`;
+    const parsed = parseToolLogic(defaultToolName, loaderFile, baseDir);
+    if (parsed) {
+      if (!xTools.find((t) => t.name === parsed.name || t.logicFilePath === parsed.logicFilePath)) {
+        xTools.push({
+          name: parsed.name,
+          description: parsed.description,
+          loader: ctx.loaderExpose.path,
+          parameters: parsed.parameters,
+          logicFilePath: parsed.logicFilePath
+        });
+      }
+    }
+  }
+  if (xTools.length > 0) {
+    entry["x-tools"] = xTools;
+  }
+  return entry;
+}
+
+// src/catalog/parser.ts
+function parseJsDoc(dtsContent) {
+  const jsdocBlockRegex = /\/\*\*([\s\S]*?)\*\//g;
+  let targetBlock = null;
+  for (const match of dtsContent.matchAll(jsdocBlockRegex)) {
+    const block = match[1];
+    if (block?.includes("@aui-component")) {
+      targetBlock = block;
+      break;
+    }
+  }
+  if (!targetBlock) {
+    return { isAuiComponent: false };
+  }
+  const result = { isAuiComponent: true };
+  const lines = targetBlock.split("\n").map((l) => l.replace(/^\s*\*\s?/, "").trimEnd());
+  const descMatch = lines.find((l) => l.startsWith("@description"));
+  if (descMatch) {
+    result.description = descMatch.replace("@description", "").trim();
+  }
+  const authMatch = lines.find((l) => l.startsWith("@auth-required"));
+  if (authMatch) {
+    const val = authMatch.replace("@auth-required", "").trim().toLowerCase();
+    result.authRequired = val === "true";
+  }
+  const fallbackMatch = lines.find((l) => l.startsWith("@fallback"));
+  if (fallbackMatch) {
+    result.fallback = fallbackMatch.replace("@fallback", "").trim();
+  }
+  const exampleStartIdx = lines.findIndex((l) => l.startsWith("@example"));
+  if (exampleStartIdx !== -1) {
+    const exampleLine = lines[exampleStartIdx];
+    if (exampleLine) {
+      const exampleFirstLine = exampleLine.replace("@example", "").trim();
+      const continuationLines = [];
+      for (let i = exampleStartIdx + 1; i < lines.length; i++) {
+        const l = lines[i];
+        if (!l) break;
+        if (/^@\w/.test(l)) break;
+        if (l && !/^[\s[\]{},"'0-9\-+tfn]/.test(l)) break;
+        continuationLines.push(l);
+      }
+      const rawJson = [exampleFirstLine, ...continuationLines].join("\n").trim();
+      if (rawJson) {
+        try {
+          result.example = JSON.parse(rawJson);
+        } catch {
+        }
+      }
+    }
+  }
+  const toolLines = lines.filter((l) => l.startsWith("@tool "));
+  if (toolLines.length > 0) {
+    result.tools = toolLines.map((l) => {
+      const parts = l.replace("@tool", "").trim().split(/\s+/);
+      return {
+        name: parts[0] ?? "",
+        logicFile: parts[1] ?? ""
+      };
+    });
+  }
+  const actionLines = lines.filter((l) => l.startsWith("@action "));
+  if (actionLines.length > 0) {
+    result.actions = actionLines.map((l) => {
+      const raw = l.replace("@action", "").trim();
+      const action = {};
+      const pairs = raw.match(/(\w+)="([^"]*)"/g) || [];
+      for (const p of pairs) {
+        const [k, v] = p.split('="');
+        const key = k?.trim();
+        const val = v?.replace(/"$/, "");
+        if (key === "name") action.name = val;
+        if (key === "description") action.description = val;
+        if (key === "replyWith") action.replyWith = val;
+        if (key === "contextKeys") action.contextKeys = val?.split(",").map((s) => s.trim());
+      }
+      return action;
+    });
+  }
+  return result;
+}
+function needsJsDocFill(dtsContent) {
+  return !dtsContent.includes("@aui-component");
+}
+function parsePropsInterface(dtsContent, componentName) {
+  const patterns = [
+    new RegExp(`interface\\s+${componentName}Properties\\s*\\{([\\s\\S]*?)\\}`, "m"),
+    new RegExp(`interface\\s+${componentName}Props\\s*\\{([\\s\\S]*?)\\}`, "m")
+  ];
+  let interfaceBody = null;
+  for (const pattern of patterns) {
+    const m = dtsContent.match(pattern);
+    const body = m?.[1];
+    if (body) {
+      interfaceBody = body;
+      break;
+    }
+  }
+  if (!interfaceBody) {
+    return [];
+  }
+  const nodeMatch = interfaceBody.match(/node\s*:\s*\{\s*properties\s*:\s*\{([\s\S]*?)\}\s*\}/m);
+  if (nodeMatch) {
+    interfaceBody = nodeMatch[1];
+  }
+  const props = [];
+  const fieldRegex = /^\s*(\w+)(\??):\s*([\s\S]+?)(?:;|$)/;
+  const reserved = ["node", "properties", "literalString", "path"];
+  for (const line of interfaceBody.split("\n")) {
+    const m = line.match(fieldRegex);
+    if (!m) continue;
+    const name = m[1];
+    if (!name || nodeMatch && reserved.includes(name)) continue;
+    const questionMark = m[2];
+    let rawType = m[3]?.trim() ?? "";
+    if (rawType.startsWith("{")) {
+      rawType = "object";
+    }
+    const optional = questionMark === "?";
+    const type = rawType;
+    props.push({ name, type, optional });
+  }
+  return props;
+}
+
+// src/catalog/build.ts
+function buildCatalogFromStats(options) {
+  const { stats, readCompiledTypes } = options;
+  const catalog = {};
+  const issues = [];
+  const missingJsdocComponents = [];
+  const { publicPath, remoteEntry } = stats.metaData;
+  const remoteEntryUrl = publicPath.replace(/\/$/, "") + "/" + [remoteEntry.path, "mf-manifest.json"].filter(Boolean).join("/");
+  const loaderExposes = stats.exposes.filter((e) => e.path.endsWith(".data"));
+  const componentExposes = stats.exposes.filter((e) => !e.path.endsWith(".data"));
+  for (const expose of componentExposes) {
+    const componentName = expose.name;
+    const loaderExpose = loaderExposes.find((le) => le.path === `${expose.path}.data`);
+    const dtsContent = readCompiledTypes(componentName);
+    if (!dtsContent) {
+      issues.push({ componentName, message: "Missing compiled d.ts for component" });
+      continue;
+    }
+    if (needsJsDocFill(dtsContent)) {
+      missingJsdocComponents.push(componentName);
+      issues.push({
+        componentName,
+        message: "Missing @aui-component JSDoc (use skills/aui-jsdoc-gen)"
+      });
+      continue;
+    }
+    const jsdoc = parseJsDoc(dtsContent);
+    const props = parsePropsInterface(dtsContent, componentName);
+    const ctx = {
+      stats,
+      expose,
+      jsdoc,
+      props,
+      componentName,
+      remoteEntryUrl,
+      loaderExpose
+    };
+    try {
+      catalog[componentName] = generateCatalogEntry(ctx);
+    } catch (err) {
+      console.error(`[AUI-X] Failed to generate catalog entry for ${componentName}:`, err);
+      issues.push({
+        componentName,
+        message: "Failed to generate catalog entry",
+        detail: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return { catalog, issues, missingJsdocComponents };
+}
+async function fileExists(filePath) {
+  try {
+    await promises.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJsonFile(filePath) {
+  const raw = await promises.readFile(filePath, "utf-8");
+  return JSON.parse(raw);
+}
+function toSnakeCase(input) {
+  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();
+}
+function toToolName(componentName) {
+  return `get_${toSnakeCase(componentName)}`;
+}
+
+// src/templates.ts
+function buildServerSource() {
+  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);
+`;
+}
+
+// src/generator.ts
+function assertCatalogShape(catalog) {
+  if (!catalog || typeof catalog !== "object" || Array.isArray(catalog)) {
+    throw new Error("Invalid aui-x-catalog.json: expected an object");
+  }
+}
+async function loadCatalog(options) {
+  const catalogPath = options.catalogPath ?? "aui-x-catalog.json";
+  if (!await fileExists(catalogPath)) {
+    throw new Error(`catalog not found: ${catalogPath}`);
+  }
+  const catalog = await readJsonFile(catalogPath);
+  assertCatalogShape(catalog);
+  return catalog;
+}
+function buildAuiMcpManifest(catalog) {
+  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
+  };
+}
+async function bundleAuiMcpServer() {
+  const serverSource = buildServerSource();
+  const result = await esbuild.build({
+    stdin: {
+      contents: serverSource,
+      // Resolve from package root so pnpm symlinked deps can be bundled.
+      resolveDir: path2.resolve(path2.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;
+}
+async function generateAuiMcpAssets(options = {}) {
+  const outDir = options.outDir ?? "dist";
+  const mcpDirname = options.mcpDirname ?? "mcp";
+  const mcpDir = path2.join(outDir, mcpDirname);
+  const catalog = await loadCatalog(options);
+  const manifest = buildAuiMcpManifest(catalog);
+  await promises.mkdir(mcpDir, { recursive: true });
+  const manifestPath = path2.join(mcpDir, "manifest.json");
+  await promises.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  let serverPath;
+  if (options.emitServer !== false) {
+    serverPath = path2.join(mcpDir, "server.mjs");
+    const serverCode = await bundleAuiMcpServer();
+    await promises.writeFile(serverPath, serverCode, "utf-8");
+  }
+  return { manifestPath, serverPath };
+}
+var __mfGlobal = globalThis;
+if (typeof __mfGlobal.self === "undefined") __mfGlobal.self = __mfGlobal;
+if (typeof __mfGlobal.window === "undefined") __mfGlobal.window = __mfGlobal;
+var EMPTY_INPUT_SCHEMA = {
+  type: "object",
+  properties: {},
+  required: []
+};
+async function loadManifestFromFile(manifestPath) {
+  const manifest = await readJsonFile(manifestPath);
+  if (!manifest || typeof manifest !== "object" || manifest.schemaVersion !== 1) {
+    throw new Error(`Invalid manifest: ${manifestPath}`);
+  }
+  return manifest;
+}
+async function loadManifestFromCatalog(catalogPath) {
+  const catalog = await readJsonFile(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) {
+  const map = /* @__PURE__ */ new Map();
+  for (const tool of manifest.tools ?? []) {
+    map.set(tool.name, tool);
+  }
+  return map;
+}
+async function executeCatalogTool(manifest, toolName, args) {
+  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"] ?? [];
+  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}` };
+  }
+  const loaderPath = selectedTool.loader.slice(2);
+  const logicFilePath = selectedTool.logicFilePath;
+  try {
+    const inputArgs = args && typeof args === "object" ? args : {};
+    if (loaderPath) {
+      const scope = xLoader.scope;
+      const remoteEntryUrl = xLoader.url;
+      try {
+        init({
+          name: "aui-mcp-mf-host",
+          remotes: [
+            {
+              name: scope,
+              entry: remoteEntryUrl
+            }
+          ]
+        });
+      } catch {
+      }
+      const remoteKey = `${scope}/${loaderPath}`;
+      const mod = 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 };
+    }
+    if (logicFilePath) {
+      const moduleUrl = new URL(`file://${logicFilePath}`);
+      const mod = 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) {
+    console.error("[aui-mcp] tool execution failed:", error);
+    return {
+      ok: false,
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function createServer(getManifest) {
+  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", text: exec.message }],
+        isError: true
+      };
+    }
+    return {
+      // Return raw loader result as JSON for the Agent to consume.
+      content: [{ type: "text", text: JSON.stringify(exec.value) }]
+    };
+  });
+  return server;
+}
+async function startWatch(filePath, onReload, onReloadError) {
+  await promises.access(filePath);
+  const watcher = chokidar.watch(filePath, { ignoreInitial: true });
+  watcher.on("change", async () => {
+    try {
+      await onReload();
+    } catch (err) {
+      onReloadError(err);
+    }
+  });
+  return watcher;
+}
+async function serveAuiMcpServer(options = {}) {
+  const transport = 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 = manifestPath ? await loadManifestFromFile(manifestPath) : await loadManifestFromCatalog(resolvedCatalogPath);
+  const getRawCatalog = () => {
+    const catalog = {};
+    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();
+        console.error(
+          `[aui-mcp] reloaded: ${(currentManifest.tools ?? []).length} tools from ${watchPath}`
+        );
+      },
+      (error) => {
+        console.error(`[aui-mcp] reload failed:`, error);
+      }
+    );
+  }
+  if (transport === "stdio") {
+    await server.connect(new StdioServerTransport());
+    return;
+  }
+  const transports = /* @__PURE__ */ new Map();
+  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 = [];
+        for await (const chunk of req) {
+          chunks.push(chunk);
+        }
+        let payload = {};
+        try {
+          const raw = Buffer.concat(chunks).toString("utf-8");
+          payload = raw ? JSON.parse(raw) : {};
+        } catch (error) {
+          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;
+        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) {
+      console.error("[aui-mcp] request handler error:", error);
+      res.writeHead(500).end("Internal server error");
+    }
+  });
+  httpServer.on("error", (error) => {
+    console.error("[aui-mcp] http server error:", error);
+  });
+  httpServer.listen(port, () => {
+    console.error(`[aui-mcp] SSE listening on http://localhost:${port}/sse`);
+  });
+}
+
+// src/rspack.ts
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+var AuiMcpRspackPlugin = class {
+  options;
+  devServerStarted = false;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  apply(compiler) {
+    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);
+    }
+  }
+  getOutDir(compiler, compilation) {
+    const rawOutDir = this.options.outDir ?? compilation?.outputOptions?.path ?? compiler?.options?.output?.path ?? compiler?.outputPath ?? "dist";
+    const context = process.cwd();
+    return path2.isAbsolute(rawOutDir) ? rawOutDir : path2.resolve(context, rawOutDir);
+  }
+  isDev(compiler) {
+    if (this.options.dev !== void 0) return this.options.dev;
+    const mode = compiler?.options?.mode;
+    if (mode === "development") return true;
+    if (compiler?.watchMode) return true;
+    return false;
+  }
+  readCompiledTypes(compiler, outDir, componentName) {
+    const entryPath = path2.join(outDir, "@mf-types", `${componentName}.d.ts`);
+    let content = this.readFileFromCompilerOrNodeFs(compiler, entryPath);
+    if (!content) {
+      const compiledPath = path2.join(outDir, "@mf-types", "compiled-types", `${componentName}.d.ts`);
+      content = this.readFileFromCompilerOrNodeFs(compiler, compiledPath);
+    }
+    if (!content) return void 0;
+    const match = content.match(/export \* from '\.\/(compiled-types\/[^']+)'/);
+    if (!match) return content;
+    const realPath = path2.join(outDir, "@mf-types", `${match[1]}.d.ts`);
+    return this.readFileFromCompilerOrNodeFs(compiler, realPath);
+  }
+  readFileFromCompilerOrNodeFs(compiler, absPath) {
+    const ofs = compiler?.outputFileSystem;
+    const readFileSync2 = ofs?.readFileSync;
+    if (typeof readFileSync2 === "function") {
+      try {
+        const resolved = readFileSync2.call(ofs, absPath);
+        return Buffer.isBuffer(resolved) ? resolved.toString("utf-8") : String(resolved);
+      } catch {
+      }
+    }
+    try {
+      if (fs4.existsSync(absPath)) return fs4.readFileSync(absPath, "utf-8");
+    } catch {
+    }
+    return void 0;
+  }
+  async readJsonFromCompilerOrNodeFs(compiler, absPath) {
+    const ofs = compiler?.outputFileSystem;
+    const readFile = ofs?.readFile;
+    if (typeof readFile === "function") {
+      const data = await new Promise((resolve, reject) => {
+        readFile.call(ofs, absPath, (err, buf) => {
+          if (err) return reject(err);
+          const text2 = Buffer.isBuffer(buf) ? buf.toString("utf-8") : String(buf);
+          resolve(text2);
+        });
+      });
+      return JSON.parse(data);
+    }
+    const text = await promises.readFile(absPath, "utf-8");
+    return JSON.parse(text);
+  }
+  async generateCatalogAndMcpAssetsAfterTypes(compiler) {
+    const outDir = this.getOutDir(compiler, void 0);
+    const statsAssetName = this.options.statsAssetName ?? "mf-stats.json";
+    const statsPath = path2.join(outDir, statsAssetName);
+    let stats;
+    try {
+      stats = await this.readJsonFromCompilerOrNodeFs(compiler, statsPath);
+    } catch (err) {
+      console.error(
+        `[aui-mcp-server] Failed to read ${statsAssetName} from ${statsPath}:`,
+        err instanceof Error ? err.message : err
+      );
+      return void 0;
+    }
+    const componentNames = (stats.exposes ?? []).filter((e) => e && typeof e === "object" && typeof e.path === "string" && !e.path.endsWith(".data")).map((e) => 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, 1e3)));
+    }
+    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})` : "";
+      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})` : "";
+      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 void 0;
+    const catalogAssetName = this.options.catalogAssetName ?? "aui-x-catalog.json";
+    const catalogPath = path2.resolve(outDir, catalogAssetName);
+    await promises.mkdir(path2.dirname(catalogPath), { recursive: true });
+    await promises.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;
+  }
+  injectAfterGenerateTypesHook(compiler, mfOptions) {
+    const pluginName = "aui-mcp-server";
+    const rawDts = mfOptions.dts ?? {};
+    mfOptions.dts = isRecord(rawDts) ? rawDts : {};
+    const dts = mfOptions.dts;
+    const rawGenerateTypes = dts.generateTypes ?? {};
+    dts.generateTypes = isRecord(rawGenerateTypes) ? rawGenerateTypes : {};
+    const generateTypes = dts.generateTypes;
+    if (generateTypes.__auiMcpInjectedAfterGenerate) return;
+    generateTypes.__auiMcpInjectedAfterGenerate = true;
+    const userAfter = generateTypes.afterGenerate;
+    generateTypes.afterGenerate = async (...args) => {
+      try {
+        await Promise.resolve(userAfter?.(...args));
+      } catch (err) {
+        console.error(`[${pluginName}] user afterGenerate failed:`, err);
+      }
+      let catalogPath;
+      try {
+        catalogPath = await this.generateCatalogAndMcpAssetsAfterTypes(compiler);
+      } catch (err) {
+        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",
+          port: this.options.port ?? 8001
+        });
+      } catch (err) {
+        console.error(`[${pluginName}] start dev server failed:`, err);
+      }
+    };
+  }
+};
+function auiMcpRsbuildPlugin(options = {}) {
+  return {
+    // Rslib `format: 'mf'` expects this plugin to exist in config.plugins.
+    name: "rsbuild:module-federation-enhanced",
+    setup(api) {
+      const mfOptions = options.mfOptions;
+      if (!mfOptions || typeof mfOptions !== "object") {
+        throw new Error("[aui-mcp-server] Missing required option: mfOptions");
+      }
+      try {
+        const require2 = createRequire(import.meta.url);
+        const { pluginModuleFederation } = require2("@module-federation/rsbuild-plugin");
+        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, utils) => {
+        utils.appendPlugins(
+          new AuiMcpRspackPlugin({
+            ...options,
+            mfOptions,
+            // MF plugin is handled by @module-federation/rsbuild-plugin above.
+            applyModuleFederationPlugin: false
+          })
+        );
+        return config;
+      });
+    }
+  };
+}
+
+export { auiMcpRsbuildPlugin };
+//# sourceMappingURL=rsbuild.js.map
+//# sourceMappingURL=rsbuild.js.map