aui-mcp-server 0.0.1

package/dist/cli.cjs

@@ -0,0 +1,1088 @@
+#!/usr/bin/env node
+'use strict';
+
+var fs4 = require('fs');
+var path2 = require('path');
+var process2 = require('process');
+var chokidar = require('chokidar');
+var url = require('url');
+var esbuild = require('esbuild');
+var http = require('http');
+var index_js = require('@modelcontextprotocol/sdk/server/index.js');
+var sse_js = require('@modelcontextprotocol/sdk/server/sse.js');
+var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
+var types_js = require('@modelcontextprotocol/sdk/types.js');
+var runtime = require('@module-federation/runtime');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs4__default = /*#__PURE__*/_interopDefault(fs4);
+var path2__default = /*#__PURE__*/_interopDefault(path2);
+var process2__default = /*#__PURE__*/_interopDefault(process2);
+var chokidar__default = /*#__PURE__*/_interopDefault(chokidar);
+var esbuild__default = /*#__PURE__*/_interopDefault(esbuild);
+var http__default = /*#__PURE__*/_interopDefault(http);
+
+/* aui-mcp-server */
+
+function parseToolLogic(toolName, logicFilePath, baseDir) {
+  let targetPath = "";
+  const extensions = [".ts", ".tsx", ".js", ".jsx"];
+  const absPath = path2.isAbsolute(logicFilePath) ? logicFilePath : path2.join(baseDir, logicFilePath);
+  for (const ext of ["", ...extensions]) {
+    if (fs4.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 = fs4.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 = path2.join(process.cwd(), path2.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 fs4.promises.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJsonFile(filePath) {
+  const raw = await fs4.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__default.default.build({
+    stdin: {
+      contents: serverSource,
+      // Resolve from package root so pnpm symlinked deps can be bundled.
+      resolveDir: path2__default.default.resolve(path2__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href)))), ".."),
+      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__default.default.join(outDir, mcpDirname);
+  const catalog = await loadCatalog(options);
+  const manifest = buildAuiMcpManifest(catalog);
+  await fs4.promises.mkdir(mcpDir, { recursive: true });
+  const manifestPath = path2__default.default.join(mcpDir, "manifest.json");
+  await fs4.promises.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  let serverPath;
+  if (options.emitServer !== false) {
+    serverPath = path2__default.default.join(mcpDir, "server.mjs");
+    const serverCode = await bundleAuiMcpServer();
+    await fs4.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 {
+        runtime.init({
+          name: "aui-mcp-mf-host",
+          remotes: [
+            {
+              name: scope,
+              entry: remoteEntryUrl
+            }
+          ]
+        });
+      } catch {
+      }
+      const remoteKey = `${scope}/${loaderPath}`;
+      const mod = await runtime.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 index_js.Server(
+    { name: "aui-x-catalog", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(types_js.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(types_js.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 fs4.promises.access(filePath);
+  const watcher = chokidar__default.default.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 stdio_js.StdioServerTransport());
+    return;
+  }
+  const transports = /* @__PURE__ */ new Map();
+  const httpServer = http__default.default.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 sse_js.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/cli.ts
+function getArg(flag) {
+  const idx = process2__default.default.argv.indexOf(flag);
+  if (idx === -1) return void 0;
+  return process2__default.default.argv[idx + 1];
+}
+function hasFlag(flag) {
+  return process2__default.default.argv.includes(flag);
+}
+function getTransportType() {
+  const v = getArg("--transport") ?? process2__default.default.env["AUI_MCP_TRANSPORT"];
+  return v === "sse" ? "sse" : "stdio";
+}
+function getPort() {
+  const v = getArg("--port") ?? process2__default.default.env["AUI_MCP_PORT"];
+  return v ? Number(v) : 8001;
+}
+function printHelp() {
+  console.log(`aui-mcp (from aui-mcp-server)
+
+Commands:
+  aui-mcp catalog <mf-stats...>  Generate aui-x-catalog.json
+  aui-mcp generate [options]     Generate dist/mcp assets
+  aui-mcp serve [options]        Start MCP server (stdio or SSE)
+  aui-mcp dev [options]          Generate then start server (watch)
+
+Catalog options:
+  -o, --output <path>    Output file (default: aui-x-catalog.json)
+  --dry-run              Print output to stdout
+  -v, --verbose          Verbose logs
+
+Common options:
+  --catalog <path>       Path to aui-x-catalog.json (default: aui-x-catalog.json)
+  --outDir <dir>         Remote dist directory (default: dist)
+  --mcpDirname <name>    Subdir under outDir (default: mcp)
+
+Generate options:
+  --noServer             Only emit manifest.json
+
+Serve options:
+  --manifest <path>      Path to manifest.json (default: dist/mcp/manifest.json)
+  --watch                Enable hot reload (manifest/catalog)
+  --transport <type>     stdio|sse (default: stdio; env: AUI_MCP_TRANSPORT)
+  --port <number>        SSE port (default: 8001; env: AUI_MCP_PORT)
+
+Dev options:
+  --noAutoGenerate       Do not re-generate when catalog changes
+`);
+}
+function readCompiledTypesFromDist(distDir, componentName) {
+  const dtsPath = path2__default.default.join(distDir, "@mf-types", "compiled-types", `${componentName}.d.ts`);
+  if (!fs4__default.default.existsSync(dtsPath)) return void 0;
+  return fs4__default.default.readFileSync(dtsPath, "utf-8");
+}
+function parseCatalogArgs(argv) {
+  const args = argv.slice(3);
+  const opts = {
+    statsFiles: [],
+    output: "aui-x-catalog.json",
+    dryRun: false,
+    verbose: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (!a) continue;
+    if (a === "-o" || a === "--output") {
+      opts.output = args[++i] ?? opts.output;
+      continue;
+    }
+    if (a === "--dry-run") {
+      opts.dryRun = true;
+      continue;
+    }
+    if (a === "--verbose" || a === "-v") {
+      opts.verbose = true;
+      continue;
+    }
+    if (!a.startsWith("-")) {
+      opts.statsFiles.push(a);
+    }
+  }
+  return opts;
+}
+async function cmdCatalog() {
+  const opts = parseCatalogArgs(process2__default.default.argv);
+  if (opts.statsFiles.length === 0) {
+    console.error("Usage: aui-mcp catalog [options] <mf-stats.json...>");
+    console.error("Example: aui-mcp catalog ./dist/mf-stats.json -o ./aui-x-catalog.json");
+    process2__default.default.exitCode = 1;
+    return;
+  }
+  const catalog = {};
+  let hasErrors = false;
+  for (const statsFile of opts.statsFiles) {
+    const absFile = path2__default.default.resolve(process2__default.default.cwd(), statsFile);
+    if (!fs4__default.default.existsSync(absFile)) {
+      console.error(`[aui-mcp] Cannot find mf-stats.json: ${absFile}`);
+      hasErrors = true;
+      continue;
+    }
+    let stats;
+    try {
+      stats = JSON.parse(fs4__default.default.readFileSync(absFile, "utf-8"));
+    } catch (e) {
+      console.error(`[aui-mcp] Failed to parse mf-stats.json: ${absFile}`);
+      console.error(e);
+      hasErrors = true;
+      continue;
+    }
+    const distDir = path2__default.default.dirname(absFile);
+    const result = buildCatalogFromStats({
+      stats,
+      readCompiledTypes: (componentName) => readCompiledTypesFromDist(distDir, componentName)
+    });
+    for (const [name, entry] of Object.entries(result.catalog)) {
+      catalog[name] = entry;
+    }
+    for (const issue of result.issues) {
+      console.warn(
+        `[aui-mcp] \u26A0 ${issue.componentName ?? "unknown"}: ${issue.message}${issue.detail ? ` (${issue.detail})` : ""}`
+      );
+      hasErrors = true;
+    }
+    if (result.missingJsdocComponents.length > 0) {
+      const names = result.missingJsdocComponents.join(", ");
+      console.warn(
+        `[aui-mcp] \u26A0 Missing @aui-component JSDoc: ${names}. Please run skills/aui-jsdoc-gen to write back to source files and retry.`
+      );
+      hasErrors = true;
+    }
+  }
+  if (Object.keys(catalog).length === 0) {
+    console.error("[aui-mcp] No catalog entries were generated successfully.");
+    process2__default.default.exitCode = 1;
+    return;
+  }
+  const outputJson = JSON.stringify(catalog, null, 2) + "\n";
+  if (opts.dryRun) {
+    console.log(outputJson);
+    return;
+  }
+  const outPath = path2__default.default.resolve(process2__default.default.cwd(), opts.output);
+  fs4__default.default.mkdirSync(path2__default.default.dirname(outPath), { recursive: true });
+  fs4__default.default.writeFileSync(outPath, outputJson, "utf-8");
+  console.log(`[aui-mcp] Written: ${outPath}`);
+  if (hasErrors) {
+    console.warn(
+      "[aui-mcp] Some components failed to generate catalog entries (see warnings above), but partial output has been written."
+    );
+  }
+}
+async function cmdGenerate() {
+  const outDir = getArg("--outDir") ?? "dist";
+  const catalogPath = getArg("--catalog") ?? "aui-x-catalog.json";
+  const mcpDirname = getArg("--mcpDirname");
+  const emitServer = !hasFlag("--noServer");
+  const result = await generateAuiMcpAssets({
+    outDir,
+    catalogPath: path2__default.default.resolve(process2__default.default.cwd(), catalogPath),
+    mcpDirname,
+    emitServer
+  });
+  console.log(`Generated: ${result.manifestPath}`);
+  if (result.serverPath) {
+    console.log(`Generated: ${result.serverPath}`);
+  }
+  if (hasFlag("--dev")) {
+    const manifestPath = result.manifestPath;
+    await serveAuiMcpServer({
+      manifestPath,
+      watch: true,
+      transport: getTransportType(),
+      port: getPort()
+    });
+  }
+}
+async function cmdServe() {
+  const outDir = getArg("--outDir") ?? "dist";
+  const mcpDirname = getArg("--mcpDirname") ?? "mcp";
+  const catalogPath = getArg("--catalog") ?? "aui-x-catalog.json";
+  const manifestPath = getArg("--manifest") ?? path2__default.default.join(outDir, mcpDirname, "manifest.json");
+  const useCatalog = hasFlag("--catalog");
+  await serveAuiMcpServer({
+    catalogPath: useCatalog ? path2__default.default.resolve(process2__default.default.cwd(), catalogPath) : void 0,
+    manifestPath: useCatalog ? void 0 : path2__default.default.resolve(process2__default.default.cwd(), manifestPath),
+    watch: hasFlag("--watch") || Boolean(process2__default.default.env["AUI_MCP_WATCH"]),
+    transport: getTransportType(),
+    port: getPort()
+  });
+}
+async function cmdDev() {
+  const outDir = getArg("--outDir") ?? "dist";
+  const catalogPath = path2__default.default.resolve(process2__default.default.cwd(), getArg("--catalog") ?? "aui-x-catalog.json");
+  const mcpDirname = getArg("--mcpDirname") ?? "mcp";
+  const enableAutoGenerate = !hasFlag("--noAutoGenerate");
+  const result = await generateAuiMcpAssets({ outDir, catalogPath, mcpDirname, emitServer: true });
+  if (enableAutoGenerate) {
+    chokidar__default.default.watch(catalogPath, { ignoreInitial: true }).on("change", async () => {
+      try {
+        await generateAuiMcpAssets({ outDir, catalogPath, mcpDirname, emitServer: true });
+        console.error(`[aui-mcp] regenerated from ${catalogPath}`);
+      } catch (err) {
+        console.error("[aui-mcp] regenerate failed:", err);
+      }
+    });
+  }
+  await serveAuiMcpServer({
+    manifestPath: result.manifestPath,
+    watch: true,
+    transport: getTransportType(),
+    port: getPort()
+  });
+}
+async function main() {
+  const cmd = process2__default.default.argv[2];
+  if (!cmd || cmd === "--help" || cmd === "-h") {
+    printHelp();
+    return;
+  }
+  if (cmd === "catalog") {
+    await cmdCatalog();
+    return;
+  }
+  if (cmd === "generate") {
+    await cmdGenerate();
+    return;
+  }
+  if (cmd === "serve") {
+    await cmdServe();
+    return;
+  }
+  if (cmd === "dev") {
+    await cmdDev();
+    return;
+  }
+  console.error(`Unknown command: ${cmd}`);
+  printHelp();
+  process2__default.default.exitCode = 1;
+}
+main().catch((err) => {
+  console.error(err);
+  process2__default.default.exitCode = 1;
+});
+//# sourceMappingURL=cli.cjs.map
+//# sourceMappingURL=cli.cjs.map