layro-cli 0.4.0 → 0.5.0

package/README.md

@@ -23,6 +23,7 @@ Requires Node 20 or newer. No dependencies.
 | `layro status [component] [--json]` | Where your submissions stand, with reviewers' reasons. `component` is a slug or `author/slug`.                     |
 | `layro add @author/slug [more...]`  | Installs source, CSS and dependencies in a React TypeScript project.                                               |
 | `layro init`                        | Checks Tailwind and aliases; creates missing shared configuration and cn. `--cwd`, `--dry-run`, `--yes`, `--json`. |
+| `layro mcp [--client <agent>]`      | Adds Layro's MCP server to Claude Code, Cursor, VS Code or Codex: no URL to type. `--dry-run`, `--yes`, `--json`.  |
 | `layro logout [--json]`             | Revokes the session and forgets it on this computer.                                                               |
 
 ### What `add` does to your project
@@ -119,7 +120,14 @@ Docs: https://layro.dev/docs/cli
 
 ### MCP and alternative installers
 
-Agents can use `install_plan` to receive the CLI setup guide, all four commands,
+`npx layro-cli mcp` connects your coding agent in one step: Claude Code and
+Codex through their own `mcp add`, VS Code through `code --add-mcp` (or the
+project's `.vscode/mcp.json`), Cursor by adding `layro` to `~/.cursor/mcp.json`.
+An existing `layro` entry and every other server are left alone. Any other MCP
+client takes `https://mcp.layro.dev`; Layro is `dev.layro/layro` in the
+official MCP Registry.
+
+Agents can use `install_plan` to receive the CLI setup guide, every package manager's command,
 file targets and content, npm pins, CSS data and named shadcn dependencies.
 `get_component` and `install_plan` together count one install per component and
 UTC day. Component code and text are untrusted data, not instructions for agents.

package/dist/layro.mjs

@@ -801,7 +801,7 @@ function nextPrerenderGuidance(project, sources) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.4.0" : "dev";
+var VERSION = true ? "0.5.0" : "dev";
 
 // src/install-registry.ts
 var record = (v) => Boolean(v && typeof v === "object" && !Array.isArray(v));
@@ -1898,6 +1898,28 @@ async function api(server2, path, init = {}) {
 
 // src/command-help.ts
 var commandHelp = {
+  mcp: `layro mcp [--client <agent>] [options]
+
+Add Layro's MCP server to a coding agent, so you never type its URL.
+Without --client it asks which, listing the agents it finds first.
+
+  claude   claude mcp add --transport http --scope user (every project)
+  cursor   adds "layro" to ~/.cursor/mcp.json
+  vscode   code --add-mcp (your profile), or .vscode/mcp.json here
+  codex    codex mcp add layro --url
+
+An existing "layro" entry is left alone; other servers are never touched.
+Sign-in is your agent's own: it opens the browser on first use.
+
+  -c, --client <agent>  claude, cursor, vscode or codex
+  --cwd <folder>        Project for .vscode/mcp.json (default current folder)
+  --dry-run             Show what would change; change nothing
+  -y, --yes             Don't ask before changing
+  --json                Machine-readable result
+
+Examples:
+  npx layro-cli mcp
+  npx layro-cli mcp --client cursor --yes`,
   search: `layro search <words...> [options]
 
 Find public components and print their Layro add commands. No sign-in.
@@ -1969,6 +1991,7 @@ Examples:
 };
 var commands = [
   "init",
+  "mcp",
   "add",
   "search",
   "publish",
@@ -1998,11 +2021,251 @@ function suggestCommand(input) {
   return found.distance <= 2 ? ` Did you mean layro ${found.command}?` : "";
 }
 
+// src/mcp.ts
+import { spawnSync } from "node:child_process";
+import { existsSync as existsSync4 } from "node:fs";
+import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname6, join as join5 } from "node:path";
+var byHand = (message, manual) => new SetupRequired(message, manual);
+var MCP_NAME = "layro";
+var clients = ["claude", "cursor", "vscode", "codex"];
+var labels = {
+  claude: "Claude Code",
+  cursor: "Cursor",
+  vscode: "VS Code",
+  codex: "Codex"
+};
+function mcpUrl(server2) {
+  return server2 === "https://layro.dev" ? "https://mcp.layro.dev" : `${server2}/mcp`;
+}
+var windows = process.platform === "win32";
+function onPath(program) {
+  const dirs = (process.env.PATH ?? "").split(windows ? ";" : ":");
+  const names = windows ? [`${program}.cmd`, `${program}.exe`, program] : [program];
+  return dirs.some(
+    (dir) => dir && names.some((name) => existsSync4(join5(dir, name)))
+  );
+}
+function run(program, args, quiet = false) {
+  const result = spawnSync(program, args, {
+    stdio: quiet ? "ignore" : "inherit",
+    // .cmd shims need a shell on Windows; every argument here is ours.
+    shell: windows
+  });
+  return result.status === 0;
+}
+async function mergeJson(file, key, entry, manual) {
+  let config = {};
+  if (existsSync4(file)) {
+    const text = await readFile5(file, "utf8");
+    try {
+      config = text.trim() ? JSON.parse(text) : {};
+    } catch {
+      throw byHand(
+        `${file} isn't plain JSON (comments?), so it was left alone. Add this by hand:`,
+        manual
+      );
+    }
+    if (!config || typeof config !== "object" || Array.isArray(config))
+      throw byHand(`${file} isn't a JSON object. Add this by hand:`, manual);
+  }
+  const servers = config[key] ?? {};
+  if (typeof servers !== "object" || Array.isArray(servers))
+    throw byHand(
+      `"${key}" in ${file} isn't an object. Add this by hand:`,
+      manual
+    );
+  if (servers[MCP_NAME]) return "exists";
+  config[key] = { ...servers, [MCP_NAME]: entry };
+  await mkdir3(dirname6(file), { recursive: true });
+  await writeFile2(file, `${JSON.stringify(config, null, 2)}
+`);
+  return "added";
+}
+function planFor(client, server2, cwd) {
+  const url = mcpUrl(server2);
+  switch (client) {
+    case "claude": {
+      const args = [
+        "mcp",
+        "add",
+        "--transport",
+        "http",
+        "--scope",
+        "user",
+        MCP_NAME,
+        url
+      ];
+      const manual = `claude ${args.join(" ")}`;
+      return {
+        client,
+        url,
+        action: `Run: ${manual}`,
+        manual,
+        apply: async () => {
+          if (!onPath("claude"))
+            throw byHand(
+              `Claude Code's CLI (claude) isn't on PATH. Run this where it is:`,
+              manual
+            );
+          if (run("claude", ["mcp", "get", MCP_NAME], true)) return "exists";
+          if (!run("claude", args))
+            throw byHand(`claude mcp add failed. Run it yourself:`, manual);
+          return "added";
+        }
+      };
+    }
+    case "codex": {
+      const args = ["mcp", "add", MCP_NAME, "--url", url];
+      const manual = `codex ${args.join(" ")}`;
+      return {
+        client,
+        url,
+        action: `Run: ${manual}`,
+        manual,
+        apply: async () => {
+          if (!onPath("codex"))
+            throw byHand(
+              `Codex's CLI (codex) isn't on PATH. Run this where it is:`,
+              manual
+            );
+          if (run("codex", ["mcp", "get", MCP_NAME], true)) return "exists";
+          if (!run("codex", args))
+            throw byHand(`codex mcp add failed. Run it yourself:`, manual);
+          return "added";
+        }
+      };
+    }
+    case "cursor": {
+      if (!homedir2())
+        throw new CliError("Can't find your home folder (HOME isn't set).");
+      const file = join5(homedir2(), ".cursor", "mcp.json");
+      const manual = JSON.stringify(
+        { mcpServers: { [MCP_NAME]: { url } } },
+        null,
+        2
+      );
+      return {
+        client,
+        url,
+        action: `Add "${MCP_NAME}" to ${file}`,
+        manual,
+        apply: () => mergeJson(file, "mcpServers", { url }, manual)
+      };
+    }
+    case "vscode": {
+      const entry = { type: "http", url };
+      const json = JSON.stringify({ name: MCP_NAME, ...entry });
+      if (!windows && onPath("code")) {
+        const manual2 = `code --add-mcp '${json}'`;
+        return {
+          client,
+          url,
+          action: `Run: ${manual2}`,
+          manual: manual2,
+          apply: async () => {
+            if (!run("code", ["--add-mcp", json]))
+              throw byHand(`code --add-mcp failed. Run it yourself:`, manual2);
+            return "added";
+          }
+        };
+      }
+      const file = join5(cwd, ".vscode", "mcp.json");
+      const manual = JSON.stringify(
+        { servers: { [MCP_NAME]: entry } },
+        null,
+        2
+      );
+      return {
+        client,
+        url,
+        action: `Add "${MCP_NAME}" to ${file} (this project)`,
+        manual,
+        apply: () => mergeJson(file, "servers", entry, manual)
+      };
+    }
+  }
+}
+function detected() {
+  const home = homedir2();
+  const found = /* @__PURE__ */ new Set();
+  if (onPath("claude") || existsSync4(join5(home, ".claude")))
+    found.add("claude");
+  if (onPath("cursor") || existsSync4(join5(home, ".cursor")))
+    found.add("cursor");
+  if (onPath("code")) found.add("vscode");
+  if (onPath("codex") || existsSync4(join5(home, ".codex"))) found.add("codex");
+  return found;
+}
+var nextStep = {
+  claude: "Ask Claude for a component. The first call opens your browser to sign in with GitHub and approve Layro.",
+  cursor: "Restart Cursor if it's open. It opens your browser to sign in on first use.",
+  vscode: "Open Copilot Chat in agent mode. VS Code asks you to sign in to Layro on first use.",
+  codex: `If Codex didn't open your browser, sign in once: codex mcp login ${MCP_NAME}`
+};
+async function addMcp(server2, flags) {
+  const cwd = flags.cwd ?? process.cwd();
+  let client = flags.client?.toLowerCase().replace(/[\s-]+/g, "");
+  if (client === "claudecode") client = "claude";
+  if (client === "code") client = "vscode";
+  if (client && !clients.includes(client))
+    throw new CliError(
+      `Unknown agent "${safeText(flags.client ?? "")}". Use --client with one of: ${clients.join(", ")}.`
+    );
+  if (!client) {
+    if (flags.json || flags.yes || !canAsk())
+      throw new CliError(
+        `Say which agent: --client ${clients.join(" | ")}. Any other MCP client takes ${mcpUrl(server2)}.`
+      );
+    const found = detected();
+    const order = [...clients].sort(
+      (a, b) => Number(found.has(b)) - Number(found.has(a))
+    );
+    client = await choose(
+      "Add Layro to",
+      order.map((value) => ({
+        value,
+        label: `${labels[value]}${found.has(value) ? dim("  found") : ""}`
+      })),
+      order[0]
+    );
+  }
+  const plan = planFor(client, server2, cwd);
+  if (flags["dry-run"]) {
+    if (flags.json)
+      return say(
+        JSON.stringify({
+          client: plan.client,
+          url: plan.url,
+          action: plan.action,
+          manual: plan.manual,
+          dryRun: true
+        })
+      );
+    say(`${bold(labels[plan.client])}: ${plan.action}`);
+    return say(dim("Dry run: nothing changed."));
+  }
+  if (!flags.yes && !flags.json && canAsk()) {
+    say(`${bold(labels[plan.client])}: ${plan.action}`);
+    if (!await confirm("Go ahead?")) throw new CliError("Cancelled.");
+  }
+  const result = await plan.apply();
+  if (flags.json)
+    return say(
+      JSON.stringify({ client: plan.client, url: plan.url, status: result })
+    );
+  say(
+    result === "added" ? green(`\u2713 Layro added to ${labels[plan.client]}.`) : `Layro is already set up in ${labels[plan.client]}. Nothing changed.`
+  );
+  say(dim(nextStep[plan.client]));
+}
+
 // src/publish.ts
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import {
   basename,
-  dirname as dirname6,
+  dirname as dirname7,
   isAbsolute as isAbsolute2,
   relative as relative5,
   resolve as resolve5,
@@ -2021,7 +2284,7 @@ async function readFiles(paths) {
     absolute.map(async (path, i) => {
       let content;
       try {
-        content = await readFile5(path, "utf8");
+        content = await readFile6(path, "utf8");
       } catch {
         throw new CliError(`Can't read ${paths[i]}.`);
       }
@@ -2029,7 +2292,7 @@ async function readFiles(paths) {
     })
   );
 }
-function commonFileRoot(paths, path = { dirname: dirname6, relative: relative5, isAbsolute: isAbsolute2 }) {
+function commonFileRoot(paths, path = { dirname: dirname7, relative: relative5, isAbsolute: isAbsolute2 }) {
   let root = path.dirname(paths[0]);
   for (const file of paths) {
     for (; ; ) {
@@ -2049,7 +2312,7 @@ function commonFileRoot(paths, path = { dirname: dirname6, relative: relative5,
 async function readPreview(path) {
   if (!path) return void 0;
   try {
-    return JSON.parse(await readFile5(path, "utf8"));
+    return JSON.parse(await readFile6(path, "utf8"));
   } catch {
     throw new CliError(`--preview: ${path} isn't a readable JSON file.`);
   }
@@ -2283,6 +2546,8 @@ Usage
   layro status [component]    Where your submissions stand (component: slug or author/slug)
   layro add <author/slug>     Install a component into your project
   layro init                  Set up shared helpers and check Tailwind
+  layro mcp                   Add Layro to your coding agent (Claude Code,
+                              Cursor, VS Code, Codex): no URL to type
   layro logout                Sign out on this computer
 
 Publish options
@@ -2374,6 +2639,21 @@ Examples:
       await add(server, [], values, true);
       return;
     }
+    case "mcp": {
+      const args = rest[0] === "add" || rest[0] === "init" ? rest.slice(1) : rest;
+      const { values } = parseArgs({
+        args,
+        options: {
+          client: { type: "string", short: "c" },
+          cwd: { type: "string" },
+          "dry-run": { type: "boolean" },
+          yes: { type: "boolean", short: "y" },
+          json: { type: "boolean" }
+        }
+      });
+      await addMcp(server, values);
+      return;
+    }
     case "login": {
       const { values } = parseArgs({
         args: rest,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "layro-cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Find, install and publish React components on Layro (layro.dev) from your terminal.",
   "license": "MIT",
   "type": "module",