ply-ui-mcp 0.1.7

package/dist/index.js

@@ -0,0 +1,1165 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// src/catalog.ts
+var import_mcp2 = require("@modelcontextprotocol/sdk/server/mcp.js");
+
+// src/resources.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+
+// src/registry.ts
+var import_zod = require("zod");
+var SITE_URL = "https://ply-ui.com";
+var env = typeof process !== "undefined" && process.env ? process.env : {};
+function firstEnv(...names) {
+  for (const name of names) {
+    const v = env[name]?.trim();
+    if (v) return v;
+  }
+}
+var FREE_REGISTRY_URL = firstEnv("PLY_REGISTRY_URL", "BASE_UI_REGISTRY_URL") || `${SITE_URL}/registry`;
+var PRO_REGISTRY_URL = firstEnv("PLY_PRO_REGISTRY_URL", "BASE_UI_PRO_REGISTRY_URL") || "https://pro.ply-ui.com/registry";
+var registryFileSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  content: import_zod.z.string()
+});
+var registryItemSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  tier: import_zod.z.enum(["free", "pro"]),
+  category: import_zod.z.enum(["application", "page-layout", "block", "widget", "shell", "component"]).optional().default("component"),
+  dependencies: import_zod.z.array(import_zod.z.string()).default([]),
+  registryDependencies: import_zod.z.array(import_zod.z.string()).default([]),
+  description: import_zod.z.string().optional().default(""),
+  usage: import_zod.z.string().optional().default(""),
+  keywords: import_zod.z.array(import_zod.z.string()).optional().default([]),
+  files: import_zod.z.array(registryFileSchema),
+  type: import_zod.z.string().optional()
+});
+var registryIndexSchema = import_zod.z.array(registryItemSchema.omit({ files: true }));
+function itemHaystack(item) {
+  return [item.name, item.description, item.usage, ...item.keywords ?? []].filter(Boolean).join(" ").toLowerCase();
+}
+function isSafeItemName(name) {
+  return /^[a-z0-9][a-z0-9-.]*$/i.test(name) && !name.includes("..");
+}
+async function fetchJson(url, headers = {}) {
+  let res;
+  try {
+    res = await fetch(url, { headers });
+  } catch (err) {
+    throw new Error(
+      `Network error while contacting the registry (${err.message}). Check your connection and try again.`
+    );
+  }
+  if (res.status === 401 || res.status === 403) {
+    throw new Error(
+      `License rejected (HTTP ${res.status}). Check PLY_LICENSE_KEY, or see ${SITE_URL}/pricing.`
+    );
+  }
+  if (res.status === 404) {
+    const e = new Error("Not found");
+    e.code = "NOT_FOUND";
+    throw e;
+  }
+  if (!res.ok) {
+    throw new Error(`Registry request failed (HTTP ${res.status}) for ${url}.`);
+  }
+  return res.json();
+}
+async function fetchIndex() {
+  const data = await fetchJson(`${FREE_REGISTRY_URL}/index.json`);
+  return registryIndexSchema.parse(data);
+}
+async function fetchFreeItem(name) {
+  if (!isSafeItemName(name)) {
+    throw new Error(`Invalid component name: '${name}'.`);
+  }
+  const data = await fetchJson(`${FREE_REGISTRY_URL}/styles/default/${name}.json`);
+  return registryItemSchema.parse(data);
+}
+async function fetchText(url) {
+  let res;
+  try {
+    res = await fetch(url);
+  } catch (err) {
+    throw new Error(`Network error fetching ${url}: ${err.message}`);
+  }
+  if (!res.ok) {
+    throw new Error(`Failed to fetch ${url} (HTTP ${res.status}).`);
+  }
+  return res.text();
+}
+function suggestNames(query, names, limit = 8) {
+  const q = query.toLowerCase().trim();
+  if (!q) return [];
+  const scored = names.map((name) => {
+    const n = name.toLowerCase();
+    let score;
+    if (n === q) score = 0;
+    else if (n.startsWith(q) || q.startsWith(n)) score = 1;
+    else if (n.includes(q) || q.includes(n)) score = 2;
+    else score = 3 + levenshtein(q, n);
+    return { name, score };
+  }).filter((s) => s.score <= 6).sort((a, b) => a.score - b.score || a.name.localeCompare(b.name));
+  return scored.slice(0, limit).map((s) => s.name);
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (!m) return n;
+  if (!n) return m;
+  let prev = Array.from({ length: n + 1 }, (_, i) => i);
+  for (let i = 1; i <= m; i++) {
+    const curr = [i];
+    for (let j = 1; j <= n; j++) {
+      curr[j] = Math.min(
+        prev[j] + 1,
+        curr[j - 1] + 1,
+        prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)
+      );
+    }
+    prev = curr;
+  }
+  return prev[n];
+}
+
+// src/utf8.ts
+function utf8ByteLength(text) {
+  return new TextEncoder().encode(text).byteLength;
+}
+
+// src/resources.ts
+function registerResources(server) {
+  server.registerResource(
+    "registry-index",
+    "ply-ui://registry/index",
+    {
+      title: "Registry index",
+      description: "Public Ply registry index (names, tiers, categories, description, usage, keywords, deps)",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const index = await fetchIndex();
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(index, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "docs-llms",
+    "ply-ui://docs/llms",
+    {
+      title: "llms.txt",
+      description: "Agent-oriented product overview (keep fetching this URL even when MCP is available)",
+      mimeType: "text/plain"
+    },
+    async (uri) => {
+      const text = await fetchText(`${SITE_URL}/llms.txt`);
+      return {
+        contents: [{ uri: uri.href, mimeType: "text/plain", text }]
+      };
+    }
+  );
+  server.registerResource(
+    "docs-catalog",
+    "ply-ui://docs/catalog",
+    {
+      title: "AI component catalog",
+      description: "docs/ai/components.md \u2014 detailed component reference for agents",
+      mimeType: "text/markdown"
+    },
+    async (uri) => {
+      const text = await fetchText(`${SITE_URL}/docs/ai/components.md`);
+      return {
+        contents: [{ uri: uri.href, mimeType: "text/markdown", text }]
+      };
+    }
+  );
+  server.registerResource(
+    "docs-cursor-rules",
+    "ply-ui://docs/cursor-rules",
+    {
+      title: "Cursor / Windsurf project rules",
+      description: "Save as .cursor/rules/base-ui.mdc (or .windsurf/rules/base-ui.md). Teaches assistants to write standalone zoneless Angular 22 with Ply without running MCP.",
+      mimeType: "text/markdown"
+    },
+    async (uri) => {
+      const text = await fetchText(`${SITE_URL}/docs/ai/base-ui.mdc`);
+      return {
+        contents: [{ uri: uri.href, mimeType: "text/markdown", text }]
+      };
+    }
+  );
+  server.registerResource(
+    "docs-snippets",
+    "ply-ui://docs/snippets",
+    {
+      title: "VS Code / Cursor snippets",
+      description: "Save as .vscode/base-ui.code-snippets. Prefixes like ply-card expand usage markup after CLI install.",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const text = await fetchText(`${SITE_URL}/docs/ai/base-ui.code-snippets`);
+      return {
+        contents: [{ uri: uri.href, mimeType: "application/json", text }]
+      };
+    }
+  );
+  server.registerResource(
+    "component",
+    new import_mcp.ResourceTemplate("ply-ui://component/{name}", {
+      list: void 0
+    }),
+    {
+      title: "Component metadata",
+      description: "Registry metadata for one component. Free source files are listed without content; Pro never streams source via MCP in V1.",
+      mimeType: "application/json"
+    },
+    async (uri, vars) => {
+      const name = String(vars.name || "");
+      if (!isSafeItemName(name)) {
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify({ error: `Invalid name: ${name}` })
+            }
+          ]
+        };
+      }
+      const index = await fetchIndex();
+      const entry = index.find((i) => i.name === name);
+      if (!entry) {
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify({ error: `Unknown component: ${name}` })
+            }
+          ]
+        };
+      }
+      if (entry.tier === "pro") {
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(
+                {
+                  ...entry,
+                  files: null,
+                  note: `Pro \u2014 metadata only. ${SITE_URL}/pricing`
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      const item = await fetchFreeItem(name);
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(
+              {
+                name: item.name,
+                tier: item.tier,
+                category: item.category,
+                description: item.description,
+                usage: item.usage,
+                keywords: item.keywords,
+                dependencies: item.dependencies,
+                registryDependencies: item.registryDependencies,
+                files: item.files.map((f) => ({
+                  path: f.name,
+                  bytes: utf8ByteLength(f.content)
+                }))
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/get-component.ts
+var import_zod2 = require("zod");
+
+// src/brand.ts
+var CLI_PACKAGE = "ply-ui-cli";
+var CLI_BIN = "ply-ui-cli";
+var CLI_NPX = `npx ${CLI_BIN}`;
+var MCP_PACKAGE = "ply-ui-mcp";
+var MCP_NPX = `npx -y ${MCP_PACKAGE}`;
+var MCP_SERVER_NAME = "ply";
+
+// src/install-hint.ts
+function cliAddCommand(name) {
+  return name?.trim() ? `${CLI_NPX} add ${name.trim()}` : `${CLI_NPX} add <name>`;
+}
+function installHint(name) {
+  return `This catalog does not write files. Install in the project with \`${cliAddCommand(name)}\`. Local stdio MCP (Cursor, Claude Code) can call add_components instead.`;
+}
+
+// src/result.ts
+function okJson(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+function failJson(message, extra = {}) {
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ ok: false, error: message, ...extra }, null, 2)
+      }
+    ]
+  };
+}
+
+// src/tools/get-component.ts
+var getComponentInput = {
+  name: import_zod2.z.string().describe("Registry component name (e.g. button, card)"),
+  includeSource: import_zod2.z.boolean().optional().default(false).describe(
+    "If true, include free-tier source file contents. Pro source is never returned via MCP in V1."
+  )
+};
+async function getComponent(args) {
+  try {
+    const name = args.name.trim();
+    if (!isSafeItemName(name)) {
+      return failJson(`Invalid component name: '${name}'.`);
+    }
+    const index = await fetchIndex();
+    const entry = index.find((i) => i.name === name);
+    if (!entry) {
+      const suggestions = suggestNames(
+        name,
+        index.map((i) => i.name)
+      );
+      return failJson(`Unknown component: '${name}'.`, {
+        suggestions,
+        listHint: "Call list_components or search_components."
+      });
+    }
+    const base = {
+      ok: true,
+      name: entry.name,
+      tier: entry.tier,
+      category: entry.category || "component",
+      description: entry.description || "",
+      usage: entry.usage || "",
+      keywords: entry.keywords || [],
+      dependencies: entry.dependencies,
+      registryDependencies: entry.registryDependencies,
+      docsUrl: `${SITE_URL}`,
+      pricingUrl: `${SITE_URL}/pricing`
+    };
+    if (entry.tier === "pro") {
+      return okJson({
+        ...base,
+        source: null,
+        installCommand: cliAddCommand(name),
+        note: `Pro component \u2014 metadata only. ${installHint(name)} Pro install also needs PLY_LICENSE_KEY. Buy at ${SITE_URL}/pricing.`
+      });
+    }
+    const item = await fetchFreeItem(name);
+    const files = item.files.map((f) => ({
+      path: f.name,
+      bytes: utf8ByteLength(f.content),
+      ...args.includeSource ? { content: f.content } : {}
+    }));
+    return okJson({
+      ...base,
+      files,
+      includeSource: Boolean(args.includeSource),
+      installCommand: cliAddCommand(name),
+      note: args.includeSource ? `Free source included for reading. ${installHint(name)}` : `Source omitted by default. Pass includeSource=true to read free files here. ${installHint(name)}`
+    });
+  } catch (err) {
+    return failJson(err.message || String(err));
+  }
+}
+
+// src/tools/list-components.ts
+var import_zod3 = require("zod");
+var CATEGORIES = [
+  "application",
+  "page-layout",
+  "block",
+  "widget",
+  "shell",
+  "component"
+];
+var listComponentsInput = {
+  tier: import_zod3.z.enum(["free", "pro", "all"]).optional().default("all").describe("Filter by license tier"),
+  category: import_zod3.z.enum(CATEGORIES).optional().describe("Filter by registry category"),
+  q: import_zod3.z.string().optional().describe("Substring filter on name, description, usage, or keywords (case-insensitive)")
+};
+async function listComponents(args) {
+  try {
+    const index = await fetchIndex();
+    const tier = args.tier ?? "all";
+    const q = args.q?.trim().toLowerCase();
+    let items = index;
+    if (tier !== "all") {
+      items = items.filter((i) => i.tier === tier);
+    }
+    if (args.category) {
+      items = items.filter((i) => (i.category || "component") === args.category);
+    }
+    if (q) {
+      items = items.filter((i) => itemHaystack(i).includes(q));
+    }
+    items = [...items].sort((a, b) => a.name.localeCompare(b.name));
+    return okJson({
+      ok: true,
+      count: items.length,
+      items: items.map((i) => ({
+        name: i.name,
+        tier: i.tier,
+        category: i.category || "component",
+        description: i.description || "",
+        usage: i.usage || "",
+        keywords: i.keywords || [],
+        dependencies: i.dependencies,
+        registryDependencies: i.registryDependencies
+      })),
+      hint: `Use get_component for details. ${installHint()}`
+    });
+  } catch (err) {
+    return failJson(err.message || String(err));
+  }
+}
+
+// src/tools/search-components.ts
+var import_zod4 = require("zod");
+
+// src/aliases.ts
+var COMPONENT_ALIASES = {
+  sheet: "drawer",
+  "side-sheet": "drawer",
+  carousel: "slider",
+  gallery: "slider",
+  "image-slider": "slider",
+  range: "range-slider",
+  "slider-input": "range-slider",
+  "input-slider": "range-slider"
+};
+function canonicalComponentName(name) {
+  const key = name.trim().toLowerCase();
+  return COMPONENT_ALIASES[key] ?? name.trim();
+}
+
+// src/tools/search-components.ts
+var CATEGORIES2 = [
+  "application",
+  "page-layout",
+  "block",
+  "widget",
+  "shell",
+  "component"
+];
+var searchComponentsInput = {
+  query: import_zod4.z.string().min(1).describe('Natural-language or substring query (e.g. "dialog modal", "button"). Matches name, description, usage, and keywords.'),
+  tier: import_zod4.z.enum(["free", "pro", "all"]).optional().default("all").describe("Filter by license tier"),
+  category: import_zod4.z.enum(CATEGORIES2).optional().describe("Filter by registry category"),
+  limit: import_zod4.z.number().int().min(1).max(40).optional().default(12)
+};
+function tokenize(query) {
+  return query.toLowerCase().split(/[^a-z0-9]+/i).map((t) => t.trim()).filter((t) => t.length >= 2);
+}
+async function searchComponents(args) {
+  try {
+    const index = await fetchIndex();
+    const tier = args.tier ?? "all";
+    const limit = args.limit ?? 12;
+    const rawQuery = args.query.trim();
+    const canonical = canonicalComponentName(rawQuery);
+    const variants = [...new Set([rawQuery, canonical].filter(Boolean))];
+    let pool = index;
+    if (tier !== "all") {
+      pool = pool.filter((i) => i.tier === tier);
+    }
+    if (args.category) {
+      pool = pool.filter((i) => (i.category || "component") === args.category);
+    }
+    const names = pool.map((i) => i.name);
+    const byFuzzy = new Set(variants.flatMap((q) => suggestNames(q, names, limit)));
+    const byTokens = pool.filter((i) => {
+      const hay = itemHaystack(i);
+      return variants.some((q) => {
+        const tokens = tokenize(q);
+        return tokens.length > 0 && tokens.every((t) => hay.includes(t));
+      });
+    });
+    const ranked = [
+      ...byTokens.sort((a, b) => a.name.localeCompare(b.name)),
+      ...pool.filter((i) => byFuzzy.has(i.name) && !byTokens.some((t) => t.name === i.name)).sort(
+        (a, b) => [...byFuzzy].indexOf(a.name) - [...byFuzzy].indexOf(b.name)
+      )
+    ].slice(0, limit);
+    return okJson({
+      ok: true,
+      query: args.query,
+      count: ranked.length,
+      matches: ranked.map((i) => ({
+        name: i.name,
+        tier: i.tier,
+        category: i.category || "component",
+        description: i.description || "",
+        usage: i.usage || "",
+        keywords: i.keywords || [],
+        registryDependencies: i.registryDependencies
+      })),
+      hint: `Next: get_component for details. ${installHint()}`
+    });
+  } catch (err) {
+    return failJson(err.message || String(err));
+  }
+}
+
+// src/version.ts
+var PACKAGE_VERSION = "0.1.0";
+
+// src/catalog.ts
+var catalogAnnotations = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: true
+};
+function createCatalogMcpServer() {
+  const server = new import_mcp2.McpServer({
+    name: MCP_SERVER_NAME,
+    version: PACKAGE_VERSION
+  });
+  server.registerTool(
+    "list_components",
+    {
+      title: "List Ply components",
+      description: `List components from the Ply registry. Filter by tier (free|pro|all), category, or name substring. Does not install anything. To copy a component into a project, tell the user to run ${CLI_NPX} add <name>.`,
+      inputSchema: listComponentsInput,
+      annotations: catalogAnnotations
+    },
+    async (args) => listComponents(args)
+  );
+  server.registerTool(
+    "get_component",
+    {
+      title: "Get component details",
+      description: `Get registry metadata for one component (deps, category, file list). Free source only when includeSource=true. Pro source is never streamed via MCP. Does not install; returns installCommand (${CLI_NPX} add <name>).`,
+      inputSchema: getComponentInput,
+      annotations: catalogAnnotations
+    },
+    async (args) => getComponent(args)
+  );
+  server.registerTool(
+    "search_components",
+    {
+      title: "Search Ply components",
+      description: `Fuzzy / token search over registry component names (e.g. "dialog", "sheet", "carousel"). Does not install anything. Prefer this before guessing names, then give the user ${CLI_NPX} add <name> (or local stdio add_components).`,
+      inputSchema: searchComponentsInput,
+      annotations: catalogAnnotations
+    },
+    async (args) => searchComponents(args)
+  );
+  registerResources(server);
+  return server;
+}
+
+// src/tools/add-components.ts
+var import_zod5 = require("zod");
+
+// src/cli.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_child_process = require("child_process");
+function resolveCliEntrypoint() {
+  const envPath = process.env.PLY_CLI_PATH?.trim() || process.env.BASE_UI_CLI_PATH?.trim();
+  if (envPath && import_fs.default.existsSync(envPath)) {
+    return { command: process.execPath, argsPrefix: [envPath] };
+  }
+  const sibling = import_path.default.resolve(__dirname, "../../cli/dist/index.js");
+  if (import_fs.default.existsSync(sibling)) {
+    return { command: process.execPath, argsPrefix: [sibling] };
+  }
+  for (const pkg of [CLI_PACKAGE, "base-ui-cli"]) {
+    try {
+      const pkgJson = require.resolve(`${pkg}/package.json`);
+      const bin = import_path.default.join(import_path.default.dirname(pkgJson), "dist", "index.js");
+      if (import_fs.default.existsSync(bin)) {
+        return { command: process.execPath, argsPrefix: [bin] };
+      }
+    } catch {
+    }
+  }
+  return { command: process.platform === "win32" ? "npx.cmd" : "npx", argsPrefix: ["-y", CLI_PACKAGE] };
+}
+function runCli(cliArgs, options = { cwd: process.cwd() }) {
+  const { command, argsPrefix } = resolveCliEntrypoint();
+  const args = [...argsPrefix, ...cliArgs];
+  const timeoutMs = options.timeoutMs ?? 12e4;
+  return new Promise((resolve) => {
+    const child = (0, import_child_process.spawn)(command, args, {
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env, FORCE_COLOR: "0" }
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      child.kill("SIGTERM");
+      resolve({
+        ok: false,
+        code: null,
+        stdout,
+        stderr: stderr + `
+Timed out after ${timeoutMs}ms`
+      });
+    }, timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ ok: false, code: null, stdout, stderr: err.message });
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ ok: code === 0, code, stdout, stderr });
+    });
+  });
+}
+function resolveProjectCwd(cwd) {
+  const root = cwd?.trim() || process.env.PLY_CWD?.trim() || process.env.BASE_UI_CWD?.trim() || process.cwd();
+  return import_path.default.resolve(root);
+}
+
+// src/tools/add-components.ts
+var addComponentsInput = {
+  names: import_zod5.z.array(import_zod5.z.string().min(1)).min(1).describe("One or more registry component names to install (aliases like sheet \u2192 drawer are resolved)"),
+  cwd: import_zod5.z.string().optional().describe(
+    "Project root containing base-ui.json (defaults to MCP process cwd / PLY_CWD / BASE_UI_CWD)"
+  ),
+  overwrite: import_zod5.z.boolean().optional().default(false).describe("Overwrite existing component folders (maps to CLI --overwrite)"),
+  licenseKey: import_zod5.z.string().optional().describe(
+    "Ply Pro license. Prefer PLY_LICENSE_KEY (or BASE_UI_LICENSE_KEY) in the MCP server env instead of putting a key in chat."
+  )
+};
+async function addComponents(args) {
+  try {
+    const cwd = resolveProjectCwd(args.cwd);
+    const names = [
+      ...new Set(
+        args.names.map((n) => canonicalComponentName(n.trim())).filter(Boolean)
+      )
+    ];
+    if (!names.length) {
+      return failJson("Provide at least one component name.");
+    }
+    for (const name of names) {
+      if (!isSafeItemName(name)) {
+        return failJson(`Invalid component name: '${name}'.`);
+      }
+    }
+    const index = await fetchIndex();
+    const byName = new Map(index.map((i) => [i.name, i]));
+    const unknown = [];
+    const pro = [];
+    const free = [];
+    for (const name of names) {
+      const entry = byName.get(name);
+      if (!entry) {
+        unknown.push(name);
+        continue;
+      }
+      if (entry.tier === "pro") {
+        pro.push(name);
+      } else {
+        free.push(name);
+      }
+    }
+    if (unknown.length) {
+      return failJson("Unknown component name(s).", {
+        unknown,
+        suggestions: unknown.flatMap(
+          (n) => suggestNames(
+            n,
+            index.map((i) => i.name),
+            3
+          )
+        )
+      });
+    }
+    const licenseKey = args.licenseKey?.trim() || process.env.PLY_LICENSE_KEY?.trim() || process.env.BASE_UI_LICENSE_KEY?.trim() || "";
+    if (pro.length && !licenseKey) {
+      return failJson(
+        `Pro components need PLY_LICENSE_KEY (or licenseKey): ${pro.join(", ")}.`,
+        {
+          pro,
+          pricingUrl: `${SITE_URL}/pricing`,
+          note: "Set PLY_LICENSE_KEY on the MCP server process (BASE_UI_LICENSE_KEY still works), then retry. Free components can still be added with this tool.",
+          freeCandidates: free
+        }
+      );
+    }
+    const queue = [...free];
+    const seen = /* @__PURE__ */ new Set();
+    const proDeps = [];
+    while (queue.length) {
+      const name = queue.shift();
+      if (seen.has(name)) continue;
+      seen.add(name);
+      const entry = byName.get(name);
+      if (!entry) continue;
+      if (entry.tier === "pro") {
+        proDeps.push(name);
+        continue;
+      }
+      queue.push(...entry.registryDependencies);
+    }
+    if (proDeps.length && !licenseKey) {
+      return failJson(
+        `Install blocked: free selection depends on Pro components: ${proDeps.join(", ")}.`,
+        {
+          proDependencies: proDeps,
+          pricingUrl: `${SITE_URL}/pricing`
+        }
+      );
+    }
+    const toInstall = [...free, ...pro];
+    const cliArgs = ["add", ...toInstall, "--yes"];
+    if (args.overwrite) cliArgs.push("--overwrite");
+    const result = await runCli(cliArgs, {
+      cwd,
+      env: licenseKey ? { PLY_LICENSE_KEY: licenseKey, BASE_UI_LICENSE_KEY: licenseKey } : void 0
+    });
+    if (!result.ok) {
+      return failJson(`${CLI_BIN} add failed.`, {
+        cwd,
+        names: toInstall,
+        exitCode: result.code,
+        stdout: result.stdout.trim(),
+        stderr: result.stderr.trim(),
+        hint: `Ensure the project was initialized (${CLI_NPX} init --yes). CLI remains the canonical install path.`
+      });
+    }
+    return okJson({
+      ok: true,
+      cwd,
+      installed: toInstall,
+      cli: `${CLI_BIN} add --yes`,
+      stdout: result.stdout.trim(),
+      stderr: result.stderr.trim() || void 0,
+      note: `Files were written by ${CLI_BIN} (canonical installer). MCP does not replace the CLI.`
+    });
+  } catch (err) {
+    return failJson(err.message || String(err));
+  }
+}
+
+// src/tools/diff-components.ts
+var import_zod6 = require("zod");
+var diffComponentsInput = {
+  names: import_zod6.z.array(import_zod6.z.string().min(1)).optional().describe(
+    "Tracked component names to diff. Omit or pass [] to check every component in base-ui-lock.json."
+  ),
+  cwd: import_zod6.z.string().optional().describe(
+    "Project root containing base-ui.json (defaults to MCP process cwd / PLY_CWD)"
+  )
+};
+async function diffComponents(args = {}) {
+  try {
+    const cwd = resolveProjectCwd(args.cwd);
+    const names = (args.names ?? []).map((n) => n.trim()).filter(Boolean);
+    for (const name of names) {
+      if (!isSafeItemName(name)) {
+        return failJson(`Invalid component name: '${name}'.`);
+      }
+    }
+    const cliArgs = names.length ? ["diff", ...names] : ["diff"];
+    const result = await runCli(cliArgs, { cwd });
+    if (!result.ok) {
+      return failJson(`${CLI_BIN} diff failed.`, {
+        cwd,
+        names,
+        exitCode: result.code,
+        stdout: result.stdout.trim(),
+        stderr: result.stderr.trim(),
+        hint: "Project must be initialized and components tracked in base-ui-lock.json."
+      });
+    }
+    return okJson({
+      ok: true,
+      cwd,
+      names: names.length ? names : "all-tracked",
+      cli: names.length ? `${CLI_BIN} diff ${names.join(" ")}` : `${CLI_BIN} diff`,
+      stdout: result.stdout.trim(),
+      stderr: result.stderr.trim() || void 0,
+      note: "Read-only. Use update_components to apply upstream changes."
+    });
+  } catch (err) {
+    return failJson(err.message || String(err));
+  }
+}
+
+// src/tools/doctor.ts
+var import_zod7 = require("zod");
+var doctorInput = {
+  cwd: import_zod7.z.string().optional().describe(
+    "Project root containing base-ui.json (defaults to MCP process cwd / PLY_CWD). Read-only."
+  )
+};
+async function doctor(args = {}) {
+  try {
+    const cwd = resolveProjectCwd(args.cwd);
+    const result = await runCli(["doctor"], { cwd });
+    const body = {
+      cwd,
+      cli: `${CLI_BIN} doctor`,
+      exitCode: result.code,
+      stdout: result.stdout.trim(),
+      stderr: result.stderr.trim() || void 0
+    };
+    if (!result.ok) {
+      return failJson(`${CLI_BIN} doctor reported problems.`, body);
+    }
+    return okJson({ ok: true, ...body });
+  } catch (err) {
+    return failJson(err.message || String(err));
+  }
+}
+
+// src/tools/init-project.ts
+var import_zod8 = require("zod");
+var initProjectInput = {
+  cwd: import_zod8.z.string().optional().describe(
+    "Project root to initialize (defaults to MCP process cwd / PLY_CWD). Always non-interactive (`init --yes`)."
+  )
+};
+async function initProject(args = {}) {
+  try {
+    const cwd = resolveProjectCwd(args.cwd);
+    const result = await runCli(["init", "--yes"], { cwd });
+    if (!result.ok) {
+      return failJson(`${CLI_BIN} init failed.`, {
+        cwd,
+        exitCode: result.code,
+        stdout: result.stdout.trim(),
+        stderr: result.stderr.trim(),
+        hint: `CLI remains the canonical installer: ${CLI_NPX} init --yes`
+      });
+    }
+    return okJson({
+      ok: true,
+      cwd,
+      cli: `${CLI_BIN} init --yes`,
+      stdout: result.stdout.trim(),
+      stderr: result.stderr.trim() || void 0
+    });
+  } catch (err) {
+    return failJson(err.message || String(err));
+  }
+}
+
+// src/tools/update-components.ts
+var import_zod9 = require("zod");
+var updateComponentsInput = {
+  names: import_zod9.z.array(import_zod9.z.string().min(1)).optional().describe(
+    "Tracked component names to update. Omit or pass [] to update every component in base-ui-lock.json."
+  ),
+  cwd: import_zod9.z.string().optional().describe(
+    "Project root containing base-ui.json (defaults to MCP process cwd / PLY_CWD)"
+  ),
+  force: import_zod9.z.boolean().optional().default(false).describe(
+    "On conflict (both local and upstream changed), take the upstream version. Does not revert local-only edits."
+  ),
+  overwriteLocal: import_zod9.z.boolean().optional().default(false).describe(
+    "Also revert files you edited that upstream did not change (`--overwrite-local`). Default skips those files."
+  ),
+  merge: import_zod9.z.boolean().optional().default(false).describe(
+    "On conflict, apply a 3-way merge using the installed snapshot (`--merge`). force still wins."
+  )
+};
+async function updateComponents(args = {}) {
+  try {
+    const cwd = resolveProjectCwd(args.cwd);
+    const names = (args.names ?? []).map((n) => n.trim()).filter(Boolean);
+    for (const name of names) {
+      if (!isSafeItemName(name)) {
+        return failJson(`Invalid component name: '${name}'.`);
+      }
+    }
+    const cliArgs = ["update", ...names, "--yes"];
+    if (args.force) cliArgs.push("--force");
+    if (args.overwriteLocal) cliArgs.push("--overwrite-local");
+    if (args.merge) cliArgs.push("--merge");
+    const result = await runCli(cliArgs, { cwd });
+    if (!result.ok) {
+      return failJson(`${CLI_BIN} update failed.`, {
+        cwd,
+        names,
+        exitCode: result.code,
+        stdout: result.stdout.trim(),
+        stderr: result.stderr.trim(),
+        hint: "Run diff_components first. Conflicts need --force; local-only edits need overwriteLocal."
+      });
+    }
+    return okJson({
+      ok: true,
+      cwd,
+      names: names.length ? names : "all-tracked",
+      force: Boolean(args.force),
+      overwriteLocal: Boolean(args.overwriteLocal),
+      merge: Boolean(args.merge),
+      cli: [CLI_BIN, ...cliArgs].join(" "),
+      stdout: result.stdout.trim(),
+      stderr: result.stderr.trim() || void 0,
+      note: `Files were written by ${CLI_BIN} (canonical updater). MCP does not replace the CLI.`
+    });
+  } catch (err) {
+    return failJson(err.message || String(err));
+  }
+}
+
+// src/server.ts
+function createMcpServer(options = {}) {
+  const mutating = options.mutating !== false;
+  const server = createCatalogMcpServer();
+  if (mutating) {
+    server.registerTool(
+      "add_components",
+      {
+        title: "Add Ply components",
+        description: `Install registry components by shelling to \`${CLI_BIN} add --yes\`. Pro names require PLY_LICENSE_KEY (or licenseKey). Project must already have base-ui.json.`,
+        inputSchema: addComponentsInput
+      },
+      async (args) => addComponents(args)
+    );
+    server.registerTool(
+      "init_project",
+      {
+        title: "Initialize Ply in a project",
+        description: `Run \`${CLI_BIN} init --yes\` in the target directory (writes base-ui.json, styles, icons, editor rules). Always non-interactive.`,
+        inputSchema: initProjectInput
+      },
+      async (args) => initProject(args)
+    );
+    server.registerTool(
+      "doctor",
+      {
+        title: "Verify Ply project setup",
+        description: `Run \`${CLI_BIN} doctor\` (read-only). Returns isError when the CLI exits non-zero.`,
+        inputSchema: doctorInput
+      },
+      async (args) => doctor(args)
+    );
+    server.registerTool(
+      "diff_components",
+      {
+        title: "Diff installed Ply components",
+        description: `Run \`${CLI_BIN} diff\` against tracked components. Read-only. Omit names to check everything in base-ui-lock.json.`,
+        inputSchema: diffComponentsInput
+      },
+      async (args) => diffComponents(args)
+    );
+    server.registerTool(
+      "update_components",
+      {
+        title: "Update installed Ply components",
+        description: `Run \`${CLI_BIN} update --yes\`. Untouched files take upstream. Conflicts skip unless force or merge. Local-only edits skip unless overwriteLocal.`,
+        inputSchema: updateComponentsInput
+      },
+      async (args) => updateComponents(args)
+    );
+  }
+  return server;
+}
+
+// src/http.ts
+var import_node_http = require("http");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+function setCors(res) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+  res.setHeader(
+    "Access-Control-Allow-Headers",
+    "Content-Type, Authorization, Mcp-Session-Id, MCP-Protocol-Version"
+  );
+}
+function unauthorized(res) {
+  setCors(res);
+  res.writeHead(401, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ error: "Unauthorized" }));
+}
+function checkAuth(req, token) {
+  if (!token) return true;
+  const header = req.headers.authorization;
+  return header === `Bearer ${token}`;
+}
+async function readBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) return void 0;
+  return JSON.parse(raw);
+}
+function startHttpServer(options) {
+  const server = (0, import_node_http.createServer)(async (req, res) => {
+    try {
+      const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+      if (req.method === "OPTIONS") {
+        setCors(res);
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      if (url.pathname === "/" && req.method === "GET") {
+        setCors(res);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            ok: true,
+            name: MCP_PACKAGE,
+            version: PACKAGE_VERSION,
+            transport: "streamable-http",
+            mcp: "/mcp",
+            mutating: !options.readOnly
+          })
+        );
+        return;
+      }
+      if (url.pathname !== "/mcp") {
+        setCors(res);
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not found. MCP is POST/GET /mcp." }));
+        return;
+      }
+      if (!checkAuth(req, options.authToken)) {
+        unauthorized(res);
+        return;
+      }
+      setCors(res);
+      const mcp = createMcpServer({ mutating: !options.readOnly });
+      const transport = new import_streamableHttp.StreamableHTTPServerTransport({
+        sessionIdGenerator: void 0
+      });
+      await mcp.connect(transport);
+      const parsedBody = req.method === "POST" ? await readBody(req) : void 0;
+      await transport.handleRequest(req, res, parsedBody);
+    } catch (err) {
+      console.error(`${MCP_PACKAGE} HTTP error:`, err);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+      }
+      if (!res.writableEnded) {
+        res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+      }
+    }
+  });
+  server.listen(options.port, options.host, () => {
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : options.port;
+    console.error(
+      `${MCP_PACKAGE} v${PACKAGE_VERSION} Streamable HTTP on http://${options.host}:${port}/mcp` + (options.readOnly ? " (read-only catalog)" : "")
+    );
+  });
+  return server;
+}
+
+// src/index.ts
+function parseArgs(argv) {
+  let http = argv.includes("--http") || process.env.PLY_MCP_HTTP === "1" || process.env.BASE_UI_MCP_HTTP === "1";
+  let readOnly = argv.includes("--read-only") || process.env.PLY_MCP_READ_ONLY === "1" || process.env.BASE_UI_MCP_READ_ONLY === "1";
+  let port = Number(process.env.PORT || process.env.PLY_MCP_PORT || process.env.BASE_UI_MCP_PORT || 3334);
+  let host = process.env.PLY_MCP_HOST || process.env.BASE_UI_MCP_HOST || (http ? "127.0.0.1" : "127.0.0.1");
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--port" && argv[i + 1]) {
+      port = Number(argv[++i]);
+    } else if (arg?.startsWith("--port=")) {
+      port = Number(arg.slice("--port=".length));
+    } else if (arg === "--host" && argv[i + 1]) {
+      host = argv[++i];
+    } else if (arg?.startsWith("--host=")) {
+      host = arg.slice("--host=".length);
+    }
+  }
+  if (!Number.isFinite(port) || port <= 0) port = 3334;
+  return { http, readOnly, port, host };
+}
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  if (opts.http) {
+    startHttpServer({
+      host: opts.host,
+      port: opts.port,
+      readOnly: opts.readOnly,
+      authToken: process.env.PLY_MCP_AUTH_TOKEN?.trim() || process.env.BASE_UI_MCP_AUTH_TOKEN?.trim() || void 0
+    });
+    return;
+  }
+  const server = createMcpServer({ mutating: true });
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  console.error(`${MCP_PACKAGE} v${PACKAGE_VERSION} ready on stdio`);
+}
+main().catch((err) => {
+  console.error(`${MCP_PACKAGE} failed to start:`, err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map